@link-assistant/agent 0.27.0 → 0.27.1

package/src/tool/websearch.ts

@@ -3,14 +3,11 @@ import { Tool } from './tool';
 import DESCRIPTION from './websearch.txt';
 import { Config } from '../config/file-config';
 import { createVerboseFetch } from '../util/verbose-fetch';
+import { ExaMcp } from '../util/exa-mcp';
 
 const verboseFetch = createVerboseFetch(fetch, { caller: 'websearch' });
 
 const API_CONFIG = {
-  BASE_URL: 'https://mcp.exa.ai',
-  ENDPOINTS: {
-    SEARCH: '/mcp',
-  },
   DEFAULT_NUM_RESULTS: 8,
 } as const;
 
@@ -30,18 +27,13 @@ interface McpSearchRequest {
   };
 }
 
-interface McpSearchResponse {
-  jsonrpc: string;
-  result: {
-    content: Array<{
-      type: string;
-      text: string;
-    }>;
-  };
-}
-
 export const WebSearchTool = Tool.define('websearch', {
-  description: DESCRIPTION,
+  // The year, not the date, so the prompt cache survives midnight (upstream
+  // 1a43e5fe87, 179c40749d #13559). Tool.define copies the object on each
+  // init(), so the getter is read per init.
+  get description() {
+    return DESCRIPTION.replace('{{year}}', String(new Date().getFullYear()));
+  },
   parameters: z.object({
     query: z.string().describe('Websearch query'),
     numResults: z
@@ -85,66 +77,19 @@ export const WebSearchTool = Tool.define('websearch', {
       },
     };
 
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), 25000);
-
-    try {
-      const headers: Record<string, string> = {
-        accept: 'application/json, text/event-stream',
-        'content-type': 'application/json',
-      };
-
-      const response = await verboseFetch(
-        `${API_CONFIG.BASE_URL}${API_CONFIG.ENDPOINTS.SEARCH}`,
-        {
-          method: 'POST',
-          headers,
-          body: JSON.stringify(searchRequest),
-          signal: AbortSignal.any([controller.signal, ctx.abort]),
-        }
-      );
+    const output = await ExaMcp.call({
+      fetch: verboseFetch,
+      body: searchRequest,
+      timeout: 25000,
+      abort: ctx.abort,
+      label: 'Search',
+    });
 
-      clearTimeout(timeoutId);
-
-      if (!response.ok) {
-        const errorText = await response.text();
-        throw new Error(`Search error (${response.status}): ${errorText}`);
-      }
-
-      const responseText = await response.text();
-
-      // Parse SSE response
-      const lines = responseText.split('\n');
-      for (const line of lines) {
-        if (line.startsWith('data: ')) {
-          const data: McpSearchResponse = JSON.parse(line.substring(6));
-          if (
-            data.result &&
-            data.result.content &&
-            data.result.content.length > 0
-          ) {
-            return {
-              output: data.result.content[0].text,
-              title: `Web search: ${params.query}`,
-              metadata: {},
-            };
-          }
-        }
-      }
-
-      return {
-        output: 'No search results found. Please try a different query.',
-        title: `Web search: ${params.query}`,
-        metadata: {},
-      };
-    } catch (error) {
-      clearTimeout(timeoutId);
-
-      if (error instanceof Error && error.name === 'AbortError') {
-        throw new Error('Search request timed out');
-      }
-
-      throw error;
-    }
+    return {
+      output:
+        output ?? 'No search results found. Please try a different query.',
+      title: `Web search: ${params.query}`,
+      metadata: {},
+    };
   },
 });

package/src/tool/websearch.txt

@@ -3,6 +3,8 @@
 - Supports configurable result counts and returns the content from the most relevant websites
 - Use this tool for accessing information beyond knowledge cutoff
 - Searches are performed automatically within a single API call
+- The current year is {{year}}. You MUST use this year when searching for recent information or current events
+- Example: If the current year is 2026 and the user asks for "latest AI news", search for "AI news 2026", NOT "AI news 2025"
 
 Usage notes:
   - Supports live crawling modes: 'fallback' (backup if cached unavailable) or 'preferred' (prioritize live crawling)

package/src/tool/write.ts

@@ -4,6 +4,11 @@ import { Tool } from './tool';
 import DESCRIPTION from './write.txt';
 import { Instance } from '../project/instance';
 import { Permission } from '../permission';
