@link-assistant/agent 0.26.9 → 0.26.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/agent",
-  "version": "0.26.9",
+  "version": "0.26.11",
   "description": "A minimal, public domain AI CLI agent compatible with OpenCode's JSON interface. Bun-only runtime.",
   "main": "src/index.js",
   "type": "module",

package/src/session/message-v2.ts

@@ -338,6 +338,8 @@ export namespace MessageV2 {
       status: z.literal('error'),
       input: z.record(z.string(), z.any()),
       error: z.string(),
+      title: z.string().optional(),
+      attachments: FilePart.array().optional(),
       metadata: z.record(z.string(), z.any()).optional(),
       time: z.object({
         start: z.number(),
@@ -734,7 +736,10 @@ export namespace MessageV2 {
               type: 'step-start',
             });
           if (part.type === 'tool') {
-            if (part.state.status === 'completed') {
+            if (
+              part.state.status === 'completed' ||
+              part.state.status === 'error'
+            ) {
               if (part.state.attachments?.length) {
                 result.push({
                   id: Identifier.ascending('message'),
@@ -753,6 +758,8 @@ export namespace MessageV2 {
                   ],
                 });
               }
+            }
+            if (part.state.status === 'completed') {
               assistantMessage.parts.push({
                 type: ('tool-' + part.tool) as `tool-${string}`,
                 state: 'output-available',

package/src/session/processor.ts

@@ -19,6 +19,7 @@ import { SessionStatus } from './status';
 import { config, isVerbose } from '../config/config';
 import { SessionCompaction } from './compaction';
 import { SSEUsageExtractor } from '../util/sse-usage-extractor';
+import { Tool } from '../tool/tool';
 
 export namespace SessionProcessor {
   const DOOM_LOOP_THRESHOLD = 3;
@@ -233,18 +234,13 @@ export namespace SessionProcessor {
                   if (match && match.state.status === 'running') {
                     await Session.updatePart({
                       ...match,
-                      state: {
-                        status: 'completed',
+                      state: Tool.toState(value.output, {
                         input: value.input,
-                        output: value.output.output,
-                        metadata: value.output.metadata,
-                        title: value.output.title,
                         time: {
                           start: match.state.time.start,
                           end: Date.now(),
                         },
-                        attachments: value.output.attachments,
-                      },
+                      }),
                     });
 
                     delete toolcalls[value.toolCallId];

package/src/session/prompt.ts

@@ -48,6 +48,8 @@ import { fn } from '../util/fn';
 import { SessionProcessor } from './processor';
 import { TaskTool } from '../tool/task';
 import { SessionStatus } from './status';
+import { Tool } from '../tool/tool';
+import { processResult } from '../tool/process-result';
 
 export namespace SessionPrompt {
   const log = Log.create({ service: 'session.prompt' });
@@ -1198,12 +1200,7 @@ export namespace SessionPrompt {
           });
           return result;
         },
-        toModelOutput(result) {
-          return {
-            type: 'text',
-            value: result.output,
-          };
-        },
+        toModelOutput: Tool.toModelOutput,
       });
     }
 
@@ -1260,14 +1257,10 @@ export namespace SessionPrompt {
           output: textParts.join('\n\n'),
           attachments,
           content: result.content, // directly return content to preserve ordering when outputting to model
+          isError: result.isError,
         };
       };
-      item.toModelOutput = (result) => {
-        return {
-          type: 'text',
-          value: result.output,
-        };
-      };
+      item.toModelOutput = Tool.toModelOutput;
       tools[key] = item;
     }
     return tools;
@@ -1723,20 +1716,29 @@ export namespace SessionPrompt {
     msg.time.completed = Date.now();
     await Session.updateMessage(msg);
     if (part.state.status === 'running') {
-      part.state = {
-        status: 'completed',
-        time: {
-          ...part.state.time,
-          end: Date.now(),
-        },
-        input: part.state.input,
-        title: '',
-        metadata: {
-          output,
-          description: '',
+      part.state = Tool.toState(
+        {
+          title: '',
+          ...processResult({
+            output,
+            exit: proc.exitCode,
+            signal: proc.signalCode,
+          }),
+          metadata: {
+            output,
+            exit: proc.exitCode,
+            signal: proc.signalCode,
+            description: '',
+          },
         },
-        output,
-      };
+        {
+          time: {
+            ...part.state.time,
+            end: Date.now(),
+          },
+          input: part.state.input,
+        }
+      );
       await Session.updatePart(part);
     }
     return { info: msg, parts: [part] };
@@ -1794,7 +1796,11 @@ export namespace SessionPrompt {
       const results = await Promise.all(
         shell.map(async ([, cmd]) => {
           try {
-            return await $`${{ raw: cmd }}`.nothrow().text();
+            const result = await $`${{ raw: cmd }}`.nothrow();
+            return processResult({
+              output: result.text(),
+              exit: result.exitCode,
+            }).output;
           } catch (error) {
             return `Error executing command: ${error instanceof Error ? error.message : String(error)}`;
           }

package/src/tool/bash.ts

@@ -1,5 +1,5 @@
 import z from 'zod';
-import { spawn } from 'child_process';
+import { ProcessRunner } from 'command-stream/process-runner';
 import { Tool } from './tool';
 import DESCRIPTION from './bash.txt';
 import { Branding } from '../branding';
@@ -7,18 +7,29 @@ import { Log } from '../util/log';
 import { Instance } from '../project/instance';
 import { lazy } from '../util/lazy';
 import { Language } from 'web-tree-sitter';
-import { $ } from 'bun';
-import { Filesystem } from '../util/filesystem';
 import { Permission } from '../permission';
 import { fileURLToPath } from 'url';
+import { processResult } from './process-result';
 
 const MAX_OUTPUT_LENGTH = 30_000;
 const DEFAULT_TIMEOUT = 1 * 60 * 1000;
 const MAX_TIMEOUT = 10 * 60 * 1000;
-const SIGKILL_TIMEOUT_MS = 200;
-
+const KILL_SIGNAL = 'SIGTERM';
 export const log = Log.create({ service: 'bash-tool' });
 
+// command-stream 1.3.0 signals only the shell on Windows, which has no process
+// groups, so the shell's descendants keep running
+// (link-foundation/command-stream#205). taskkill /t walks the tree from the
+// shell, so it must run before the shell itself is stopped.
+const killWindowsTree = async (pid: number | undefined) => {
+  if (!pid) return;
+  // A failed taskkill resolves with its exit code; the runner is stopped next.
+  await new ProcessRunner(
+    { mode: 'exec', file: 'taskkill', args: ['/pid', String(pid), '/f', '/t'] },
+    { mirror: false, capture: false, stdin: 'ignore' }
+  ).catch(() => {});
+};
+
 const resolveWasm = (asset: string) => {
   if (asset.startsWith('file://')) return fileURLToPath(asset);
   if (asset.startsWith('/') || /^[a-z]:/i.test(asset)) return asset;
@@ -118,15 +129,8 @@ export const BashTool = Tool.define('bash', {
       });
     }
 
-    const proc = spawn(params.command, {
-      shell: true,
-      cwd: Instance.directory,
-      env: {
-        ...process.env,
-      },
-      stdio: ['ignore', 'pipe', 'pipe'],
-      detached: process.platform !== 'win32',
-    });
+    const timeoutSignal = AbortSignal.timeout(timeout);
+    const cancel = AbortSignal.any([ctx.abort, timeoutSignal]);
 
     let output = '';
 
@@ -138,90 +142,74 @@ export const BashTool = Tool.define('bash', {
       },
     });
 
-    const append = (chunk: Buffer) => {
-      output += chunk.toString();
-      ctx.metadata({
-        metadata: {
-          output,
-          description: params.description,
-        },
-      });
-    };
+    let exit: number | null = null;
+    let signal: string | null = null;
 
-    proc.stdout?.on('data', append);
-    proc.stderr?.on('data', append);
+    // command-stream 1.3.0 finishes a runner whose signal is already aborted
+    // before stream() subscribes to its end event, so the iterator never ends
+    // (link-foundation/command-stream#207).
+    // A cancelled command does not need to start at all.
+    if (!cancel.aborted) {
+      // On Windows the runner is stopped only after taskkill has stopped the
+      // shell's process tree.
+      const stop =
+        process.platform === 'win32' ? new AbortController() : undefined;
 
-    let timedOut = false;
-    let aborted = false;
-    let exited = false;
+      // The file/args shell form spawns the command string through Node's
+      // platform shell, as `spawn(command, { shell: true })` does. A command
+      // string spec would route simple commands and pipelines through
+      // command-stream's JavaScript builtins (`ls`, `exit`, `cd`, ...) instead.
+      const command = new ProcessRunner(
+        { mode: 'shell', file: params.command, args: [] },
+        {
+          cwd: Instance.directory,
+          env: { ...process.env },
+          signal: stop?.signal ?? cancel,
+          killSignal: KILL_SIGNAL,
+          killGrace: 200,
+          mirror: false,
+          capture: true,
+          stdin: 'ignore',
+        }
+      );
 
-    const killTree = async () => {
-      const pid = proc.pid;
-      if (!pid || exited) {
-        return;
-      }
+      const stopTree = () => {
+        void killWindowsTree(command.child?.pid).finally(() => stop?.abort());
+      };
+      if (stop) cancel.addEventListener('abort', stopTree, { once: true });
 
-      if (process.platform === 'win32') {
-        await new Promise<void>((resolve) => {
-          const killer = spawn('taskkill', ['/pid', String(pid), '/f', '/t'], {
-            stdio: 'ignore',
+      for await (const chunk of command.stream()) {
+        if (chunk.type === 'exit') {
+          exit = chunk.code;
+        } else {
+          output += chunk.data.toString();
+          ctx.metadata({
+            metadata: {
+              output,
+              description: params.description,
+            },
           });
-          killer.once('exit', resolve);
-          killer.once('error', resolve);
-        });
-        return;
-      }
-
-      try {
-        process.kill(-pid, 'SIGTERM');
-        await Bun.sleep(SIGKILL_TIMEOUT_MS);
-        if (!exited) {
-          process.kill(-pid, 'SIGKILL');
-        }
-      } catch (_e) {
-        proc.kill('SIGTERM');
-        await Bun.sleep(SIGKILL_TIMEOUT_MS);
-        if (!exited) {
-          proc.kill('SIGKILL');
         }
       }
-    };
 
-    if (ctx.abort.aborted) {
-      aborted = true;
-      await killTree();
-    }
+      cancel.removeEventListener('abort', stopTree);
 
-    const abortHandler = () => {
-      aborted = true;
-      void killTree();
-    };
-
-    ctx.abort.addEventListener('abort', abortHandler, { once: true });
-
-    const timeoutTimer = setTimeout(() => {
-      timedOut = true;
-      void killTree();
-    }, timeout);
-
-    await new Promise<void>((resolve, reject) => {
-      const cleanup = () => {
-        clearTimeout(timeoutTimer);
-        ctx.abort.removeEventListener('abort', abortHandler);
-      };
+      // command-stream reports a shell that died from a signal as exit 0
+      // (link-foundation/command-stream#208).
+      // Its result keeps the native child, which has the signal name.
+      const finished = command.result as {
+        child?: { signalCode?: string | null };
+      } | null;
+      signal = finished?.child?.signalCode ?? null;
+    }
 
-      proc.once('exit', () => {
-        exited = true;
-        cleanup();
-        resolve();
-      });
-
-      proc.once('error', (error) => {
-        exited = true;
-        cleanup();
-        reject(error);
-      });
-    });
+    const timedOut = timeoutSignal.aborted;
+    const aborted = ctx.abort.aborted;
+    // command-stream settles a cancelled command as soon as it sends the kill
+    // signal and reports a synthesized 128 + signal code. The real exit status
+    // is unavailable, as it is when the shell itself dies from a signal.
+    if (timedOut || aborted) signal = KILL_SIGNAL;
+    if (signal) exit = null;
 
     if (output.length > MAX_OUTPUT_LENGTH) {
       output = output.slice(0, MAX_OUTPUT_LENGTH);
@@ -236,14 +224,34 @@ export const BashTool = Tool.define('bash', {
       output += '\n\n(Command was aborted)';
     }
 
+    const result = processResult({
+      output,
+      exit,
+      signal,
+      timedOut,
+      aborted,
+    });
+
+    log.debug(() => ({
+      message: 'command finished',
+      exit,
+      signal,
+      timedOut,
+      aborted,
+      isError: result.isError,
+    }));
+
     return {
       title: params.command,
       metadata: {
         output,
-        exit: proc.exitCode,
+        exit,
+        signal,
+        timedOut,
+        aborted,
         description: params.description,
       },
-      output,
+      ...result,
     };
   },
 });

package/src/tool/batch.ts

@@ -101,21 +101,18 @@ export const BatchTool = Tool.define('batch', async () => {
             type: 'tool',
             tool: call.tool,
             callID: partID,
-            state: {
-              status: 'completed',
+            state: Tool.toState(result, {
               input: call.parameters,
-              output: result.output,
-              title: result.title,
-              metadata: result.metadata,
-              attachments: result.attachments,
               time: {
                 start: callStartTime,
                 end: Date.now(),
               },
-            },
+            }),
           });
 
-          return { success: true as const, tool: call.tool, result };
+          return result.isError
+            ? { success: false as const, tool: call.tool, error: result.output }
+            : { success: true as const, tool: call.tool, result };
         } catch (error) {
           await Session.updatePart({
             id: partID,
@@ -179,6 +176,7 @@ export const BatchTool = Tool.define('batch', async () => {
       return {
         title: `Batch execution (${successfulCalls}/${results.length} successful)`,
         output: outputMessage,
+        isError: failedCalls > 0,
         attachments: results
           .filter((result) => result.success)
           .flatMap((r) => r.result.attachments ?? []),

package/src/tool/grep.ts

@@ -62,7 +62,7 @@ export const GrepTool = Tool.define('grep', {
     }
 
     if (exitCode !== 0) {
-      throw new Error(`ripgrep failed: ${errorOutput}`);
+      throw new Error(`Exit code ${exitCode}\nripgrep failed: ${errorOutput}`);
     }
 
     const matches = [];

package/src/tool/process-result.ts

@@ -0,0 +1,18 @@
+/** Keep process status in the text sent to every provider, including those
+ * whose tool protocol has no separate error flag. */
+export function processResult(input: {
+  output: string;
+  exit: number | null;
+  signal?: string | null;
+  timedOut?: boolean;
+  aborted?: boolean;
+}) {
+  const isError = input.exit !== 0 || !!input.timedOut || !!input.aborted;
+  const status = input.signal ? ` (signal ${input.signal})` : '';
+  return {
+    output: isError
+      ? `Exit code ${input.exit ?? 'unavailable'}${status}\n${input.output}`
+      : input.output,
+    isError,
+  };
+}

package/src/tool/tool.ts

@@ -1,11 +1,56 @@
 import z from 'zod';
 import type { MessageV2 } from '../session/message-v2';
+import type { ToolResultOutput } from 'ai';
 
 export namespace Tool {
   interface Metadata {
     [key: string]: any;
   }
 
+  export interface Result<M extends Metadata = Metadata> {
+    title: string;
+    metadata: M;
+    output: string;
+    isError?: boolean;
+    attachments?: MessageV2.FilePart[];
+  }
+
+  // AI SDK 7 passes an options object containing the execution output.
+  export function toModelOutput({
+    output: result,
+  }: {
+    output: Pick<Result, 'output' | 'isError'>;
+  }): ToolResultOutput {
+    return {
+      type: result.isError ? 'error-text' : 'text',
+      value: result.output,
+    };
+  }
+
+  export function toState(
+    result: Result,
+    input: { input: Record<string, any>; time: { start: number; end: number } }
+  ): MessageV2.ToolStateCompleted | MessageV2.ToolStateError {
+    if (result.isError) {
+      return {
+        ...input,
+        status: 'error',
+        error: result.output,
+        metadata: result.metadata,
+        title: result.title,
+        attachments: result.attachments,
+      };
+    }
+    return {
+      ...input,
+      status: 'completed',
+      output: result.output,
+      title: result.title,
+      metadata: result.metadata,
+      attachments: result.attachments,
+    };
+  }
+
   export type Context<M extends Metadata = Metadata> = {
     sessionID: string;
     messageID: string;
@@ -23,15 +68,7 @@ export namespace Tool {
     init: () => Promise<{
       description: string;
       parameters: Parameters;
-      execute(
-        args: z.infer<Parameters>,
-        ctx: Context
-      ): Promise<{
-        title: string;
-        metadata: M;
-        output: string;
-        attachments?: MessageV2.FilePart[];
-      }>;
+      execute(args: z.infer<Parameters>, ctx: Context): Promise<Result<M>>;
       formatValidationError?(error: z.ZodError): string;
     }>;
   }