@link-assistant/agent 0.26.9 → 0.26.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/agent",
-  "version": "0.26.9",
+  "version": "0.26.10",
   "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

@@ -11,6 +11,7 @@ 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;
@@ -154,10 +155,11 @@ export const BashTool = Tool.define('bash', {
     let timedOut = false;
     let aborted = false;
     let exited = false;
+    let closed = false;
 
     const killTree = async () => {
       const pid = proc.pid;
-      if (!pid || exited) {
+      if (!pid || closed) {
         return;
       }
 
@@ -175,7 +177,9 @@ export const BashTool = Tool.define('bash', {
       try {
         process.kill(-pid, 'SIGTERM');
         await Bun.sleep(SIGKILL_TIMEOUT_MS);
-        if (!exited) {
+        // The shell may exit before a child that ignores SIGTERM. The
+        // process group still needs SIGKILL until its output pipes close.
+        if (!closed) {
           process.kill(-pid, 'SIGKILL');
         }
       } catch (_e) {
@@ -187,11 +191,6 @@ export const BashTool = Tool.define('bash', {
       }
     };
 
-    if (ctx.abort.aborted) {
-      aborted = true;
-      await killTree();
-    }
-
     const abortHandler = () => {
       aborted = true;
       void killTree();
@@ -204,7 +203,7 @@ export const BashTool = Tool.define('bash', {
       void killTree();
     }, timeout);
 
-    await new Promise<void>((resolve, reject) => {
+    const completion = new Promise<void>((resolve, reject) => {
       const cleanup = () => {
         clearTimeout(timeoutTimer);
         ctx.abort.removeEventListener('abort', abortHandler);
@@ -212,6 +211,12 @@ export const BashTool = Tool.define('bash', {
 
       proc.once('exit', () => {
         exited = true;
+      });
+
+      // close follows exit after stdout/stderr have drained. Install these
+      // listeners before killing an already-aborted process.
+      proc.once('close', () => {
+        closed = true;
         cleanup();
         resolve();
       });
@@ -223,6 +228,9 @@ export const BashTool = Tool.define('bash', {
       });
     });
 
+    if (ctx.abort.aborted) abortHandler();
+    await completion;
+
     if (output.length > MAX_OUTPUT_LENGTH) {
       output = output.slice(0, MAX_OUTPUT_LENGTH);
       output += '\n\n(Output was truncated due to length limit)';
@@ -236,14 +244,34 @@ export const BashTool = Tool.define('bash', {
       output += '\n\n(Command was aborted)';
     }
 
+    const result = processResult({
+      output,
+      exit: proc.exitCode,
+      signal: proc.signalCode,
+      timedOut,
+      aborted,
+    });
+
+    log.debug(() => ({
+      message: 'command finished',
+      exit: proc.exitCode,
+      signal: proc.signalCode,
+      timedOut,
+      aborted,
+      isError: result.isError,
+    }));
+
     return {
       title: params.command,
       metadata: {
         output,
         exit: proc.exitCode,
+        signal: proc.signalCode,
+        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;
     }>;
   }