ai-cli-mcp 2.17.0 → 2.19.0

package/dist/__tests__/process-management.test.js

@@ -141,8 +141,9 @@ describe('Process Management Tests', () => {
                 pid: 12345,
                 agent: 'claude',
                 status: 'completed',
-                messages: [
+                events: [
                     {
+                        kind: 'message',
                         ts: expect.any(String),
                         text: 'new message',
                     },
@@ -154,7 +155,7 @@ describe('Process Management Tests', () => {
                 pid: 99999,
                 agent: null,
                 status: 'not_found',
-                messages: [],
+                events: [],
                 truncated: false,
                 error: 'process not found',
             });
@@ -199,8 +200,9 @@ describe('Process Management Tests', () => {
                 pid: 12346,
                 agent: 'opencode',
                 status: 'completed',
-                messages: [
+                events: [
                     {
+                        kind: 'message',
                         ts: expect.any(String),
                         text: 'OpenCode visible text',
                     },
@@ -250,8 +252,9 @@ describe('Process Management Tests', () => {
                 pid: 12347,
                 agent: 'gemini',
                 status: 'completed',
-                messages: [
+                events: [
                     {
+                        kind: 'message',
                         ts: expect.any(String),
                         text: 'Visible Gemini text',
                     },
@@ -260,6 +263,155 @@ describe('Process Management Tests', () => {
                 error: null,
             });
         });
+        it('should include normalized tool_call events when requested', async () => {
+            const { handlers } = await setupServer();
+            const mockProcess = new EventEmitter();
+            mockProcess.pid = 12348;
+            mockProcess.stdout = new EventEmitter();
+            mockProcess.stderr = new EventEmitter();
+            mockProcess.kill = vi.fn();
+            mockSpawn.mockReturnValue(mockProcess);
+            const callToolHandler = handlers.get('callTool');
+            await callToolHandler({
+                params: {
+                    name: 'run',
+                    arguments: {
+                        prompt: 'claude mcp peek prompt',
+                        workFolder: '/tmp',
+                        model: 'haiku',
+                    }
+                }
+            });
+            const peekPromise = callToolHandler({
+                params: {
+                    name: 'peek',
+                    arguments: {
+                        pids: [12348],
+                        peek_time_sec: 1,
+                        include_tool_calls: true,
+                    }
+                }
+            });
+            setTimeout(() => {
+                mockProcess.stdout.emit('data', '{"type":"assistant","message":{"content":[{"type":"tool_use","id":"toolu_1","name":"mcp__acm__list_processes","input":{}}]}}\n');
+                mockProcess.stdout.emit('data', '{"type":"user","message":{"content":[{"tool_use_id":"toolu_1","type":"tool_result","content":[{"type":"text","text":"secret result"}]}]}}\n');
+                mockProcess.stdout.emit('data', '{"type":"assistant","message":{"content":[{"type":"text","text":"MCP succeeded."}]}}\n');
+                mockProcess.emit('close', 0);
+            }, 10);
+            const result = await peekPromise;
+            const response = JSON.parse(result.content[0].text);
+            expect(response.processes).toHaveLength(1);
+            expect(response.processes[0]).toMatchObject({
+                pid: 12348,
+                agent: 'claude',
+                status: 'completed',
+                events: [
+                    {
+                        kind: 'tool_call',
+                        phase: 'started',
+                        id: 'toolu_1',
+                        tool: 'mcp__acm__list_processes',
+                        server: 'acm',
+                        summary: 'acm.list_processes',
+                    },
+                    {
+                        kind: 'tool_call',
+                        phase: 'completed',
+                        id: 'toolu_1',
+                        tool: 'mcp__acm__list_processes',
+                        server: 'acm',
+                        summary: 'acm.list_processes',
+                        status: 'success',
+                    },
+                    {
+                        kind: 'message',
+                        ts: expect.any(String),
+                        text: 'MCP succeeded.',
+                    },
+                ],
+                truncated: false,
+                error: null,
+            });
+            expect(JSON.stringify(response)).not.toContain('secret result');
+        });
+        it('should peek Forge plain-text messages and low-precision tool calls without raw command output', async () => {
+            const { handlers } = await setupServer();
+            const mockProcess = new EventEmitter();
+            mockProcess.pid = 12349;
+            mockProcess.stdout = new EventEmitter();
+            mockProcess.stderr = new EventEmitter();
+            mockProcess.kill = vi.fn();
+            mockSpawn.mockReturnValue(mockProcess);
+            const callToolHandler = handlers.get('callTool');
+            await callToolHandler({
+                params: {
+                    name: 'run',
+                    arguments: {
+                        prompt: 'forge peek prompt',
+                        workFolder: '/tmp',
+                        model: 'forge',
+                    }
+                }
+            });
+            const peekPromise = callToolHandler({
+                params: {
+                    name: 'peek',
+                    arguments: {
+                        pids: [12349],
+                        peek_time_sec: 1,
+                        include_tool_calls: true,
+                    }
+                }
+            });
+            setTimeout(() => {
+                mockProcess.stdout.emit('data', 'Summary: Forge started\n');
+                mockProcess.stdout.emit('data', "● [11:28:40] Execute [/bin/zsh] /bin/sh -c 'echo hi'\n");
+                mockProcess.stdout.emit('data', 'secret child output\n');
+                mockProcess.stderr.emit('data', 'Summary: stderr should be ignored\n');
+                mockProcess.stdout.emit('data', '● [11:28:41] Finished abc123\n');
+                mockProcess.stdout.emit('data', 'Completed successfully: Forge done\n');
+                mockProcess.emit('close', 0);
+            }, 10);
+            const result = await peekPromise;
+            const response = JSON.parse(result.content[0].text);
+            expect(response.processes).toHaveLength(1);
+            expect(response.processes[0]).toMatchObject({
+                pid: 12349,
+                agent: 'forge',
+                status: 'completed',
+                events: [
+                    {
+                        kind: 'message',
+                        ts: expect.any(String),
+                        text: 'Forge started',
+                    },
+                    {
+                        kind: 'tool_call',
+                        phase: 'started',
+                        id: 'forge_0',
+                        tool: '/bin/zsh',
+                        summary: "/bin/sh -c 'echo hi'",
+                    },
+                    {
+                        kind: 'tool_call',
+                        phase: 'completed',
+                        id: 'forge_0',
+                        tool: '/bin/zsh',
+                        summary: "/bin/sh -c 'echo hi'",
+                        status: 'unknown',
+                    },
+                    {
+                        kind: 'message',
+                        ts: expect.any(String),
+                        text: 'Forge done',
+                    },
+                ],
+                truncated: false,
+                error: null,
+            });
+            expect(JSON.stringify(response)).not.toContain('secret child output');
+            expect(JSON.stringify(response)).not.toContain('stderr should be ignored');
+        });
         it('should handle process with model parameter', async () => {
             const { handlers } = await setupServer();
             const mockProcess = new EventEmitter();

package/dist/app/cli.js

@@ -8,7 +8,7 @@ export const CLI_HELP_TEXT = `Usage: ai-cli <command> [options]
 Commands:
   run       Start an AI CLI process in the background
   wait      Wait for one or more pids
-  peek      Observe new natural-language agent messages for a short window
+  peek      Observe new agent events for a short window
   ps        List tracked processes
   result    Get the current result for a pid
   kill      Terminate a tracked pid
@@ -57,12 +57,13 @@ Options:
 `;
 export const PEEK_HELP_TEXT = `Usage: ai-cli peek <pid...> [options]
 
-Observe new natural-language agent messages for a short one-shot window.
-In v1, message extraction is supported for Codex, Claude, OpenCode, and Gemini; Forge returns status with messages: [].
+Observe new natural-language agent messages, and optionally tool calls, for a short one-shot window.
+In v1, message extraction is supported for Codex, Claude, OpenCode, Gemini, and best-effort Forge Summary/Completed successfully lines. Forge tool calls are low-precision Execute/Finished markers and never include command output.
 This is not a history API, gapless streaming, or stdout/stderr tailing. No --follow mode is available in v1.
 
 Options:
   --time <seconds>             Observation window in seconds. Defaults to 10, maximum 60
+  --include-tool-calls         Include normalized tool_call events without raw tool output
   --help, -h                   Show this help message
 `;
 export const KILL_HELP_TEXT = `Usage: ai-cli kill <pid>
@@ -119,7 +120,7 @@ const defaultDeps = {
     listProcesses: () => getCliProcessService().listProcesses(),
     getProcessResult: (pid, verbose) => getCliProcessService().getProcessResult(pid, verbose),
     waitForProcesses: (pids, timeoutSeconds, verbose) => getCliProcessService().waitForProcesses(pids, timeoutSeconds, verbose),
-    peekProcesses: (pids, peekTimeSec) => getCliProcessService().peekProcesses(pids, peekTimeSec),
+    peekProcesses: (pids, peekTimeSec, includeToolCalls) => getCliProcessService().peekProcesses(pids, peekTimeSec, includeToolCalls),
     killProcess: (pid) => getCliProcessService().killProcess(pid),
     cleanupProcesses: () => getCliProcessService().cleanupProcesses(),
     getDoctorStatus: () => getCliDoctorStatus(),
@@ -297,7 +298,7 @@ export async function runCli(argv, deps = {}) {
             stdout(CLI_HELP_TEXT);
             return 1;
         }
-        writeJson(stdout, await peekProcesses(pids, peekTimeSec));
+        writeJson(stdout, await peekProcesses(pids, peekTimeSec, 'include-tool-calls' in flags || 'include_tool_calls' in flags));
         return 0;
     }
     if (command === 'kill') {

package/dist/app/mcp.js

@@ -211,7 +211,7 @@ ${getSupportedModelsDescription()}
                 },
                 {
                     name: 'peek',
-                    description: 'One-shot short observation window for running child agents. Returns only natural-language agent messages observed during this call; not a history API, not gapless streaming, and not stdout/stderr tailing. In v1, message extraction is supported for Codex, Claude, OpenCode, and Gemini; Forge returns status with messages: [].',
+                    description: 'One-shot short observation window for running child agents. Returns only natural-language message events, and optionally normalized tool_call events, observed during this call; not a history API, not gapless streaming, and not stdout/stderr tailing. In v1, message extraction is supported for Codex, Claude, OpenCode, Gemini, and best-effort Forge Summary/Completed successfully lines. Forge tool calls are low-precision Execute/Finished markers and never include command output. Tool calls exclude raw tool output.',
                     inputSchema: {
                         type: 'object',
                         properties: {
@@ -224,6 +224,10 @@ ${getSupportedModelsDescription()}
                                 type: 'number',
                                 description: 'Optional positive integer observation window in seconds. Defaults to 10; maximum is 60.',
                             },
+                            include_tool_calls: {
+                                type: 'boolean',
+                                description: 'Optional: include normalized tool_call events without raw tool output. Defaults to false.',
+                            },
                         },
                         required: ['pids'],
                     },
@@ -351,15 +355,20 @@ ${getSupportedModelsDescription()}
     async handlePeek(toolArguments) {
         let pids;
         let peekTimeSec;
+        let includeToolCalls;
         try {
             pids = validatePeekPids(toolArguments.pids);
             peekTimeSec = validatePeekTimeSec(toolArguments.peek_time_sec);
+            if (toolArguments.include_tool_calls !== undefined && typeof toolArguments.include_tool_calls !== 'boolean') {
+                throw new Error('include_tool_calls must be a boolean when provided');
+            }
+            includeToolCalls = toolArguments.include_tool_calls === true;
         }
         catch (error) {
             throw new McpError(ErrorCode.InvalidParams, error.message);
         }
         try {
-            const response = await this.processService.peekProcesses(pids, peekTimeSec);
+            const response = await this.processService.peekProcesses(pids, peekTimeSec, includeToolCalls);
             return {
                 content: [{
                         type: 'text',

package/dist/cli-process-service.js

@@ -4,9 +4,9 @@ import { join, basename, dirname } from 'node:path';
 import { homedir } from 'node:os';
 import { buildCliCommand } from './cli-builder.js';
 import { findClaudeCli, findCodexCli, findForgeCli, findGeminiCli, findOpencodeCli } from './cli-utils.js';
-import { parseClaudeOutput, parseCodexOutput, parseForgeOutput, parseGeminiOutput, parseOpenCodeOutput, PeekMessageExtractor } from './parsers.js';
+import { parseClaudeOutput, parseCodexOutput, parseForgeOutput, parseGeminiOutput, parseOpenCodeOutput, PeekEventExtractor } from './parsers.js';
 import { buildProcessResult } from './process-result.js';
-import { appendPeekMessages, buildNotFoundPeekProcess, observedDurationSec, validatePeekPids, validatePeekTimeSec, } from './peek.js';
+import { appendPeekEvents, buildNotFoundPeekProcess, observedDurationSec, validatePeekPids, validatePeekTimeSec, } from './peek.js';
 function resolveDefaultStateDir() {
     return process.env.AI_CLI_STATE_DIR || join(homedir(), '.local', 'state', 'ai-cli');
 }
@@ -175,7 +175,7 @@ export class CliProcessService {
             await new Promise((resolve) => setTimeout(resolve, 50));
         }
     }
-    async peekProcesses(pids, peekTimeSec = 10) {
+    async peekProcesses(pids, peekTimeSec = 10, includeToolCalls = false) {
         const targetPids = validatePeekPids(pids);
         const targetPeekTimeSec = validatePeekTimeSec(peekTimeSec);
         const processes = [];
@@ -193,7 +193,7 @@ export class CliProcessService {
                 pid,
                 agent: process.toolType,
                 status: process.status,
-                messages: [],
+                events: [],
                 truncated: false,
                 error: null,
             };
@@ -201,8 +201,8 @@ export class CliProcessService {
             observers.push({
                 process,
                 result,
-                stdoutExtractor: new PeekMessageExtractor(process.toolType),
-                stderrExtractor: new PeekMessageExtractor(process.toolType),
+                stdoutExtractor: new PeekEventExtractor(process.toolType, { includeToolCalls, source: 'stdout' }),
+                stderrExtractor: new PeekEventExtractor(process.toolType, { includeToolCalls, source: 'stderr' }),
                 stdoutOffset: this.fileSizeSafe(process.stdoutPath),
                 stderrOffset: this.fileSizeSafe(process.stderrPath),
             });
@@ -216,10 +216,10 @@ export class CliProcessService {
             for (const observer of observers) {
                 const stdoutRead = this.readTextFromOffset(observer.process.stdoutPath, observer.stdoutOffset);
                 observer.stdoutOffset = stdoutRead.offset;
-                appendPeekMessages(observer.result, observer.stdoutExtractor.push(stdoutRead.text, observedAt));
+                appendPeekEvents(observer.result, observer.stdoutExtractor.push(stdoutRead.text, observedAt));
                 const stderrRead = this.readTextFromOffset(observer.process.stderrPath, observer.stderrOffset);
                 observer.stderrOffset = stderrRead.offset;
-                appendPeekMessages(observer.result, observer.stderrExtractor.push(stderrRead.text, observedAt));
+                appendPeekEvents(observer.result, observer.stderrExtractor.push(stderrRead.text, observedAt));
                 observer.process = this.refreshStatus(this.readProcess(observer.process.pid));
                 observer.result.status = observer.process.status;
                 if (observer.process.status === 'running') {
@@ -239,8 +239,9 @@ export class CliProcessService {
         for (const observer of observers) {
             observer.process = this.refreshStatus(this.readProcess(observer.process.pid));
             observer.result.status = observer.process.status;
-            appendPeekMessages(observer.result, observer.stdoutExtractor.flush(flushTs));
-            appendPeekMessages(observer.result, observer.stderrExtractor.flush(flushTs));
+            const terminal = observer.process.status !== 'running';
+            appendPeekEvents(observer.result, observer.stdoutExtractor.flush(flushTs, { terminal }));
+            appendPeekEvents(observer.result, observer.stderrExtractor.flush(flushTs, { terminal }));
         }
         return {
             peek_started_at: startedAt.toISOString(),