+import { FileTime } from '../file/time';
+import { Bus } from '../bus';
+import { File } from '../file';
+import { Bom } from '../util/bom';
+import { config } from '../config/config';
 
 export const WriteTool = Tool.define('write', {
   description: DESCRIPTION,
@@ -32,11 +37,22 @@ export const WriteTool = Tool.define('write', {
       metadata: { filePath: filepath },
     });
 
-    const file = Bun.file(filepath);
-    const exists = await file.exists();
-
-    // Write the file without permission checks
-    await Bun.write(filepath, params.content);
+    // Serialize with concurrent edit/write calls on the same file.
+    const exists = await FileTime.withLock(filepath, async () => {
+      // No read-before-write requirement here on purpose: this fork lets
+      // the write tool overwrite files without a prior read.
+      const file = Bun.file(filepath);
+      const exists = await file.exists();
+      // Keep an existing UTF-8 BOM (Bun.file().text() would hide it).
+      const bom = exists && (await Bom.has(filepath));
+      const next = Bom.split(params.content);
+      await Bun.write(filepath, Bom.join(next.text, bom || next.bom));
+      await Bus.publish(File.Event.Edited, { file: filepath });
+      // Record the write as a read so a follow-up edit does not fail with
+      // "You must read the file ... before overwriting it".
+      FileTime.read(ctx.sessionID, filepath);
+      return exists;
+    });
 
     return {
       title: path.relative(Instance.worktree, filepath),
@@ -45,7 +61,8 @@ export const WriteTool = Tool.define('write', {
         filepath,
         exists: exists,
       },
-      output: '',
+      // --legacy-tool-output: write used to return an empty output.
+      output: config.legacyToolOutput ? '' : 'Wrote file successfully.',
     };
   },
 });

package/src/util/bom.ts

@@ -0,0 +1,32 @@
+// UTF-8 byte-order-mark helpers, ported from upstream OpenCode
+// (packages/opencode/src/util/bom.ts, PR #23797). `Bun.file().text()` and
+// `TextDecoder` drop the BOM by default, so tools that read-modify-write a
+// file must decode with `ignoreBOM: true` and re-attach it on write.
+export namespace Bom {
+  const BOM_CODE = 0xfeff;
+  const BOM = String.fromCharCode(BOM_CODE);
+
+  export function split(text: string) {
+    if (text.charCodeAt(0) !== BOM_CODE) return { bom: false, text };
+    return { bom: true, text: text.slice(1) };
+  }
+
+  export function join(text: string, bom: boolean) {
+    const stripped = split(text).text;
+    if (!bom) return stripped;
+    return BOM + stripped;
+  }
+
+  export async function readFile(filePath: string) {
+    const bytes = await Bun.file(filePath).arrayBuffer();
+    return split(new TextDecoder('utf-8', { ignoreBOM: true }).decode(bytes));
+  }
+
+  // Checks only the first three bytes (EF BB BF), without reading the file.
+  export async function has(filePath: string) {
+    const head = new Uint8Array(
+      await Bun.file(filePath).slice(0, 3).arrayBuffer()
+    );
+    return head[0] === 0xef && head[1] === 0xbb && head[2] === 0xbf;
+  }
+}

package/src/util/exa-mcp.ts

@@ -0,0 +1,82 @@
+import { readBounded } from './read-bounded';
+
+// Shared transport for the Exa MCP tools (websearch, codesearch).
+export namespace ExaMcp {
+  export const MAX_RESPONSE_SIZE = 5 * 1024 * 1024;
+
+  // The anonymous endpoint is rate-limited; an EXA_API_KEY lifts the limit
+  // (upstream fde3d9133b, #16362). An empty value counts as unset.
+  export function url() {
+    const key = process.env.EXA_API_KEY;
+    return key
+      ? `https://mcp.exa.ai/mcp?exaApiKey=${encodeURIComponent(key)}`
+      : 'https://mcp.exa.ai/mcp';
+  }
+
+  type Message = {
+    result?: { content?: Array<{ type: string; text: string }> };
+  };
+
+  function first(message: Message | undefined) {
+    const content = message?.result?.content;
+    return content && content.length > 0 ? content[0].text : undefined;
+  }
+
+  // Exa answers with SSE `data:` lines or with a plain JSON body.
+  export function parse(text: string): string | undefined {
+    for (const line of text.split('\n')) {
+      if (!line.startsWith('data:')) continue;
+      const result = first(JSON.parse(line.slice(5).trim()));
+      if (result !== undefined) return result;
+    }
+    const trimmed = text.trim();
+    if (!trimmed.startsWith('{')) return undefined;
+    try {
+      return first(JSON.parse(trimmed));
+    } catch {
+      return undefined;
+    }
+  }
+
+  // The request timeout covers the body read too, and the body is bounded
+  // (upstream 69f1ec22e3, #33259).
+  export async function call(input: {
+    fetch: typeof fetch;
+    body: unknown;
+    timeout: number;
+    abort: AbortSignal;
+    label: string;
+  }): Promise<string | undefined> {
+    const timeoutSignal = AbortSignal.timeout(input.timeout);
+    const tooLarge = () =>
+      new Error(`${input.label} error: Response too large (exceeds 5MB limit)`);
+    try {
+      const response = await input.fetch(url(), {
+        method: 'POST',
+        headers: {
+          accept: 'application/json, text/event-stream',
+          'content-type': 'application/json',
+        },
+        body: JSON.stringify(input.body),
+        signal: AbortSignal.any([timeoutSignal, input.abort]),
+      });
+      const text = (
+        await readBounded(response, MAX_RESPONSE_SIZE, tooLarge)
+      ).toString('utf-8');
+      if (!response.ok) {
+        throw new Error(`${input.label} error (${response.status}): ${text}`);
+      }
+      return parse(text);
+    } catch (error) {
+      // AbortSignal.timeout aborts with a TimeoutError, not an AbortError.
+      if (
+        error instanceof Error &&
+        (error.name === 'TimeoutError' || error.name === 'AbortError') &&
+        !input.abort.aborted
+      ) {
+        throw new Error(`${input.label} request timed out`);
+      }
+      throw error;
+    }
+  }
+}

