Function createReadTool

packages/computer/src/tools/fs/read.ts:56–179

(options: ReadToolOptions)

  return _enc.encode(s).length;
}
export function createReadTool(options: ReadToolOptions): Tool<z.infer<typeof inputSchema>> {
  const { store } = options;
  const maxLines = options.maxLines ?? DEFAULT_MAX_LINES;
  const maxBytes = options.maxBytes ?? DEFAULT_MAX_BYTES;

  return tool({
    description: `Read the contents of a file. Output is truncated to ${maxLines} lines or ${Math.round(maxBytes / 1024)}KB, whichever is reached first; use offset/limit to page through large files.`,
    inputSchema,
    execute: async ({ path, offset, limit }): Promise<ReadResult | { error: string }> => {
      const stat = await store.stat(path);
      if (!stat) return { error: `File not found: ${path}` };

      const startLine = offset ?? 1;
      const wantedLines = limit ?? maxLines;
      const lineCap = Math.min(wantedLines, maxLines);

      const decoder = new TextDecoder("utf-8");
      let carry = ""; // bytes from previous chunk that didn't end on a newline
      let currentLine = 1; // 1-indexed line we're about to emit
      const collected: string[] = [];
      let collectedBytes = 0;
      let firstEmittedLine: number | null = null;
      let truncatedByBudget = false;
      let firstLineOverflow = false;

      const processLine = (line: string): boolean => {
        // Returns true to keep going, false to stop the outer pump.
        if (currentLine < startLine) {
          currentLine++;
          return true;
        }
        // We're at or past `startLine` — try to emit.
        const lineBytes = utf8ByteLength(line);
        if (collected.length === 0 && lineBytes > maxBytes) {
          firstLineOverflow = true;
          return false;
        }
        // Stop before emitting if this line would push us over either cap.
        if (collected.length >= lineCap) {
          truncatedByBudget = true;
          return false;
        }
        if (collectedBytes + lineBytes + (collected.length > 0 ? 1 : 0) > maxBytes) {
          truncatedByBudget = true;
          return false;
        }
        if (firstEmittedLine === null) firstEmittedLine = currentLine;
        collected.push(line);
        collectedBytes += lineBytes + (collected.length > 1 ? 1 : 0);
        currentLine++;
        return true;
      };

      let keepGoing = true;
      for await (const chunk of store.readChunks(path)) {
        if (!keepGoing) break;
        carry += decoder.decode(chunk, { stream: true });
        // Process every complete line in `carry`. Keep the final partial line