@namzu/sdk 57.0.0 → 58.0.0

package/src/tools/builtins/grep.ts

@@ -1,8 +1,9 @@
-import { readFile, stat } from 'node:fs/promises'
+import { stat } from 'node:fs/promises'
 import { isAbsolute, join, relative, sep } from 'node:path'
 import { z } from 'zod'
 import { walkFilesLocally } from '../../sandbox/file-walk.js'
 import type { SandboxWalkFilesOptions } from '../../types/sandbox/index.js'
+import type { ToolContext } from '../../types/tool/index.js'
 import { subscribeToAbort } from '../../utils/abort.js'
 import { defineTool } from '../defineTool.js'
 import {
@@ -13,6 +14,7 @@ import {
 	toolRoots,
 } from '../paths.js'
 import { relativePosix, resolveWithinPosix } from '../posix-path.js'
+import { readBoundedChunks, readBoundedFile } from './bounded-file-read.js'
 
 /** A remote read has no signal parameter; stop consuming it when the turn ends. */
 async function readWithSignal(read: () => Promise<Buffer>, signal?: AbortSignal): Promise<Buffer> {
@@ -57,6 +59,46 @@ export const DEFAULT_HEAD_LIMIT = 250
 /** A matching or context line longer than this is replaced by a notice, not printed. */
 export const MAX_LINE_COLUMNS = 500
 
+/** File kinds for the `type` argument: extensions (without the dot) and exact file names. */
+const FILE_TYPES: Record<string, { ext: string[]; names?: string[] }> = {
+	js: { ext: ['js', 'jsx', 'mjs', 'cjs'] },
+	ts: { ext: ['ts', 'tsx', 'mts', 'cts'] },
+	py: { ext: ['py', 'pyi'] },
+	rust: { ext: ['rs'] },
+	go: { ext: ['go'] },
+	java: { ext: ['java'] },
+	kotlin: { ext: ['kt', 'kts'] },
+	swift: { ext: ['swift'] },
+	c: { ext: ['c', 'h'] },
+	cpp: { ext: ['cc', 'cpp', 'cxx', 'hpp', 'hh', 'hxx', 'h'] },
+	cs: { ext: ['cs'] },
+	rb: { ext: ['rb', 'rake', 'gemspec'] },
+	php: { ext: ['php'] },
+	sh: { ext: ['sh', 'bash', 'zsh'] },
+	md: { ext: ['md', 'markdown', 'mdx'] },
+	json: { ext: ['json', 'jsonc'] },
+	yaml: { ext: ['yml', 'yaml'] },
+	toml: { ext: ['toml'] },
+	html: { ext: ['html', 'htm'] },
+	css: { ext: ['css', 'scss', 'sass', 'less'] },
+	sql: { ext: ['sql'] },
+	xml: { ext: ['xml'] },
+	make: { ext: ['mk', 'mak'], names: ['Makefile', 'makefile', 'GNUmakefile'] },
+	docker: { ext: [], names: ['Dockerfile'] },
+}
+FILE_TYPES.javascript = FILE_TYPES.js as { ext: string[] }
+FILE_TYPES.typescript = FILE_TYPES.ts as { ext: string[] }
+FILE_TYPES.python = FILE_TYPES.py as { ext: string[] }
+FILE_TYPES.rs = FILE_TYPES.rust as { ext: string[] }
+FILE_TYPES.markdown = FILE_TYPES.md as { ext: string[] }
+
+function matchesType(path: string, kind: { ext: string[]; names?: string[] }): boolean {
+	const name = path.slice(path.lastIndexOf('/') + 1)
+	if (kind.names?.includes(name)) return true
+	const dot = name.lastIndexOf('.')
+	return dot > 0 && kind.ext.includes(name.slice(dot + 1))
+}
+
 const inputSchema = z.object({
 	pattern: z.string().describe('Regular expression pattern to search for in file contents'),
 	path: z
@@ -74,6 +116,24 @@ const inputSchema = z.object({
 		.min(0)
 		.default(0)
 		.describe('Number of lines to show before and after each match'),
+	before_context: z.coerce
+		.number()
+		.int()
+		.min(0)
+		.optional()
+		.describe('Lines before each content match; overrides context_lines for this side.'),
+	after_context: z.coerce
+		.number()
+		.int()
+		.min(0)
+		.optional()
+		.describe('Lines after each content match; overrides context_lines for this side.'),
+	only_matching: z
+		.boolean()
+		.optional()
+		.describe(
+			'In content mode, print each matched substring instead of the whole line. Ignores context.',
+		),
 	output_mode: z
 		.enum(['files_with_matches', 'content', 'count'])
 		.default('files_with_matches')
@@ -94,6 +154,18 @@ const inputSchema = z.object({
 		.min(0)
 		.default(0)
 		.describe('Skip this many entries before applying head_limit, to page through results.'),
+	multiline: z
+		.boolean()
+		.optional()
+		.describe(
+			'Let a pattern span lines: "." also matches a newline, and "^" and "$" match at line starts and ends. Content mode prints every line a match covers.',
+		),
+	type: z
+		.string()
+		.optional()
+		.describe(
+			'Only search files of this kind, e.g. "js", "ts", "py", "rust", "go", "java", "md". Narrows what include selects.',
+		),
 	max_results: z.coerce
 		.number()
 		.int()
@@ -117,7 +189,7 @@ function isBinaryContent(buffer: Buffer): boolean {
 export const GrepTool = defineTool({
 	name: 'grep',
 	description:
-		'Searches file contents using a regular expression. By default returns the paths of matching files, newest first; output_mode "content" returns matching lines with file paths, line numbers and optional context lines, and "count" returns the number of matching lines per file. Results are paged: head_limit (default 250, 0 for none) and offset. A line over 500 characters is replaced by a notice. Searches with a bounded traversal and identifies incomplete searches. Skips binary files, files over 5 MB, and symlinks. Choose the narrowest relevant directory.',
+		'Searches file contents using a regular expression. By default returns the paths of matching files, newest first; output_mode "content" returns matching lines with file paths, line numbers and optional context lines, and "count" returns the number of matching lines per file. Set multiline for a pattern that spans lines and type (js, py, rust, ...) to search one kind of file. In content mode, before_context and after_context override symmetric context_lines; only_matching returns matched substrings without context. Results are paged: head_limit (default 250, 0 for none) and offset. A line over 500 characters is replaced by a notice. Searches with a bounded traversal and identifies incomplete searches. Skips binary files, files over 5 MB, and symlinks. Choose the narrowest relevant directory.',
 	inputSchema,
 	category: 'analysis',
 	// Declared so a path outside the turn's roots can be reviewed before the
@@ -146,7 +218,18 @@ export const GrepTool = defineTool({
 
 	async execute(input, context) {
 		context.abortSignal?.throwIfAborted()
-		const flags = input.case_sensitive ? 'g' : 'gi'
+		const multiline = input.multiline === true
+		const flags = `${(input.case_sensitive ?? true) ? 'g' : 'gi'}${multiline ? 'ms' : ''}`
+		const fileType = input.type
+			? FILE_TYPES[input.type.toLowerCase().replace(/^\./, '')]
+			: undefined
+		if (input.type && !fileType) {
+			return {
+				success: false,
+				output: '',
+				error: `Unknown file type "${input.type}". Known types: ${Object.keys(FILE_TYPES).sort().join(', ')}. Use include for another pattern.`,
+			}
+		}
 		let regex: RegExp
 		try {
 			regex = new RegExp(input.pattern, flags)
@@ -189,6 +272,8 @@ export const GrepTool = defineTool({
 		// `max_results` predates `head_limit`; it keeps meaning "at most this many".
 		const headLimit = input.head_limit ?? input.max_results ?? DEFAULT_HEAD_LIMIT
 		const offset = input.offset ?? 0
+		const beforeContext = input.before_context ?? input.context_lines ?? 0
+		const afterContext = input.after_context ?? input.context_lines ?? 0
 		// Content lines in output order. Only content mode uses them as the
 		// result; the other modes build from `matchedFiles`.
 		const results: string[] = []
@@ -213,6 +298,7 @@ export const GrepTool = defineTool({
 					)
 				}
 				filesSearched++
+				if (fileType && !matchesType(entry.path, fileType)) continue
 				if (entry.size > MAX_FILE_SIZE) continue
 
 				let content: string
@@ -221,10 +307,15 @@ export const GrepTool = defineTool({
 					const buffer = await readWithSignal(
 						() =>
 							sandbox
-								? sandbox.readFile(filePath)
+								? readBoundedChunks(
+										(offset, length) =>
+											sandbox.readFile(filePath, { offset, length, signal: context.abortSignal }),
+										MAX_FILE_SIZE,
+										context.abortSignal,
+									)
 								: resolveWithinReal(root, filePath).then((path) => {
 										contained = path
-										return readFile(path, { signal: context.abortSignal })
+										return readBoundedFile(path, MAX_FILE_SIZE, context.abortSignal)
 									}),
 						context.abortSignal,
 					)
@@ -245,36 +336,47 @@ export const GrepTool = defineTool({
 							.split(sep)
 							.join('/')}`
 
-				for (let i = 0; i < lines.length; i++) {
-					context.abortSignal?.throwIfAborted()
-					const line = lines[i] ?? ''
-					regex.lastIndex = 0
-					if (!regex.test(line)) continue
+				if (mode === 'content' && input.only_matching) {
+					for (const fragment of matchingFragments(content, regex, multiline)) {
+						context.abortSignal?.throwIfAborted()
+						if (fileMatches++ === 0) filesMatched++
+						totalMatches++
+						results.push(`${relPath}:${fragment.line}:${clipLine(fragment.text, 'matching')}`)
+						if (headLimit > 0 && results.length >= offset + headLimit) {
+							pageHasMore = true
+							break
+						}
+					}
+					if (pageHasMore) break
+					continue
+				}
 
+				// Each hit is the first and last line (0-based) a match covers.
+				const hits = multiline ? multilineHits(content, regex) : lineHits(lines, regex, context)
+				// Count mode reports matching lines, so a line covered twice counts once.
+				const countedLines = new Set<number>()
+				for (const [first, last] of hits) {
+					context.abortSignal?.throwIfAborted()
 					if (fileMatches === 0) filesMatched++
 					fileMatches++
 					totalMatches++
 					// A file list only needs to know that the file matches.
 					if (mode === 'files_with_matches') break
-					if (mode === 'count') continue
-
-					if (input.context_lines > 0) {
-						const start = Math.max(0, i - input.context_lines)
-						const end = Math.min(lines.length - 1, i + input.context_lines)
-
-						if (results.length > 0) {
-							results.push('--')
-						}
+					if (mode === 'count') {
+						for (let j = first; j <= last; j++) countedLines.add(j)
+						continue
+					}
 
-						for (let j = start; j <= end; j++) {
-							const prefix = j === i ? ':' : '-'
-							const text = lines[j] ?? ''
-							results.push(
-								`${relPath}${prefix}${j + 1}${prefix}${clipLine(text, j === i ? 'matching' : 'context')}`,
-							)
-						}
-					} else {
-						results.push(`${relPath}:${i + 1}:${clipLine(line, 'matching')}`)
+					const before = Math.max(0, first - beforeContext)
+					const after = Math.min(lines.length - 1, last + afterContext)
+					if ((beforeContext > 0 || afterContext > 0) && results.length > 0) results.push('--')
+					for (let j = before; j <= after; j++) {
+						if (headLimit > 0 && results.length >= offset + headLimit) break
+						const hit = j >= first && j <= last
+						const prefix = hit ? ':' : '-'
+						results.push(
+							`${relPath}${prefix}${j + 1}${prefix}${clipLine(lines[j] ?? '', hit ? 'matching' : 'context')}`,
+						)
 					}
 
 					// A full page ends the search: another file is not read just to
@@ -285,6 +387,7 @@ export const GrepTool = defineTool({
 						break
 					}
 				}
+				if (mode === 'count' && fileMatches > 0) fileMatches = countedLines.size
 
 				if (fileMatches > 0 && mode !== 'content') {
 					matchedFiles.push({
@@ -404,3 +507,70 @@ async function sortByNewest<T extends { relPath: string; host?: string }>(
 		.sort((a, b) => b.mtime - a.mtime || a.file.relPath.localeCompare(b.file.relPath))
 		.map((entry) => entry.file)
 }
+
+/** One hit per matching line. */
+function lineHits(
+	lines: readonly string[],
+	regex: RegExp,
+	context: ToolContext,
+): [number, number][] {
+	const hits: [number, number][] = []
+	for (let i = 0; i < lines.length; i++) {
+		context.abortSignal?.throwIfAborted()
+		regex.lastIndex = 0
+		if (regex.test(lines[i] ?? '')) hits.push([i, i])
+	}
+	return hits
+}
+
+/** One hit per match over the whole text, from the line it starts on to the line it ends on. */
+function multilineHits(content: string, regex: RegExp): [number, number][] {
+	const hits: [number, number][] = []
+	const starts = [0]
+	for (let i = content.indexOf('\n'); i !== -1; i = content.indexOf('\n', i + 1)) starts.push(i + 1)
+	const lineOf = (offset: number): number => {
+		let lo = 0
+		let hi = starts.length - 1
+		while (lo < hi) {
+			const mid = (lo + hi + 1) >> 1
+			if ((starts[mid] ?? 0) <= offset) lo = mid
+			else hi = mid - 1
+		}
+		return lo
+	}
+	regex.lastIndex = 0
+	for (let m = regex.exec(content); m !== null; m = regex.exec(content)) {
+		const text = m[0]
+		if (text.length === 0) {
+			regex.lastIndex++
+			continue
+		}
+		// A match that ends on a newline covers the lines before it, not the next one.
+		const end = m.index + text.length - (text.endsWith('\n') ? 1 : 0)
+		hits.push([lineOf(m.index), lineOf(Math.max(m.index, end))])
+	}
+	return hits
+}
+
+/** Lazy fragments: a dense file never allocates every match before paging. */
+function* matchingFragments(content: string, regex: RegExp, multiline: boolean) {
+	const subjects = multiline ? [content] : content.split('\n')
+	let line = 1
+	for (const subject of subjects) {
+		regex.lastIndex = 0
+		let previous = 0
+		for (let match = regex.exec(subject); match !== null; match = regex.exec(subject)) {
+			if (multiline) {
+				for (let i = previous; i < match.index; i++) if (subject[i] === '\n') line++
+				previous = match.index
+			}
+			if (match[0].length === 0) {
+				regex.lastIndex++
+				continue
+			}
+			// Keep a multiline substring on one output row, never forge path rows.
+			yield { line, text: match[0].replace(/\n/g, '\\n') }
+		}
+		if (!multiline) line++
+	}
+}

package/src/tools/builtins/read-file.ts

@@ -1,14 +1,23 @@
-import { readFile, stat } from 'node:fs/promises'
+import { stat } from 'node:fs/promises'
 import { extname } from 'node:path'
 import { z } from 'zod'
-import type { ToolContext } from '../../types/tool/index.js'
+import type { ToolContext, ToolResult } from '../../types/tool/index.js'
 import type { ToolFacts } from '../../types/tool/presentation.js'
 import { defineTool } from '../defineTool.js'
 import { resolveWithinAnyReal, toolRoots } from '../paths.js'
 import { resolveRetainedOutput } from '../retained-output.js'
 import { looksBinary } from '../text-window.js'
+import { TEXT_MAX_INPUT_BYTES, readBoundedChunks, readBoundedFile } from './bounded-file-read.js'
 import { fingerprintContent } from './content-fingerprint.js'
+import {
+	type MediaRead,
+	NOTEBOOK_MAX_BYTES,
+	PDF_MAX_BYTES,
+	readNotebook,
+	readPdfPages,
+} from './read-media.js'
 import { type RenderedRead, humanBytes, renderCappedRead } from './read-render.js'
+import { MAX_BYTES as IMAGE_MAX_BYTES, inspectImageBytes } from './view-image.js'
 
 const inputSchema = z.object({
 	path: z.string().describe('Path to the file to read (absolute or relative)'),
@@ -35,6 +44,12 @@ const inputSchema = z.object({
 		.optional()
 		.describe('Starting line number (0-indexed). Defaults to 0 (beginning of file).'),
 	limit: z.coerce.number().optional().describe('Maximum number of lines to read'),
+	pages: z
+		.string()
+		.optional()
+		.describe(
+			'For a PDF: the pages to render as images, one page ("3") or one range ("1-5"), at most 20 pages per request. Required for a PDF of more than 10 pages.',
+		),
 	allow_large: z
 		.boolean()
 		.optional()
@@ -46,7 +61,7 @@ const inputSchema = z.object({
 export const ReadFileTool = defineTool({
 	name: 'read',
 	description:
-		'Reads a file and returns its contents with line numbers. Supports readRange ([start,end], 1-indexed inclusive) or offset/limit for large files. Without a window it returns the first 2000 lines and says so — pass offset/limit to continue. A file over 256 KiB is refused unless a window is named, and a result over about 25,000 tokens is cut to a first page that names the next call; pass allow_large only when you need all of it.',
+		'Reads a file and returns its contents with line numbers. Also reads images (PNG, JPEG, WebP), which come back as pictures; PDFs, whose pages come back as images (pass pages, for example "1-5", at most 20 pages per request; a PDF of more than 10 pages needs it); and Jupyter notebooks (.ipynb), which come back as cells with their outputs. Supports readRange ([start,end], 1-indexed inclusive) or offset/limit for large files. Without a window it returns the first 2000 lines and says so — pass offset/limit to continue. A file over 256 KiB is refused unless a window is named, and a result over about 25,000 tokens is cut to a first page that names the next call; pass allow_large only when you need all of it.',
 	inputSchema,
 	category: 'filesystem',
 	// Declared so a path outside the turn's roots can be reviewed before the
@@ -78,8 +93,17 @@ export const ReadFileTool = defineTool({
 		const retained = await resolveRetainedOutput(context.retainedOutputDirectory, input.path)
 		// Sandbox-aware: route through sandbox.readFile() when available
 		if (context.sandbox && retained === undefined) {
-			const buffer = await context.sandbox.readFile(input.path)
-			const binaryGuidance = describeStructuredBinaryRead(input.path, buffer)
+			const sandbox = context.sandbox
+			const buffer = await readBoundedChunks(
+				(offset, length) =>
+					sandbox.readFile(input.path, { offset, length, signal: context.abortSignal }),
+				PDF_MAX_BYTES,
+				context.abortSignal,
+				(prefix) => inputLimit(input.path, prefix),
+			)
+			const media = await readMediaFile(buffer, input.path, input, context, true)
+			if (media) return media
+			const binaryGuidance = describeStructuredBinaryRead(input.path)
 			if (binaryGuidance) {
 				return {
 					success: false,
@@ -121,15 +145,22 @@ export const ReadFileTool = defineTool({
 		}
 
 		const filePath = retained ?? (await resolveWithinAnyReal(toolRoots(context), input.path))
+		// Pictures, PDFs and notebooks are not text: they have their own size
+		// limits and are never numbered, so the text cap below does not apply.
+		const namesMediaFile = namesMedia(filePath)
 		// Refused on the size alone, before the file is in memory, when no window
 		// was named: the cap exists so a huge file is never loaded to be refused.
-		if (input.readRange === undefined && input.limit === undefined) {
+		if (!namesMediaFile && input.readRange === undefined && input.limit === undefined) {
 			const { size } = await stat(filePath)
 			const early = renderCappedRead('', size, input, capOptions(input, context))
 			if (!early.ok) return refusedRead(filePath, size, early.message, false)
 		}
-		const buffer = await readFile(filePath)
-		const binaryGuidance = describeStructuredBinaryRead(filePath, buffer)
+		const buffer = await readBoundedFile(filePath, PDF_MAX_BYTES, context.abortSignal, (prefix) =>
+			inputLimit(filePath, prefix),
+		)
+		const media = await readMediaFile(buffer, filePath, input, context, false)
+		if (media) return media
+		const binaryGuidance = describeStructuredBinaryRead(filePath)
 		if (binaryGuidance) {
 			return {
 				success: false,
@@ -172,6 +203,117 @@ export const ReadFileTool = defineTool({
 	},
 })
 
+type MediaKind = 'image' | 'pdf' | 'notebook'
+
+/**
+ * What a file is by its bytes, never by its name: a text file called `.png` is
+ * still text. A notebook is JSON, so only its extension can name it.
+ */
+function mediaKindOf(path: string, buffer: Buffer): MediaKind | undefined {
+	if (buffer.subarray(0, 8).equals(Buffer.from('89504e470d0a1a0a', 'hex'))) return 'image'
+	if (buffer[0] === 0xff && buffer[1] === 0xd8) return 'image'
+	if (buffer.toString('ascii', 0, 4) === 'RIFF' && buffer.toString('ascii', 8, 12) === 'WEBP')
+		return 'image'
+	if (buffer.subarray(0, 4).toString('utf8') === '%PDF') return 'pdf'
+	if (extname(path).toLowerCase() === '.ipynb') return 'notebook'
+	return undefined
+}
+
+/** A name that suggests a file the text cap should not judge. */
+function namesMedia(path: string): boolean {
+	return ['.png', '.jpg', '.jpeg', '.webp', '.pdf', '.ipynb'].includes(extname(path).toLowerCase())
+}
+
+function inputLimit(path: string, prefix: Buffer): number {
+	const kind = mediaKindOf(path, prefix)
+	return kind ? mediaLimit(kind) : TEXT_MAX_INPUT_BYTES
+}
+
+function mediaLimit(kind: MediaKind): number {
+	return kind === 'image' ? IMAGE_MAX_BYTES : kind === 'pdf' ? PDF_MAX_BYTES : NOTEBOOK_MAX_BYTES
+}
+
+function mediaFailure(path: string, bytes: number, message: string, sandboxed: boolean) {
+	return {
+		success: false as const,
+		output: message,
+		error: message,
+		data: { path, ...(sandboxed ? { sandboxed: true } : {}) },
+		facts: { kind: 'read' as const, path, bytes },
+	}
+}
+
+function tooLargeMedia(path: string, bytes: number, kind: MediaKind) {
+	const what = kind === 'image' ? 'Image' : kind === 'pdf' ? 'PDF' : 'Notebook'
+	return mediaFailure(
+		path,
+		bytes,
+		`${what} file (${humanBytes(bytes)}) exceeds the maximum size this tool can read (${humanBytes(mediaLimit(kind))}).`,
+		false,
+	)
+}
+
+/**
+ * An image, a PDF or a notebook, as what the model can use: the picture itself,
+ * the pages of the PDF as pictures, or the notebook's cells with their output.
+ * Undefined for any other file, which is read as text.
+ */
+async function readMediaFile(
+	buffer: Buffer,
+	path: string,
+	input: { readonly pages?: string | undefined },
+	context: ToolContext,
+	sandboxed: boolean,
+): Promise<ToolResult | undefined> {
+	const kind = mediaKindOf(path, buffer)
+	if (!kind) return undefined
+	if (buffer.length > mediaLimit(kind)) return tooLargeMedia(path, buffer.length, kind)
+	if (kind === 'image') {
+		try {
+			const result = await inspectImageBytes(
+				{ path, bytes: buffer, sandboxed },
+				context.abortSignal,
+			)
+			return {
+				...result,
+				facts: { kind: 'read' as const, path, bytes: buffer.length },
+			}
+		} catch (error) {
+			return mediaFailure(
+				path,
+				buffer.length,
+				error instanceof Error ? error.message : String(error),
+				sandboxed,
+			)
+		}
+	}
+	const media: MediaRead =
+		kind === 'pdf'
+			? await readPdfPages(buffer, input.pages, path, context.abortSignal)
+			: readNotebook(buffer, path)
+	if (!media.ok) return mediaFailure(path, buffer.length, media.message, sandboxed)
+	const text = media.parts
+		.filter((part) => part.type === 'text')
+		.map((part) => part.text)
+		.join('\n')
+	const hasImage = media.parts.some((part) => part.type === 'image')
+	return {
+		success: true as const,
+		output: text,
+		...(hasImage
+			? {
+					content: media.parts.map((part) =>
+						part.type === 'text'
+							? { type: 'text' as const, text: part.text }
+							: { type: 'image' as const, mediaType: part.mediaType, data: part.data },
+					),
+				}
+			: {}),
+		data: { path, ...(sandboxed ? { sandboxed: true } : {}), ...media.facts },
+		facts: { kind: 'read' as const, path, bytes: buffer.length },
+	}
+}
+
 function capOptions(
 	input: { path: string; allow_large?: boolean | undefined },
 	context: ToolContext,
@@ -315,35 +457,14 @@ function unchangedRead(
 	}
 }
 
-function describeStructuredBinaryRead(path: string, buffer: Buffer): string | null {
+function describeStructuredBinaryRead(path: string): string | null {
 	const ext = extname(path).toLowerCase()
-	const image = buffer.subarray(0, 8).equals(Buffer.from('89504e470d0a1a0a', 'hex'))
-		? 'PNG'
-		: buffer[0] === 0xff && buffer[1] === 0xd8
-			? 'JPEG'
-			: buffer.toString('ascii', 0, 4) === 'RIFF' && buffer.toString('ascii', 8, 12) === 'WEBP'
-				? 'WebP'
-				: null
-	if (image) {
-		return [
-			`The file "${path}" is a ${image} raster image, not UTF-8 text.`,
-			'Use an available view_image tool with this path to inspect the actual pixels. Reading binary bytes as text does not provide visual evidence.',
-			'If image inspection is unavailable, open the file in an application and use an available screenshot tool; report the limitation if neither can show the image.',
-		].join('\n')
-	}
 	if (ext === '.docx') return buildStructuredBinaryGuidance(path, 'DOCX', 'python-docx')
 	if (ext === '.pptx') return buildStructuredBinaryGuidance(path, 'PPTX', 'python-pptx')
 	if (ext === '.xlsx') return buildStructuredBinaryGuidance(path, 'XLSX', 'openpyxl')
-	if (ext === '.pdf' || startsWithPdfHeader(buffer)) {
-		return buildStructuredBinaryGuidance(path, 'PDF', 'pdftotext or PyMuPDF')
-	}
 	return null
 }
 
-function startsWithPdfHeader(buffer: Buffer): boolean {
-	return buffer.length >= 4 && buffer.subarray(0, 4).toString('utf8') === '%PDF'
-}
-
 function buildStructuredBinaryGuidance(path: string, format: string, extractor: string): string {
 	return [
 		`The file "${path}" is a ${format} document package, not UTF-8 text.`,