minimal-agent 0.11.0 → 0.13.0

package/src/tools/tasks/taskStop.js

@@ -1,34 +1,74 @@
 import { z } from 'zod';
 import { toToolParameters } from '../../utils/zodToJson.js';
 import { DEFAULT_MAX_RESULT_SIZE_CHARS } from '../types.js';
-import { stopBackgroundTask } from './backgroundTaskService.js';
+import { stopBackgroundTask, } from './backgroundTaskService.js';
 import { processExecutionMetadata } from './processEvidence.js';
-const inputSchema = z.object({ task_id: z.string().uuid() });
-function call(input, state) {
+import { getLiveAgentTask, loadAgentRecord, } from '../agent/agentTaskService.js';
+const inputSchema = z.object({
+    task_id: z.string().regex(/^(?:proc_|agent_)?[0-9a-f-]{36}$/i),
+});
+async function call(input, state, context) {
+    if (input.task_id.startsWith('agent_') && context) {
+        const live = getLiveAgentTask(context.sessionState?.agentTasks, input.task_id);
+        if (live?.status === 'running') {
+            live.abort.abort();
+            await Promise.race([
+                live.completion,
+                new Promise((r) => setTimeout(r, 5000)),
+            ]);
+            return {
+                ok: true,
+                content: `已停止 Agent ${input.task_id}`,
+                metadata: {
+                    kind: 'agent',
+                    agentId: live.id,
+                    status: 'stopped',
+                    agentType: live.input.agent_type ?? 'explore',
+                    description: live.description,
+                    isolation: live.input.isolation ?? 'none',
+                    turns: 0,
+                    toolCalls: 0,
+                    failedToolCalls: 0,
+                    durationMs: Date.now() - live.createdAt,
+                    changedFiles: [],
+                },
+            };
+        }
+        const saved = await loadAgentRecord(context, input.task_id);
+        return saved
+            ? { ok: true, content: `Agent ${input.task_id} 已经是 ${saved.status}` }
+            : { ok: false, error: `当前会话中不存在 Agent ${input.task_id}` };
+    }
     const task = stopBackgroundTask(input.task_id, state);
     if (!task)
         return { ok: false, error: `当前会话中不存在后台任务 ${input.task_id}` };
     return {
         ok: true,
-        content: task.status === 'stopped' ? `已停止后台任务 ${task.id}` : `后台任务 ${task.id} 已经是 ${task.status}`,
+        content: task.status === 'stopped'
+            ? `已停止后台任务 ${task.id}`
+            : `后台任务 ${task.id} 已经是 ${task.status}`,
         metadata: processExecutionMetadata({
             shell: task.shell,
             mode: 'background',
             command: task.command,
             taskId: task.id,
-            status: task.status === 'completed' ? 'completed' : task.status === 'failed' ? 'failed' : 'stopped',
+            status: task.status === 'completed'
+                ? 'completed'
+                : task.status === 'failed'
+                    ? 'failed'
+                    : 'stopped',
             exitCode: task.exitCode,
         }),
     };
 }
 export const taskStopTool = {
     name: 'TaskStop',
-    description: 'Stops one Bash or PowerShell background task owned by the current session, including its child process tree.',
+    description: 'Stops one Bash/PowerShell background process (including its process tree) or one running Agent task owned by the current session.',
     inputSchema,
     parameters: toToolParameters(inputSchema),
     isReadOnly: false,
     isConcurrencySafe: true,
     maxResultSizeChars: DEFAULT_MAX_RESULT_SIZE_CHARS,
-    call: (input) => Promise.resolve(call(input)),
-    callWithContext: (input, _signal, context) => Promise.resolve(call(input, context.sessionState?.backgroundTasks)),
+    call: (input) => call(input),
+    callWithContext: (input, _signal, context) => call(input, context.sessionState?.backgroundTasks, context),
 };

package/src/tools/tasks/taskStop.ts

@@ -3,24 +3,82 @@ import { z } from 'zod';
 import type { Tool, ToolCallContext, ToolResult } from '../../types.js';
 import { toToolParameters } from '../../utils/zodToJson.js';
 import { DEFAULT_MAX_RESULT_SIZE_CHARS } from '../types.js';
-import { stopBackgroundTask, type BackgroundTaskState } from './backgroundTaskService.js';
+import {
+  stopBackgroundTask,
+  type BackgroundTaskState,
+} from './backgroundTaskService.js';
 import { processExecutionMetadata } from './processEvidence.js';
+import {
+  getLiveAgentTask,
+  loadAgentRecord,
+  saveAgentRecord,
+} from '../agent/agentTaskService.js';
 
-const inputSchema = z.object({ task_id: z.string().uuid() });
+const inputSchema = z.object({
+  task_id: z.string().regex(/^(?:proc_|agent_)?[0-9a-f-]{36}$/i),
+});
 type TaskStopInput = z.infer<typeof inputSchema>;
 
-function call(input: TaskStopInput, state?: BackgroundTaskState): ToolResult {
+async function call(
+  input: TaskStopInput,
+  state?: BackgroundTaskState,
+  context?: ToolCallContext,
+): Promise<ToolResult> {
+  if (input.task_id.startsWith('agent_') && context) {
+    const live = getLiveAgentTask(
+      context.sessionState?.agentTasks,
+      input.task_id,
+    );
+    if (live?.status === 'running') {
+      live.abort.abort();
+      await Promise.race([
+        live.completion,
+        new Promise<void>((r) => setTimeout(r, 5000)),
+      ]);
+      return {
+        ok: true,
+        content: `已停止 Agent ${input.task_id}`,
+        metadata: {
+          kind: 'agent',
+          agentId: live.id,
+          status: 'stopped',
+          agentType:
+            (live.input.agent_type as 'explore' | 'general') ?? 'explore',
+          description: live.description,
+          isolation: (live.input.isolation as 'none' | 'worktree') ?? 'none',
+          turns: 0,
+          toolCalls: 0,
+          failedToolCalls: 0,
+          durationMs: Date.now() - live.createdAt,
+          changedFiles: [],
+        },
+      };
+    }
+    const saved = await loadAgentRecord(context, input.task_id);
+    return saved
+      ? { ok: true, content: `Agent ${input.task_id} 已经是 ${saved.status}` }
+      : { ok: false, error: `当前会话中不存在 Agent ${input.task_id}` };
+  }
   const task = stopBackgroundTask(input.task_id, state);
-  if (!task) return { ok: false, error: `当前会话中不存在后台任务 ${input.task_id}` };
+  if (!task)
+    return { ok: false, error: `当前会话中不存在后台任务 ${input.task_id}` };
   return {
     ok: true,
-    content: task.status === 'stopped' ? `已停止后台任务 ${task.id}` : `后台任务 ${task.id} 已经是 ${task.status}`,
+    content:
+      task.status === 'stopped'
+        ? `已停止后台任务 ${task.id}`
+        : `后台任务 ${task.id} 已经是 ${task.status}`,
     metadata: processExecutionMetadata({
       shell: task.shell,
       mode: 'background',
       command: task.command,
       taskId: task.id,
-      status: task.status === 'completed' ? 'completed' : task.status === 'failed' ? 'failed' : 'stopped',
+      status:
+        task.status === 'completed'
+          ? 'completed'
+          : task.status === 'failed'
+            ? 'failed'
+            : 'stopped',
       exitCode: task.exitCode,
     }),
   };
@@ -28,12 +86,14 @@ function call(input: TaskStopInput, state?: BackgroundTaskState): ToolResult {
 
 export const taskStopTool: Tool<TaskStopInput> = {
   name: 'TaskStop',
-  description: 'Stops one Bash or PowerShell background task owned by the current session, including its child process tree.',
+  description:
+    'Stops one Bash/PowerShell background process (including its process tree) or one running Agent task owned by the current session.',
   inputSchema,
   parameters: toToolParameters(inputSchema),
   isReadOnly: false,
   isConcurrencySafe: true,
   maxResultSizeChars: DEFAULT_MAX_RESULT_SIZE_CHARS,
-  call: (input) => Promise.resolve(call(input)),
-  callWithContext: (input, _signal, context: ToolCallContext) => Promise.resolve(call(input, context.sessionState?.backgroundTasks)),
+  call: (input) => call(input),
+  callWithContext: (input, _signal, context: ToolCallContext) =>
+    call(input, context.sessionState?.backgroundTasks, context),
 };

package/src/tools/tasks/taskStore.js

@@ -0,0 +1,46 @@
+import { randomUUID } from 'node:crypto';
+import { join } from 'node:path';
+import { mutateRuntimeJson, readRuntimeJson, sessionRuntimeDir, } from '../../session/runtimeStore.js';
+const EMPTY = { schemaVersion: 1, tasks: [] };
+function pathFor(context) {
+    return join(sessionRuntimeDir(context), 'tasks.json');
+}
+export async function listManagedTasks(context) {
+    return (await readRuntimeJson(pathFor(context), EMPTY)).tasks;
+}
+export async function mutateManagedTasks(context, fn) {
+    return (await mutateRuntimeJson(pathFor(context), EMPTY, (file) => ({
+        schemaVersion: 1,
+        tasks: fn(file.tasks),
+    }))).tasks;
+}
+export function newTaskId() {
+    return `task_${randomUUID()}`;
+}
+export function assertNoDependencyCycle(tasks) {
+    const map = new Map(tasks.map((task) => [task.id, task]));
+    const visiting = new Set();
+    const visited = new Set();
+    const visit = (id) => {
+        if (visiting.has(id))
+            throw new Error(`任务依赖形成环：${id}`);
+        if (visited.has(id))
+            return;
+        const task = map.get(id);
+        if (!task)
+            throw new Error(`依赖任务不存在：${id}`);
+        visiting.add(id);
+        task.blockedBy.forEach(visit);
+        visiting.delete(id);
+        visited.add(id);
+    };
+    tasks.forEach((task) => visit(task.id));
+}
+export function effectiveTaskStatus(task, tasks) {
+    if (task.status === 'completed')
+        return 'completed';
+    const byId = new Map(tasks.map((item) => [item.id, item]));
+    return task.blockedBy.some((id) => byId.get(id)?.status !== 'completed')
+        ? 'blocked'
+        : task.status;
+}

package/src/tools/tasks/taskStore.ts

@@ -0,0 +1,77 @@
+import { randomUUID } from 'node:crypto';
+import { join } from 'node:path';
+
+import type { ToolCallContext } from '../../types.js';
+import {
+  mutateRuntimeJson,
+  readRuntimeJson,
+  sessionRuntimeDir,
+} from '../../session/runtimeStore.js';
+
+export type ManagedTaskStatus = 'pending' | 'in_progress' | 'completed';
+export interface ManagedTask {
+  id: string;
+  title: string;
+  description?: string;
+  activeForm?: string;
+  owner?: string;
+  status: ManagedTaskStatus;
+  blockedBy: string[];
+  metadata?: Record<string, unknown>;
+  createdAt: number;
+  updatedAt: number;
+}
+interface TaskFile {
+  schemaVersion: 1;
+  tasks: ManagedTask[];
+}
+const EMPTY: TaskFile = { schemaVersion: 1, tasks: [] };
+
+function pathFor(context: ToolCallContext): string {
+  return join(sessionRuntimeDir(context), 'tasks.json');
+}
+export async function listManagedTasks(
+  context: ToolCallContext,
+): Promise<ManagedTask[]> {
+  return (await readRuntimeJson(pathFor(context), EMPTY)).tasks;
+}
+export async function mutateManagedTasks(
+  context: ToolCallContext,
+  fn: (tasks: ManagedTask[]) => ManagedTask[],
+): Promise<ManagedTask[]> {
+  return (
+    await mutateRuntimeJson(pathFor(context), EMPTY, (file) => ({
+      schemaVersion: 1 as const,
+      tasks: fn(file.tasks),
+    }))
+  ).tasks;
+}
+export function newTaskId(): string {
+  return `task_${randomUUID()}`;
+}
+export function assertNoDependencyCycle(tasks: ManagedTask[]): void {
+  const map = new Map(tasks.map((task) => [task.id, task]));
+  const visiting = new Set<string>();
+  const visited = new Set<string>();
+  const visit = (id: string) => {
+    if (visiting.has(id)) throw new Error(`任务依赖形成环：${id}`);
+    if (visited.has(id)) return;
+    const task = map.get(id);
+    if (!task) throw new Error(`依赖任务不存在：${id}`);
+    visiting.add(id);
+    task.blockedBy.forEach(visit);
+    visiting.delete(id);
+    visited.add(id);
+  };
+  tasks.forEach((task) => visit(task.id));
+}
+export function effectiveTaskStatus(
+  task: ManagedTask,
+  tasks: ManagedTask[],
+): string {
+  if (task.status === 'completed') return 'completed';
+  const byId = new Map(tasks.map((item) => [item.id, item]));
+  return task.blockedBy.some((id) => byId.get(id)?.status !== 'completed')
+    ? 'blocked'
+    : task.status;
+}

package/src/tools/terminal/terminalCapture.js

@@ -0,0 +1,167 @@
+import { z } from 'zod';
+import { toToolParameters } from '../../utils/zodToJson.js';
+const schema = z.object({
+    lines: z.number().int().min(1).max(200).default(50).optional(),
+});
+export class AnsiScreen {
+    columns;
+    rows = [''];
+    row = 0;
+    column = 0;
+    escape = '';
+    constructor(columns = process.stdout.columns || 120) {
+        this.columns = columns;
+    }
+    resize(columns) {
+        this.columns = Math.max(20, columns || 120);
+    }
+    write(value) {
+        const text = Buffer.isBuffer(value)
+            ? value.toString('utf8')
+            : String(value);
+        for (const char of text) {
+            if (this.escape) {
+                this.escape += char;
+                if (/^\x1b\[[0-?]*[ -/]*[@-~]$/.test(this.escape)) {
+                    this.applyCsi(this.escape);
+                    this.escape = '';
+                }
+                else if (this.escape.length > 64 ||
+                    !/^\x1b(?:\[[0-?]*[ -/]*)?$/.test(this.escape)) {
+                    this.escape = '';
+                }
+                continue;
+            }
+            if (char === '\x1b') {
+                this.escape = char;
+                continue;
+            }
+            if (char === '\r') {
+                this.column = 0;
+                continue;
+            }
+            if (char === '\n') {
+                this.newLine();
+                continue;
+            }
+            if (char === '\b') {
+                this.column = Math.max(0, this.column - 1);
+                continue;
+            }
+            if (char < ' ')
+                continue;
+            this.put(char);
+        }
+    }
+    snapshot(lines) {
+        return this.rows.slice(-lines).join('\n') || '<terminal is empty>';
+    }
+    put(char) {
+        const current = this.rows[this.row] ?? '';
+        this.rows[this.row] =
+            current.length < this.column
+                ? `${current}${' '.repeat(this.column - current.length)}${char}`
+                : `${current.slice(0, this.column)}${char}${current.slice(this.column + 1)}`;
+        this.column += 1;
+        if (this.column >= this.columns)
+            this.newLine();
+    }
+    newLine() {
+        this.row += 1;
+        this.column = 0;
+        if (!this.rows[this.row])
+            this.rows[this.row] = '';
+        if (this.rows.length > 200) {
+            this.rows.splice(0, this.rows.length - 200);
+            this.row = this.rows.length - 1;
+        }
+    }
+    applyCsi(sequence) {
+        const match = /^\x1b\[([0-9;?]*)([A-Za-z])$/.exec(sequence);
+        if (!match)
+            return;
+        const rawValues = match[1].replace(/^\?/, '').split(';');
+        const values = rawValues.map((value) => value === '' ? undefined : Number(value));
+        const amount = values[0] ?? (match[2] === 'J' || match[2] === 'K' ? 0 : 1);
+        switch (match[2]) {
+            case 'A':
+                this.row = Math.max(0, this.row - amount);
+                break;
+            case 'B':
+                this.row = Math.min(this.rows.length - 1, this.row + amount);
+                break;
+            case 'C':
+                this.column += amount;
+                break;
+            case 'D':
+                this.column = Math.max(0, this.column - amount);
+                break;
+            case 'G':
+                this.column = Math.max(0, amount - 1);
+                break;
+            case 'H':
+            case 'f':
+                this.row = Math.max(0, Math.min(this.rows.length - 1, (values[0] ?? 1) - 1));
+                this.column = Math.max(0, (values[1] ?? 1) - 1);
+                break;
+            case 'K': {
+                const current = this.rows[this.row] ?? '';
+                if (amount === 1)
+                    this.rows[this.row] =
+                        `${' '.repeat(this.column)}${current.slice(this.column)}`;
+                else if (amount === 2)
+                    this.rows[this.row] = '';
+                else
+                    this.rows[this.row] = current.slice(0, this.column);
+                break;
+            }
+            case 'J':
+                if (amount === 2 || amount === 3) {
+                    this.rows = [''];
+                    this.row = 0;
+                    this.column = 0;
+                }
+                break;
+            default:
+                break;
+        }
+    }
+}
+let uninstall;
+const screen = new AnsiScreen();
+export function installTerminalCapture() {
+    if (uninstall)
+        return () => undefined;
+    const original = process.stdout.write.bind(process.stdout);
+    const onResize = () => screen.resize(process.stdout.columns || 120);
+    process.stdout.write = ((chunk, ...args) => {
+        screen.write(chunk);
+        return original(chunk, ...args);
+    });
+    process.stdout.on('resize', onResize);
+    uninstall = () => {
+        process.stdout.write = original;
+        process.stdout.off('resize', onResize);
+        uninstall = undefined;
+    };
+    return uninstall;
+}
+export function hasTerminalCapture() {
+    return Boolean(uninstall);
+}
+export const terminalCaptureTool = {
+    name: 'TerminalCapture',
+    description: 'Returns a bounded virtual-screen snapshot of the current TUI terminal. Available only when the TUI host installed its capture provider.',
+    inputSchema: schema,
+    parameters: toToolParameters(schema),
+    isReadOnly: true,
+    isConcurrencySafe: true,
+    resolveAvailability: (runtime) => ({
+        available: runtime.surface === 'tui' && hasTerminalCapture(),
+        signature: `terminal:${runtime.surface}:${hasTerminalCapture()}`,
+    }),
+    call: async (input) => ({
+        ok: true,
+        content: screen.snapshot(input.lines ?? 50),
+    }),
+};

package/src/tools/terminal/terminalCapture.ts

@@ -0,0 +1,179 @@
+import { z } from 'zod';
+
+import type { Tool, ToolResult } from '../../types.js';
+import { toToolParameters } from '../../utils/zodToJson.js';
+
+const schema = z.object({
+  lines: z.number().int().min(1).max(200).default(50).optional(),
+});
+
+export class AnsiScreen {
+  private rows = [''];
+  private row = 0;
+  private column = 0;
+  private escape = '';
+
+  constructor(private columns = process.stdout.columns || 120) {}
+
+  resize(columns: number): void {
+    this.columns = Math.max(20, columns || 120);
+  }
+
+  write(value: unknown): void {
+    const text = Buffer.isBuffer(value)
+      ? value.toString('utf8')
+      : String(value);
+    for (const char of text) {
+      if (this.escape) {
+        this.escape += char;
+        if (/^\x1b\[[0-?]*[ -/]*[@-~]$/.test(this.escape)) {
+          this.applyCsi(this.escape);
+          this.escape = '';
+        } else if (
+          this.escape.length > 64 ||
+          !/^\x1b(?:\[[0-?]*[ -/]*)?$/.test(this.escape)
+        ) {
+          this.escape = '';
+        }
+        continue;
+      }
+      if (char === '\x1b') {
+        this.escape = char;
+        continue;
+      }
+      if (char === '\r') {
+        this.column = 0;
+        continue;
+      }
+      if (char === '\n') {
+        this.newLine();
+        continue;
+      }
+      if (char === '\b') {
+        this.column = Math.max(0, this.column - 1);
+        continue;
+      }
+      if (char < ' ') continue;
+      this.put(char);
+    }
+  }
+
+  snapshot(lines: number): string {
+    return this.rows.slice(-lines).join('\n') || '<terminal is empty>';
+  }
+
+  private put(char: string): void {
+    const current = this.rows[this.row] ?? '';
+    this.rows[this.row] =
+      current.length < this.column
+        ? `${current}${' '.repeat(this.column - current.length)}${char}`
+        : `${current.slice(0, this.column)}${char}${current.slice(this.column + 1)}`;
+    this.column += 1;
+    if (this.column >= this.columns) this.newLine();
+  }
+
+  private newLine(): void {
+    this.row += 1;
+    this.column = 0;
+    if (!this.rows[this.row]) this.rows[this.row] = '';
+    if (this.rows.length > 200) {
+      this.rows.splice(0, this.rows.length - 200);
+      this.row = this.rows.length - 1;
+    }
+  }
+
+  private applyCsi(sequence: string): void {
+    const match = /^\x1b\[([0-9;?]*)([A-Za-z])$/.exec(sequence);
+    if (!match) return;
+    const rawValues = match[1]!.replace(/^\?/, '').split(';');
+    const values = rawValues.map((value) =>
+      value === '' ? undefined : Number(value),
+    );
+    const amount = values[0] ?? (match[2] === 'J' || match[2] === 'K' ? 0 : 1);
+    switch (match[2]) {
+      case 'A':
+        this.row = Math.max(0, this.row - amount);
+        break;
+      case 'B':
+        this.row = Math.min(this.rows.length - 1, this.row + amount);
+        break;
+      case 'C':
+        this.column += amount;
+        break;
+      case 'D':
+        this.column = Math.max(0, this.column - amount);
+        break;
+      case 'G':
+        this.column = Math.max(0, amount - 1);
+        break;
+      case 'H':
+      case 'f':
+        this.row = Math.max(
+          0,
+          Math.min(this.rows.length - 1, (values[0] ?? 1) - 1),
+        );
+        this.column = Math.max(0, (values[1] ?? 1) - 1);
+        break;
+      case 'K': {
+        const current = this.rows[this.row] ?? '';
+        if (amount === 1)
+          this.rows[this.row] =
+            `${' '.repeat(this.column)}${current.slice(this.column)}`;
+        else if (amount === 2) this.rows[this.row] = '';
+        else this.rows[this.row] = current.slice(0, this.column);
+        break;
+      }
+      case 'J':
+        if (amount === 2 || amount === 3) {
+          this.rows = [''];
+          this.row = 0;
+          this.column = 0;
+        }
+        break;
+      default:
+        break;
+    }
+  }
+}
+
+let uninstall: (() => void) | undefined;
+const screen = new AnsiScreen();
+
+export function installTerminalCapture(): () => void {
+  if (uninstall) return () => undefined;
+  const original = process.stdout.write.bind(process.stdout);
+  const onResize = () => screen.resize(process.stdout.columns || 120);
+  process.stdout.write = ((chunk: unknown, ...args: unknown[]) => {
+    screen.write(chunk);
+    return original(chunk as never, ...(args as never[]));
+  }) as typeof process.stdout.write;
+  process.stdout.on('resize', onResize);
+  uninstall = () => {
+    process.stdout.write = original;
+    process.stdout.off('resize', onResize);
+    uninstall = undefined;
+  };
+  return uninstall;
+}
+
+export function hasTerminalCapture(): boolean {
+  return Boolean(uninstall);
+}
+
+export const terminalCaptureTool: Tool<z.infer<typeof schema>> = {
+  name: 'TerminalCapture',
+  description:
+    'Returns a bounded virtual-screen snapshot of the current TUI terminal. Available only when the TUI host installed its capture provider.',
+  inputSchema: schema,
+  parameters: toToolParameters(schema),
+  isReadOnly: true,
+  isConcurrencySafe: true,
+  resolveAvailability: (runtime) => ({
+    available: runtime.surface === 'tui' && hasTerminalCapture(),
+    signature: `terminal:${runtime.surface}:${hasTerminalCapture()}`,
+  }),
+  call: async (input): Promise<ToolResult> => ({
+    ok: true,
+    content: screen.snapshot(input.lines ?? 50),
+  }),
+};