package/src/util/legacy-error-names.ts

@@ -0,0 +1,39 @@
+import { config } from '../config/config';
+
+/**
+ * Backward compatibility for the error objects written to JSON output
+ * (issue #335).
+ *
+ * The upstream sync introduced `ContextOverflowError` for requests that exceed
+ * the model's context window. Before, the same failure was reported as a
+ * non-retryable `APIError`. Consumers that switch on `error.name` can ask for
+ * the previous name with --legacy-error-names /
+ * LINK_ASSISTANT_AGENT_LEGACY_ERROR_NAMES=true. Stored session messages keep
+ * the new name; only the JSON output is mapped.
+ */
+const LEGACY_NAMES: Record<
+  string,
+  (data: Record<string, unknown>) => { name: string; data: unknown }
+> = {
+  ContextOverflowError: (data) => ({
+    name: 'APIError',
+    data: { ...data, isRetryable: false },
+  }),
+};
+
+export function legacyErrorObject<T>(
+  error: T,
+  enabled: boolean = config.legacyErrorNames
+): T {
+  if (!enabled || !error || typeof error !== 'object') return error;
+  const { name, data } = error as { name?: unknown; data?: unknown };
+  if (typeof name !== 'string') return error;
+  const map = LEGACY_NAMES[name];
+  if (!map) return error;
+  return {
+    ...error,
+    ...map(
+      data && typeof data === 'object' ? (data as Record<string, unknown>) : {}
+    ),
+  } as T;
+}

package/src/util/read-bounded.ts

@@ -0,0 +1,32 @@
+// Reads a response body, failing as soon as it exceeds `max` bytes instead of
+// buffering an oversized, chunked or endless body before checking its size
+// (upstream 69f1ec22e3, #33259).
+export async function readBounded(
+  response: Response,
+  max: number,
+  tooLarge: () => Error
+): Promise<Buffer> {
+  const length = Number.parseInt(
+    response.headers.get('content-length') ?? '',
+    10
+  );
+  if (Number.isSafeInteger(length) && length > max) {
+    await response.body?.cancel().catch(() => {});
+    throw tooLarge();
+  }
+  if (!response.body) return Buffer.alloc(0);
+  const reader = response.body.getReader();
+  const chunks: Uint8Array[] = [];
+  let size = 0;
+  for (;;) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    size += value.byteLength;
+    if (size > max) {
+      await reader.cancel().catch(() => {});
+      throw tooLarge();
+    }
+    chunks.push(value);
+  }
+  return Buffer.concat(chunks, size);
+}

package/src/util/sse-usage-extractor.ts

@@ -13,6 +13,13 @@ export interface SSEUsageData {
 }
 
 const pendingUsage = new Map<string, SSEUsageData>();
