@link-assistant/agent 0.26.15 → 0.27.1

package/src/tool/read.ts

@@ -12,6 +12,13 @@ import { formatBalancedLineWindow, formatColumnWindow } from './text-window';
 
 const DEFAULT_READ_LIMIT = 2000;
 const MAX_LINE_LENGTH = 2000;
+// upstream 1b82511fbd / c1b03b728a (#14009): the output is bounded in bytes
+// too (config.readMaxBytes, 50 KB by default), 2000 long lines would otherwise
+// put megabytes into the context.
+
+function formatSize(bytes: number) {
+  return bytes % 1024 === 0 ? `${bytes / 1024} KB` : `${bytes} bytes`;
+}
 
 export const ReadTool = Tool.define('read', {
   description: DESCRIPTION,
@@ -36,18 +43,42 @@ export const ReadTool = Tool.define('read', {
   }),
   async execute(params, ctx) {
     let filepath = params.filePath;
-    if (!path.isAbsolute(filepath)) {
-      filepath = path.join(Instance.worktree, filepath);
+    const relative = !path.isAbsolute(filepath);
+    if (relative) {
+      // Relative to the session directory, like every other tool, not to the
+      // worktree root (upstream 6cf2c3e3db).
+      filepath = path.resolve(Instance.directory, filepath);
     }
-    const title = path.relative(Instance.worktree, filepath);
 
     // No restrictions - unrestricted file read
-    const file = Bun.file(filepath);
-    if (!(await file.exists())) {
+    let stat = await fs.promises.stat(filepath).catch(() => undefined);
+    if (!stat && relative && Instance.directory !== Instance.worktree) {
+      // Backward compatibility: relative paths used to resolve against the
+      // worktree root. Keep that working when the path does not exist under
+      // the session directory.
+      const fromWorktree = path.resolve(Instance.worktree, params.filePath);
+      const worktreeStat = await fs.promises
+        .stat(fromWorktree)
+        .catch(() => undefined);
+      if (worktreeStat) {
+        filepath = fromWorktree;
+        stat = worktreeStat;
+      }
+    }
+    if (!stat) {
+      const alternate = alternatePath(filepath);
+      if (alternate) {
+        filepath = alternate;
+        stat = await fs.promises.stat(filepath).catch(() => undefined);
+      }
+    }
+    const title = path.relative(Instance.worktree, filepath);
+    if (!stat) {
       const dir = path.dirname(filepath);
       const base = path.basename(filepath);
 
-      const dirEntries = fs.readdirSync(dir);
+      // A missing parent directory is still just "File not found".
+      const dirEntries = fs.existsSync(dir) ? fs.readdirSync(dir) : [];
       const suggestions = dirEntries
         .filter(
           (entry) =>
@@ -65,6 +96,16 @@ export const ReadTool = Tool.define('read', {
 
       throw new Error(`File not found: ${filepath}`);
     }
+    // upstream 823d327401 / ff837fe949 (#33255/#33260)
+    if (stat.isDirectory()) {
+      throw new Error(
+        `Path is a directory, not a file: ${filepath}. Use the ls or glob tool to list it.`
+      );
+    }
+    if (!stat.isFile()) {
+      throw new Error(`Path is not a regular file: ${filepath}`);
+    }
+    const file = Bun.file(filepath);
 
     const isImage = isImageFile(filepath);
     const supportsImages = await (async () => {
@@ -85,9 +126,8 @@ export const ReadTool = Tool.define('read', {
           `Failed to read image: ${filepath}, model may not be able to read images`
         );
       }
+      const bytes = await file.bytes();
       if (verifyImages) {
-        const bytes = new Uint8Array(await file.arrayBuffer());
-
         // Validate image format matches file extension
         if (!validateImageFormat(bytes, isImage)) {
           throw new Error(
@@ -118,54 +158,101 @@ export const ReadTool = Tool.define('read', {
             messageID: ctx.messageID,
             type: 'file',
             mime,
-            url: `data:${mime};base64,${Buffer.from(await file.bytes()).toString('base64')}`,
+            url: `data:${mime};base64,${Buffer.from(bytes).toString('base64')}`,
           },
         ],
       };
     }
 
-    const isBinary = await isBinaryFile(filepath, file);
+    const isBinary = await isBinaryFile(filepath, stat.size);
     if (isBinary) throw new Error(`Cannot read binary file: ${filepath}`);
 
-    const limit = normalizeNonNegativeInteger(params.limit, DEFAULT_READ_LIMIT);
+    // upstream 683d470fe4 (#51011): never return more than the default limit.
+    // --read-max-lines / --read-max-bytes tune both caps; 0 disables a cap.
+    const maxLines = config.readMaxLines > 0 ? config.readMaxLines : Infinity;
+    const maxBytes = config.readMaxBytes > 0 ? config.readMaxBytes : Infinity;
+    const limit = Math.min(
+      normalizeNonNegativeInteger(
+        params.limit,
+        Math.min(DEFAULT_READ_LIMIT, maxLines)
+      ),
+      maxLines
+    );
     const offset = normalizeNonNegativeInteger(params.offset, 0);
     const hasExplicitLineRange =
       params.offset !== undefined || params.limit !== undefined;
     const hasExplicitColumnRange =
       params.columnOffset !== undefined || params.columnLimit !== undefined;
     const columnOffset = normalizeNonNegativeInteger(params.columnOffset, 0);
-    const columnLimit = normalizeNonNegativeInteger(
-      params.columnLimit,
-      MAX_LINE_LENGTH
+    const columnLimit = Math.min(
+      normalizeNonNegativeInteger(params.columnLimit, MAX_LINE_LENGTH),
+      maxBytes
     );
-    const lines = await file.text().then((text) => text.split('\n'));
+    const lines = splitLines(await file.text());
+    // upstream c1b03b728a (#14009)
+    // --legacy-tool-output keeps the old empty result past the end.
+    if (
+      !config.legacyToolOutput &&
+      hasExplicitLineRange &&
+      lines.length > 0 &&
+      offset >= lines.length
+    ) {
+      throw new Error(
+        `Offset ${offset} is out of range for this file (${lines.length} lines)`
+      );
+    }
     const selected = selectLines({
       lines,
       offset,
       limit,
       summarizeMiddle: !hasExplicitLineRange,
     });
-    const content = selected.parts.flatMap((part) => {
+    const formatLine = ({
+      line,
+      lineNumber,
+    }: {
+      line: string;
+      lineNumber: number;
+    }) => {
+      const formattedLine = hasExplicitColumnRange
+        ? formatColumnWindow({
+            line,
+            lineNumber,
+            offset: columnOffset,
+            limit: columnLimit,
+          })
+        : formatBalancedLineWindow({
+            line,
+            lineNumber,
+            limit: MAX_LINE_LENGTH,
+          });
+      return `${lineNumber.toString().padStart(5, '0')}| ${formattedLine}`;
+    };
+
+    const content: string[] = [];
+    let bytes = 0;
+    let capped: { first: number; last: number } | undefined;
+    for (const part of selected.parts) {
       if (part.type === 'omitted') {
-        return [`... [omitted lines ${part.start}..${part.end}] ...`];
+        content.push(`... [omitted lines ${part.start}..${part.end}] ...`);
+        continue;
       }
-
-      return part.lines.map(({ line, lineNumber }) => {
-        const formattedLine = hasExplicitColumnRange
-          ? formatColumnWindow({
-              line,
-              lineNumber,
-              offset: columnOffset,
-              limit: columnLimit,
-            })
-          : formatBalancedLineWindow({
-              line,
-              lineNumber,
-              limit: MAX_LINE_LENGTH,
-            });
-        return `${lineNumber.toString().padStart(5, '0')}| ${formattedLine}`;
-      });
-    });
+      for (const item of part.lines) {
+        const formatted = formatLine(item);
+        const size = Buffer.byteLength(formatted, 'utf8') + 1;
+        // Always show at least one line so the cap cannot return nothing.
+        if (bytes + size > maxBytes && content.length > 0) {
+          capped = {
+            first: part.lines[0].lineNumber,
+            last: item.lineNumber - 1,
+          };
+          break;
+        }
+        content.push(formatted);
+        bytes += size;
+      }
+      if (capped) break;
+    }
     const preview = content.slice(0, 20).join('\n');
 
     let output = '<file>\n';
@@ -175,7 +262,10 @@ export const ReadTool = Tool.define('read', {
     const lastReadLine = selected.lastLine;
     const hasMoreLines = hasExplicitLineRange && totalLines > lastReadLine;
 
-    if (hasMoreLines) {
+    if (capped) {
+      // `offset` is 0-based, so the next unread line starts at `last`.
+      output += `\n\n(Output capped at ${formatSize(maxBytes)}. Showing lines ${capped.first}-${capped.last}. Use offset=${capped.last} to continue.)`;
+    } else if (hasMoreLines) {
       output += `\n\n(File has more lines. Use 'offset' parameter to read beyond line ${lastReadLine})`;
     } else {
       output += `\n\n(End of file - total ${totalLines} lines)`;
@@ -195,6 +285,40 @@ export const ReadTool = Tool.define('read', {
   },
 });
 
+// CRLF files must not leak `\r` into the output, and a trailing newline ends
+// the last line instead of starting an empty one (upstream c1b03b728a,
+// 683d470fe4).
+function splitLines(text: string) {
+  const lines = text.split(/\r?\n/);
+  if (lines.length > 1 && lines[lines.length - 1] === '') lines.pop();
+  return lines;
+}
+
+// macOS puts U+202F (narrow no-break space) before AM/PM in screenshot names
+// and models type a plain space; curly apostrophes get straightened the same
+// way. Use the only directory entry that matches after canonicalizing both
+// (upstream d484f070d1 #45807, b47824fb63 #50953).
+function canonicalName(name: string) {
+  return name
+    .normalize('NFC')
+    .replace(/[\u00a0\u202f]/g, ' ')
+    .replace(/[\u2018\u2019]/g, "'");
+}
+
+function alternatePath(filepath: string): string | undefined {
+  const dir = path.dirname(filepath);
+  const base = canonicalName(path.basename(filepath));
+  let entries: string[];
+  try {
+    entries = fs.readdirSync(dir);
+  } catch {
+    return undefined;
+  }
+  const matches = entries.filter((entry) => canonicalName(entry) === base);
+  if (matches.length !== 1) return undefined;
+  return path.join(dir, matches[0]);
+}
+
 function normalizeNonNegativeInteger(
   value: number | undefined,
   fallback: number
@@ -386,7 +510,7 @@ function validateImageFormat(
 
 async function isBinaryFile(
   filepath: string,
-  file: Bun.BunFile
+  fileSize: number
 ): Promise<boolean> {
   const ext = path.extname(filepath).toLowerCase();
   // binary check for common non-text extensions
@@ -424,14 +548,18 @@ async function isBinaryFile(
       break;
   }
 
-  const stat = await file.stat();
-  const fileSize = stat.size;
   if (fileSize === 0) return false;
 
+  // Sample only the first 4 KB instead of loading the whole file
+  // (upstream c1b03b728a #14009).
   const bufferSize = Math.min(4096, fileSize);
-  const buffer = await file.arrayBuffer();
-  if (buffer.byteLength === 0) return false;
-  const bytes = new Uint8Array(buffer.slice(0, bufferSize));
+  const fh = await fs.promises.open(filepath, 'r');
+  const sample = Buffer.alloc(bufferSize);
+  const { bytesRead } = await fh
+    .read(sample, 0, bufferSize, 0)
+    .finally(() => fh.close());
+  if (bytesRead === 0) return false;
+  const bytes = sample.subarray(0, bytesRead);
 
   let nonPrintableCount = 0;
   for (let i = 0; i < bytes.length; i++) {

package/src/tool/task.ts

@@ -110,24 +110,32 @@ export const TaskTool = Tool.define('task', async () => {
       }
       ctx.abort.addEventListener('abort', cancel);
       using _ = defer(() => ctx.abort.removeEventListener('abort', cancel));
-      const promptParts = await SessionPrompt.resolvePromptParts(params.prompt);
-      const result = await SessionPrompt.prompt({
-        messageID,
-        sessionID: session.id,
-        model: {
-          modelID: model.modelID,
-          providerID: model.providerID,
-        },
-        agent: agent.name,
-        tools: {
-          todowrite: false,
-          todoread: false,
-          task: false,
-          ...agent.tools,
-        },
-        parts: promptParts,
-      });
-      unsub();
+      // Unsubscribe even when the subagent fails, or the subscription lives
+      // as long as the instance (upstream 63f5669eb5, #9992).
+      let result: Awaited<ReturnType<typeof SessionPrompt.prompt>>;
+      try {
+        const promptParts = await SessionPrompt.resolvePromptParts(
+          params.prompt
+        );
+        result = await SessionPrompt.prompt({
+          messageID,
+          sessionID: session.id,
+          model: {
+            modelID: model.modelID,
+            providerID: model.providerID,
+          },
+          agent: agent.name,
+          tools: {
+            todowrite: false,
+            todoread: false,
+            task: false,
+            ...agent.tools,
+          },
+          parts: promptParts,
+        });
+      } finally {
+        unsub();
+      }
       let all;
       all = await Session.messages({ sessionID: session.id });
       all = all.filter((x) => x.info.role === 'assistant');

package/src/tool/tool.ts

@@ -87,7 +87,10 @@ export namespace Tool {
     return {
       id,
       init: async () => {
-        const toolInfo = init instanceof Function ? await init() : init;
+        // Copy object-defined tools so each init() wraps the original
+        // execute once instead of stacking another wrapper on the shared
+        // object (upstream 81d3ac3bf0, #16952).
+        const toolInfo = init instanceof Function ? await init() : { ...init };
         const execute = toolInfo.execute;
         toolInfo.execute = (args, ctx) => {
           try {

package/src/tool/webfetch.ts

@@ -4,6 +4,8 @@ import TurndownService from 'turndown';
 import DESCRIPTION from './webfetch.txt';
 import { createVerboseFetch } from '../util/verbose-fetch';
 import { Permission } from '../permission';
+import { Branding } from '../branding';
+import { readBounded } from '../util/read-bounded';
 
 const verboseFetch = createVerboseFetch(fetch, { caller: 'webfetch' });
 
@@ -15,10 +17,14 @@ export const WebFetchTool = Tool.define('webfetch', {
   description: DESCRIPTION,
   parameters: z.object({
     url: z.string().describe('The URL to fetch content from'),
+    // Optional, not `.default()`: the JSON schema sent to the model would
+    // still list a defaulted field as required, and execute receives the raw
+    // arguments (upstream fd973d242e #6345, 2d2f587bfa #30215).
     format: z
       .enum(['text', 'markdown', 'html'])
+      .optional()
       .describe(
-        'The format to return the content in (text, markdown, or html)'
+        'The format to return the content in (text, markdown, or html). Defaults to markdown.'
       ),
     timeout: z
       .number()
@@ -26,6 +32,7 @@ export const WebFetchTool = Tool.define('webfetch', {
       .optional(),
   }),
   async execute(params, ctx) {
+    const format = params.format ?? 'markdown';
     // Validate URL
     if (
       !params.url.startsWith('http://') &&
@@ -50,12 +57,15 @@ export const WebFetchTool = Tool.define('webfetch', {
       MAX_TIMEOUT
     );
 
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), timeout);
+    // AbortSignal.timeout keeps no timer alive after a failed fetch, and it
+    // also aborts a body that trickles in after the headers (upstream
+    // bc1840b196 #21378, 69f1ec22e3 #33259).
+    const timeoutSignal = AbortSignal.timeout(timeout);
+    const signal = AbortSignal.any([timeoutSignal, ctx.abort]);
 
     // Build Accept header based on requested format with q parameters for fallbacks
     let acceptHeader = '*/*';
-    switch (params.format) {
+    switch (format) {
       case 'markdown':
         acceptHeader =
           'text/markdown;q=1.0, text/x-markdown;q=0.9, text/plain;q=0.8, text/html;q=0.7, */*;q=0.1';
@@ -73,40 +83,56 @@ export const WebFetchTool = Tool.define('webfetch', {
           'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8';
     }
 
-    const response = await verboseFetch(params.url, {
-      signal: AbortSignal.any([controller.signal, ctx.abort]),
-      headers: {
-        'User-Agent':
-          'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
-        Accept: acceptHeader,
-        'Accept-Language': 'en-US,en;q=0.9',
-      },
-    });
-
-    clearTimeout(timeoutId);
-
-    if (!response.ok) {
-      throw new Error(`Request failed with status code: ${response.status}`);
-    }
-
-    // Check content length
-    const contentLength = response.headers.get('content-length');
-    if (contentLength && parseInt(contentLength) > MAX_RESPONSE_SIZE) {
-      throw new Error('Response too large (exceeds 5MB limit)');
-    }
-
-    const arrayBuffer = await response.arrayBuffer();
-    if (arrayBuffer.byteLength > MAX_RESPONSE_SIZE) {
-      throw new Error('Response too large (exceeds 5MB limit)');
+    const headers = {
+      'User-Agent':
+        'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36',
+      Accept: acceptHeader,
+      'Accept-Language': 'en-US,en;q=0.9',
+    };
+
+    let body: Buffer;
+    let response: Response;
+    try {
+      const initial = await verboseFetch(params.url, { signal, headers });
+      // Cloudflare challenges a Chrome UA whose TLS fingerprint is not
+      // Chrome's, and lets an honest UA through (upstream b978ca11da #10328).
+      if (
+        initial.status === 403 &&
+        initial.headers.get('cf-mitigated') === 'challenge'
+      ) {
+        await initial.body?.cancel().catch(() => {});
+        response = await verboseFetch(params.url, {
+          signal,
+          headers: { ...headers, 'User-Agent': Branding.BINARY },
+        });
+      } else {
+        response = initial;
+      }
+
+      if (!response.ok) {
+        await response.body?.cancel().catch(() => {});
+        throw new Error(`Request failed with status code: ${response.status}`);
+      }
+
+      body = await readBounded(
+        response,
+        MAX_RESPONSE_SIZE,
+        () => new Error('Response too large (exceeds 5MB limit)')
+      );
+    } catch (error) {
+      if (timeoutSignal.aborted && !ctx.abort.aborted) {
+        throw new Error(`Request timed out after ${timeout / 1000} seconds`);
+      }
+      throw error;
     }
 
-    const content = new TextDecoder().decode(arrayBuffer);
+    const content = new TextDecoder().decode(body);
     const contentType = response.headers.get('content-type') || '';
 
     const title = `${params.url} (${contentType})`;
 
     // Handle content based on requested format and actual content type
-    switch (params.format) {
+    switch (format) {
       case 'markdown':
         if (contentType.includes('text/html')) {
           const markdown = convertHTMLToMarkdown(content);
@@ -156,37 +182,23 @@ export const WebFetchTool = Tool.define('webfetch', {
 
 async function extractTextFromHTML(html: string) {
   let text = '';
-  let skipContent = false;
+  // Count open skipped elements so text after `</script>` and text outside
+  // any element is kept (upstream ad6a8a1850, #26309).
+  let skipDepth = 0;
 
   const rewriter = new HTMLRewriter()
     .on('script, style, noscript, iframe, object, embed', {
-      element() {
-        skipContent = true;
-      },
-      text() {
-        // Skip text content inside these elements
-      },
-    })
-    .on('*', {
       element(element) {
-        // Reset skip flag when entering other elements
-        if (
-          ![
-            'script',
-            'style',
-            'noscript',
-            'iframe',
-            'object',
-            'embed',
-          ].includes(element.tagName)
-        ) {
-          skipContent = false;
-        }
+        if (!element.canHaveContent) return;
+        skipDepth++;
+        element.onEndTag(() => {
+          skipDepth--;
+        });
       },
+    })
+    .onDocument({
       text(input) {
-        if (!skipContent) {
-          text += input.text;
-        }
+        if (skipDepth === 0) text += input.text;
       },
     })
     .transform(new Response(html));

package/src/tool/webfetch.txt

@@ -1,14 +1,14 @@
 - Fetches content from a specified URL
-- Takes a URL and a prompt as input
-- Fetches the URL content, converts HTML to markdown
-- Returns the model's response about the content
+- Takes a URL and optional format as input
+- Fetches the URL content, converts to requested format (markdown by default)
+- Returns the content in the specified format
 - Use this tool when you need to retrieve and analyze web content
 
 Usage notes:
   - IMPORTANT: if another tool is present that offers better web fetching capabilities, is more targeted to the task, or has fewer restrictions, prefer using that tool instead of this one.
   - The URL must be a fully-formed valid URL
   - HTTP URLs will be automatically upgraded to HTTPS
-  - The prompt should describe what information you want to extract from the page
+  - Format options: "markdown" (default), "text", or "html"
   - This tool is read-only and does not modify any files
   - Results may be summarized if the content is very large
   - Includes a self-cleaning 15-minute cache for faster responses when repeatedly accessing the same URL