+/**
+ * Usage is only consumed when the provider response lacks it, so entries for
+ * every other streamed request used to stay in memory for the life of the
+ * process (issue #335 memory-leak audit). Only recent requests can still be
+ * consumed, so keep a bounded number and evict the oldest first.
+ */
+export const MAX_PENDING_SSE_USAGE = 64;
 let requestCounter = 0;
 
 export namespace SSEUsageExtractor {
@@ -77,24 +84,71 @@ export namespace SSEUsageExtractor {
     return lastUsage;
   }
 
+  /** Longest SSE line kept while waiting for its newline. */
+  export const MAX_SSE_LINE_CHARS = 1024 * 1024;
+
+  /**
+   * Incremental extractor for a streamed SSE body. Only the unfinished last
+   * line is buffered, so the whole stream can be read (usage arrives in the
+   * final events) with bounded memory. The previous code buffered the first
+   * 50 000 characters and stopped reading the tee branch, which both lost the
+   * usage of longer responses and left the tee buffering the rest of the
+   * response for a reader that never came back (issue #335).
+   */
+  export function createTracker() {
+    let partial = '';
+    let latest: SSEUsageData | undefined;
+    const scan = (text: string) => {
+      const usage = extractUsageFromSSEChunk(text);
+      if (usage) latest = usage;
+    };
+    return {
+      push(text: string) {
+        partial += text;
+        const end = partial.lastIndexOf('\n');
+        if (end === -1) {
+          if (partial.length > MAX_SSE_LINE_CHARS) partial = '';
+          return;
+        }
+        scan(partial.slice(0, end));
+        partial = partial.slice(end + 1);
+        if (partial.length > MAX_SSE_LINE_CHARS) partial = '';
+      },
+      finish(): SSEUsageData | undefined {
+        if (partial) scan(partial);
+        partial = '';
+        return latest;
+      },
+    };
+  }
+
+  /** Stores usage found by a tracker under `requestId`. */
+  export function storeUsage(requestId: string, usage: SSEUsageData) {
+    pendingUsage.delete(requestId);
+    pendingUsage.set(requestId, usage);
+    while (pendingUsage.size > MAX_PENDING_SSE_USAGE) {
+      const oldest = pendingUsage.keys().next().value;
+      if (oldest === undefined) break;
+      pendingUsage.delete(oldest);
+    }
+    if (isVerbose()) {
+      log.info('raw SSE usage extracted', {
+        requestId,
+        promptTokens: usage.promptTokens,
+        completionTokens: usage.completionTokens,
+        totalTokens: usage.totalTokens,
+        cachedTokens: usage.cachedTokens,
+        reasoningTokens: usage.reasoningTokens,
+      });
+    }
+  }
+
   export function processStreamForUsage(
     requestId: string,
     streamBody: string
   ): void {
     const usage = extractUsageFromSSEChunk(streamBody);
-    if (usage) {
-      pendingUsage.set(requestId, usage);
-      if (isVerbose()) {
-        log.info('raw SSE usage extracted', {
-          requestId,
-          promptTokens: usage.promptTokens,
-          completionTokens: usage.completionTokens,
-          totalTokens: usage.totalTokens,
-          cachedTokens: usage.cachedTokens,
-          reasoningTokens: usage.reasoningTokens,
-        });
-      }
-    }
+    if (usage) storeUsage(requestId, usage);
   }
 
   export function getUsage(requestId: string): SSEUsageData | undefined {

package/src/util/timeout.ts

@@ -1,10 +1,9 @@
 export function withTimeout<T>(promise: Promise<T>, ms: number): Promise<T> {
   let timeout: NodeJS.Timeout;
   return Promise.race([
-    promise.then((result) => {
-      clearTimeout(timeout);
-      return result;
-    }),
+    // Clear the timer on rejection too, so a failed call does not keep the
+    // timer and its closure alive until the deadline (issue #335).
+    promise.finally(() => clearTimeout(timeout)),
     new Promise<never>((_, reject) => {
       timeout = setTimeout(() => {
         reject(new Error(`Operation timed out after ${ms}ms`));

package/src/util/verbose-fetch.ts

@@ -74,6 +74,43 @@ export function sanitizeHeaders(
   return sanitized;
 }
 
+const SENSITIVE_QUERY_PARAMS = new Set([
+  'exaapikey',
+  'apikey',
+  'api_key',
+  'api-key',
+  'key',
+  'token',
+  'access_token',
+  'auth',
+  'secret',
+]);
+
+/**
+ * Mask credentials passed as URL query parameters (for example the Exa MCP
+ * URL carries `exaApiKey=...`) so verbose logs do not leak them (issue #335).
+ * Unparseable URLs are returned unchanged.
+ */
+export function sanitizeUrl(raw: string): string {
+  let parsed: URL;
+  try {
+    parsed = new URL(raw);
+  } catch {
+    return raw;
+  }
+  let changed = false;
+  if (parsed.password) {
+    parsed.password = 'REDACTED';
+    changed = true;
+  }
+  for (const name of Array.from(parsed.searchParams.keys())) {
+    if (!SENSITIVE_QUERY_PARAMS.has(name.toLowerCase())) continue;
+    parsed.searchParams.set(name, '[REDACTED]');
+    changed = true;
+  }
+  return changed ? parsed.toString() : raw;
+}
+
 /**
  * Create a body preview string, truncated to maxChars.
  */
@@ -147,12 +184,14 @@ export function createVerboseFetch(
     globalHttpCallCount++;
     const callNum = globalHttpCallCount;
 
-    const url =
+    const rawUrl =
       typeof input === 'string'
         ? input
         : input instanceof URL
           ? input.toString()
           : input.url;
+    // Only used for logging; never sent anywhere.
+    const url = sanitizeUrl(rawUrl);
     const method = init?.method ?? 'GET';
 
     // Prepare request details for logging (error-resilient)