@namzu/sdk 2.0.0 → 3.0.0

package/src/tools/builtins/__tests__/edit.test.ts

@@ -1,11 +1,8 @@
-import { existsSync, mkdtempSync, readFileSync, readdirSync, writeFileSync } from 'node:fs'
+import { mkdtempSync, readFileSync, writeFileSync } from 'node:fs'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
 import { describe, expect, it } from 'vitest'
-import { ToolRegistry } from '../../../registry/tool/execute.js'
-import type { Sandbox } from '../../../types/sandbox/index.js'
 import type { ToolContext } from '../../../types/tool/index.js'
-import { atomicWriteFile } from '../atomic-write-file.js'
 import { EditTool } from '../edit.js'
 
 function makeContext(workingDirectory: string): ToolContext {
@@ -19,75 +16,12 @@ function makeContext(workingDirectory: string): ToolContext {
 }
 
 describe('EditTool', () => {
-	it('publishes one closed canonical replacement contract', () => {
-		const schema = EditTool.modelInputSchema
-		expect(schema).toEqual({
-			type: 'object',
-			properties: {
-				path: {
-					type: 'string',
-					description: 'Path to the file to edit. Must not be empty.',
-				},
-				old_string: {
-					type: 'string',
-					description:
-						'Exact unique text from the file, without read-tool line-number prefixes. Must not be empty.',
-				},
-				new_string: {
-					type: 'string',
-					description:
-						'Exact replacement text. May be empty to delete old_string. Keep under 12000 characters.',
-				},
-				replace_all: {
-					type: 'boolean',
-					description: 'Replace every occurrence instead of requiring one unique match.',
-				},
-			},
-			required: ['path', 'old_string', 'new_string'],
-			additionalProperties: false,
-		})
-
-		expect(
-			EditTool.inputSchema.safeParse({
-				path: 'doc.md',
-				old_string: 'old',
-				new_string: 'new',
-				replace_all: true,
-			}).success,
-		).toBe(true)
-
-		for (const legacy of [
-			{ path: 'doc.md', oldStr: 'old', newStr: 'new' },
-			{ path: 'doc.md', insertLine: 'end', new_string: 'append' },
-			{
-				path: 'doc.md',
-				old_string: 'old',
-				new_string: 'new',
-				newStr: 'legacy',
-			},
-		]) {
-			expect(EditTool.inputSchema.safeParse(legacy).success, JSON.stringify(legacy)).toBe(false)
-		}
-		expect(
-			EditTool.inputSchema.safeParse({
-				path: '   ',
-				old_string: 'old',
-				new_string: 'new',
-			}).success,
-		).toBe(false)
-	})
-
-	it('replaces one exact unique string', async () => {
+	it('accepts oldStr/newStr aliases for string replacement', async () => {
 		const dir = mkdtempSync(join(tmpdir(), 'namzu-edit-'))
 		writeFileSync(join(dir, 'doc.md'), 'alpha\nbeta\n')
 
 		const result = await EditTool.execute(
-			{
-				path: 'doc.md',
-				old_string: 'beta',
-				new_string: 'gamma',
-				replace_all: false,
-			},
+			{ path: 'doc.md', oldStr: 'beta', newStr: 'gamma', replace_all: false },
 			makeContext(dir),
 		)
 
@@ -95,223 +29,29 @@ describe('EditTool', () => {
 		expect(readFileSync(join(dir, 'doc.md'), 'utf-8')).toBe('alpha\ngamma\n')
 	})
 
-	it('validates a path without rewriting edge whitespace', async () => {
+	it('inserts content after a 1-indexed line number', async () => {
 		const dir = mkdtempSync(join(tmpdir(), 'namzu-edit-'))
-		writeFileSync(join(dir, ' doc.md '), 'alpha\n')
+		writeFileSync(join(dir, 'doc.md'), 'alpha\nbeta\n')
 
 		const result = await EditTool.execute(
-			{
-				path: ' doc.md ',
-				old_string: 'alpha',
-				new_string: 'beta',
-				replace_all: false,
-			},
+			{ path: 'doc.md', insertLine: 1, newStr: 'inserted', replace_all: false },
 			makeContext(dir),
 		)
 
 		expect(result.success).toBe(true)
-		expect(readFileSync(join(dir, ' doc.md '), 'utf-8')).toBe('beta\n')
-		expect(existsSync(join(dir, 'doc.md'))).toBe(false)
+		expect(readFileSync(join(dir, 'doc.md'), 'utf-8')).toBe('alpha\ninserted\nbeta\n')
 	})
 
-	it('allows deletion with an empty new_string', async () => {
+	it('inserts content at the end with insertLine=end', async () => {
 		const dir = mkdtempSync(join(tmpdir(), 'namzu-edit-'))
-		writeFileSync(join(dir, 'doc.md'), 'alpha\nremove me\nomega\n')
+		writeFileSync(join(dir, 'doc.md'), 'alpha\n')
 
 		const result = await EditTool.execute(
-			{
-				path: 'doc.md',
-				old_string: 'remove me\n',
-				new_string: '',
-				replace_all: false,
-			},
+			{ path: 'doc.md', insertLine: 'end', newStr: 'omega', replace_all: false },
 			makeContext(dir),
 		)
 
 		expect(result.success).toBe(true)
 		expect(readFileSync(join(dir, 'doc.md'), 'utf-8')).toBe('alpha\nomega\n')
 	})
-
-	it('replaces every exact occurrence only when replace_all is true', async () => {
-		const dir = mkdtempSync(join(tmpdir(), 'namzu-edit-'))
-		writeFileSync(join(dir, 'doc.md'), 'alpha alpha alpha')
-
-		const result = await EditTool.execute(
-			{
-				path: 'doc.md',
-				old_string: 'alpha',
-				new_string: 'beta',
-				replace_all: true,
-			},
-			makeContext(dir),
-		)
-
-		expect(result.success).toBe(true)
-		expect(result.data).toMatchObject({ replacements: 3 })
-		expect(readFileSync(join(dir, 'doc.md'), 'utf-8')).toBe('beta beta beta')
-	})
-
-	it('refuses ambiguous exact matches instead of guessing', async () => {
-		const dir = mkdtempSync(join(tmpdir(), 'namzu-edit-'))
-		writeFileSync(join(dir, 'doc.md'), 'alpha\nalpha\n')
-
-		const result = await EditTool.execute(
-			{
-				path: 'doc.md',
-				old_string: 'alpha',
-				new_string: 'beta',
-				replace_all: false,
-			},
-			makeContext(dir),
-		)
-
-		expect(result.success).toBe(false)
-		expect(result.error).toContain('old_string is not unique')
-		expect(readFileSync(join(dir, 'doc.md'), 'utf-8')).toBe('alpha\nalpha\n')
-	})
-
-	it('normalizes consistent CRLF/LF boundaries without fuzzy matching', async () => {
-		const dir = mkdtempSync(join(tmpdir(), 'namzu-edit-'))
-		writeFileSync(join(dir, 'doc.md'), 'alpha\r\nbeta\r\nomega\r\n')
-
-		const result = await EditTool.execute(
-			{
-				path: 'doc.md',
-				old_string: 'alpha\nbeta',
-				new_string: 'gamma\ndelta',
-				replace_all: false,
-			},
-			makeContext(dir),
-		)
-
-		expect(result.success).toBe(true)
-		expect(readFileSync(join(dir, 'doc.md'), 'utf-8')).toBe('gamma\r\ndelta\r\nomega\r\n')
-	})
-
-	it('rejects legacy and extra fields even when execute is called directly', async () => {
-		const dir = mkdtempSync(join(tmpdir(), 'namzu-edit-'))
-		writeFileSync(join(dir, 'doc.md'), 'alpha\n')
-
-		for (const input of [
-			{ path: 'doc.md', oldStr: 'alpha', newStr: 'beta' },
-			{
-				path: 'doc.md',
-				old_string: 'alpha',
-				new_string: 'beta',
-				insertLine: 'end',
-			},
-		]) {
-			const result = await EditTool.execute(input as never, makeContext(dir))
-			expect(result.success, JSON.stringify(input)).toBe(false)
-			expect(result.error).toContain('Invalid edit input')
-		}
-
-		expect(readFileSync(join(dir, 'doc.md'), 'utf-8')).toBe('alpha\n')
-	})
-
-	it('returns one canonical recovery shape after registry validation fails', async () => {
-		const registry = new ToolRegistry()
-		registry.register(EditTool)
-
-		const result = await registry.execute(
-			'edit',
-			{ insertLine: '"end"', newStr: 'content' },
-			makeContext('/tmp'),
-		)
-
-		expect(result.success).toBe(false)
-		expect(result.error).toContain('Validation failed for "edit":')
-		expect(result.error).toContain('Required: path: string')
-		expect(result.error).toContain(
-			'{"path":"file.md","old_string":"exact unique text","new_string":"replacement text"}',
-		)
-		expect(result.error).not.toContain('Accepted shapes')
-	})
-
-	it('serializes independent EditTool read-modify-write cycles for one sandbox path', async () => {
-		let body = Buffer.from('alpha')
-		let reads = 0
-		let writes = 0
-		let releaseFirstWrite = () => {}
-		let markFirstWriteStarted = () => {}
-		const firstWriteStarted = new Promise<void>((resolve) => {
-			markFirstWriteStarted = resolve
-		})
-		const firstWriteGate = new Promise<void>((resolve) => {
-			releaseFirstWrite = resolve
-		})
-		const sandbox = {
-			id: 'sbx_edit_lock',
-			status: 'ready',
-			rootDir: '/workspace',
-			environment: 'basic',
-			async readFile() {
-				reads += 1
-				return Buffer.from(body)
-			},
-			async writeFile(_path: string, content: string | Buffer) {
-				writes += 1
-				if (writes === 1) {
-					markFirstWriteStarted()
-					await firstWriteGate
-				}
-				body = Buffer.isBuffer(content) ? Buffer.from(content) : Buffer.from(content)
-			},
-			async exec() {
-				throw new Error('not used')
-			},
-			async listFiles() {
-				return []
-			},
-			async destroy() {},
-		} as Sandbox
-		const firstContext = { ...makeContext('/workspace'), sandbox }
-		const secondContext = { ...makeContext('/workspace'), sandbox }
-
-		const first = EditTool.execute(
-			{
-				path: 'doc.md',
-				old_string: 'alpha',
-				new_string: 'beta',
-				replace_all: false,
-			},
-			firstContext,
-		)
-		await firstWriteStarted
-		const second = EditTool.execute(
-			{
-				path: 'doc.md',
-				old_string: 'beta',
-				new_string: 'gamma',
-				replace_all: false,
-			},
-			secondContext,
-		)
-		await Promise.resolve()
-		expect(reads).toBe(1)
-
-		releaseFirstWrite()
-		const results = await Promise.all([first, second])
-		expect(results.every((result) => result.success)).toBe(true)
-		expect(reads).toBe(2)
-		expect(writes).toBe(2)
-		expect(body.toString('utf-8')).toBe('gamma')
-	})
-
-	it('leaves the original intact when an atomic local write fails before commit', async () => {
-		const dir = mkdtempSync(join(tmpdir(), 'namzu-atomic-write-'))
-		const filePath = join(dir, 'doc.md')
-		writeFileSync(filePath, 'original')
-
-		await expect(
-			atomicWriteFile(filePath, 'replacement', {
-				beforeCommit: async () => {
-					throw new Error('injected pre-commit failure')
-				},
-			}),
-		).rejects.toThrow('injected pre-commit failure')
-
-		expect(readFileSync(filePath, 'utf-8')).toBe('original')
-		expect(readdirSync(dir).filter((entry) => entry.includes('.namzu-'))).toEqual([])
-	})
 })

package/src/tools/builtins/__tests__/payload-budget.test.ts

@@ -17,8 +17,8 @@ describe('filesystem tool payload budgeting', () => {
 		expect(() =>
 			EditTool.inputSchema.parse({
 				path: 'outputs/long.md',
-				old_string: '{{SECTION}}',
-				new_string: oversized,
+				oldStr: '{{SECTION}}',
+				newStr: oversized,
 				replace_all: false,
 			}),
 		).not.toThrow()
@@ -31,7 +31,7 @@ describe('filesystem tool payload budgeting', () => {
 		expect(names).not.toContain('append')
 	})
 
-	it('assembles replay-safe long documents by advancing an exact marker', async () => {
+	it('assembles long documents with bounded write plus edit insert chunks', async () => {
 		const dir = mkdtempSync(join(tmpdir(), 'namzu-long-doc-'))
 		const ctx: ToolContext = {
 			runId: 'run_test' as ToolContext['runId'],
@@ -40,12 +40,12 @@ describe('filesystem tool payload budgeting', () => {
 			env: {},
 			log: () => {},
 		}
-		const opening = '# Long document regression\n\n{{CHUNK_001}}\n'
+		const opening = '# Long document regression\n\n{{BODY}}\n'
 		const chunks = Array.from({ length: 6 }, (_, sectionIndex) => {
 			const lines = Array.from({ length: 45 }, (_, lineIndex) => {
 				const section = sectionIndex + 1
 				const line = lineIndex + 1
-				return `Section ${section}.${line}: this bounded paragraph proves long-form output grows through exact marker edits rather than one oversized JSON tool argument.`
+				return `Section ${section}.${line}: this bounded paragraph proves long-form output grows through edit insertions rather than one oversized JSON tool argument.`
 			})
 			const chunk = [`## Section ${sectionIndex + 1}`, ...lines, ''].join('\n')
 			expect(chunk.length).toBeLessThan(12_000)
@@ -58,52 +58,32 @@ describe('filesystem tool payload budgeting', () => {
 		)
 		expect(writeResult.success).toBe(true)
 
-		for (const [index, chunk] of chunks.entries()) {
-			const currentMarker = `{{CHUNK_${String(index + 1).padStart(3, '0')}}}`
-			const nextMarker = `{{CHUNK_${String(index + 2).padStart(3, '0')}}}`
+		const firstEdit = await EditTool.execute(
+			{
+				path: 'outputs/regression-long-document.md',
+				oldStr: '{{BODY}}',
+				newStr: chunks[0],
+				replace_all: false,
+			},
+			ctx,
+		)
+		expect(firstEdit.success).toBe(true)
+
+		for (const chunk of chunks.slice(1)) {
 			const result = await EditTool.execute(
 				{
 					path: 'outputs/regression-long-document.md',
-					old_string: currentMarker,
-					new_string: `${chunk}\n${nextMarker}`,
+					insertLine: 'end',
+					newStr: chunk,
 					replace_all: false,
 				},
 				ctx,
 			)
 			expect(result.success).toBe(true)
-
-			if (index === 0) {
-				const beforeReplay = readFileSync(join(dir, 'outputs/regression-long-document.md'), 'utf-8')
-				const replay = await EditTool.execute(
-					{
-						path: 'outputs/regression-long-document.md',
-						old_string: currentMarker,
-						new_string: `${chunk}\n${nextMarker}`,
-						replace_all: false,
-					},
-					ctx,
-				)
-				expect(replay.success).toBe(false)
-				expect(readFileSync(join(dir, 'outputs/regression-long-document.md'), 'utf-8')).toBe(
-					beforeReplay,
-				)
-			}
 		}
 
-		const finalMarker = `{{CHUNK_${String(chunks.length + 1).padStart(3, '0')}}}`
-		const finalize = await EditTool.execute(
-			{
-				path: 'outputs/regression-long-document.md',
-				old_string: finalMarker,
-				new_string: '',
-				replace_all: false,
-			},
-			ctx,
-		)
-		expect(finalize.success).toBe(true)
-
 		const final = readFileSync(join(dir, 'outputs/regression-long-document.md'), 'utf-8')
-		expect(final).not.toContain('{{CHUNK_')
+		expect(final).not.toContain('{{BODY}}')
 		expect(final.split('\n').length).toBeGreaterThan(250)
 		expect(final).toContain('## Section 1')
 		expect(final).toContain('## Section 6')

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

@@ -26,7 +26,35 @@ describe('ReadFileTool', () => {
 		)
 
 		expect(result.success).toBe(true)
-		expect(result.output).toBe('2\ttwo\n3\tthree')
+		expect(result.output).toContain('2\ttwo\n3\tthree')
+		// A window over a longer file now says so: the model must be able to
+		// tell "these are all the lines" from "these are the lines I asked
+		// for", or it reasons about a fragment as if it were the file.
+		expect(result.output).toContain('PARTIAL view — lines 2-3 of 4')
+		expect(result.data).toMatchObject({ truncated: true, returnedLines: 2, totalLines: 4 })
+	})
+
+	it('adds no partial-view notice when the whole file was returned', async () => {
+		const dir = mkdtempSync(join(tmpdir(), 'namzu-read-'))
+		writeFileSync(join(dir, 'doc.md'), ['one', 'two'].join('\n'))
+
+		const result = await ReadFileTool.execute({ path: 'doc.md' }, makeContext(dir))
+
+		expect(result.output).toBe('1\tone\n2\ttwo')
+		expect(result.data).toMatchObject({ truncated: false })
+	})
+
+	it('defaults to a bounded window instead of returning an entire large file', async () => {
+		const dir = mkdtempSync(join(tmpdir(), 'namzu-read-'))
+		const lines = Array.from({ length: 5000 }, (_, i) => `line ${i + 1}`)
+		writeFileSync(join(dir, 'big.txt'), lines.join('\n'))
+
+		const result = await ReadFileTool.execute({ path: 'big.txt' }, makeContext(dir))
+
+		expect(result.data).toMatchObject({ returnedLines: 2000, totalLines: 5000, truncated: true })
+		expect(result.output).toContain('PARTIAL view — lines 1-2000 of 5000')
+		// The notice names the exact next call rather than describing it.
+		expect(result.output).toContain('offset: 2000')
 	})
 
 	it('guides binary Office documents through extractor tooling', async () => {

package/src/tools/builtins/__tests__/write-file.test.ts

@@ -8,10 +8,10 @@ import { WriteFileTool } from '../write-file.js'
 function makeTracker(): FileReadTracker & { keys(): string[] } {
 	const set = new Set<string>()
 	return {
-		recordRead: (key) => {
-			set.add(key)
+		recordRead: (k) => {
+			set.add(k)
 		},
-		hasRead: (key) => set.has(key),
+		hasRead: (k) => set.has(k),
 		keys: () => Array.from(set),
 	}
 }
@@ -27,33 +27,7 @@ function makeContext(workingDirectory: string, tracker?: FileReadTracker): ToolC
 	}
 }
 
-describe('WriteFileTool — canonical contract and read-before-overwrite invariant', () => {
-	it('publishes one closed path + content contract', () => {
-		expect(WriteFileTool.modelInputSchema).toEqual({
-			type: 'object',
-			properties: {
-				path: {
-					type: 'string',
-					description: 'Non-empty path to the file to write.',
-				},
-				content: {
-					type: 'string',
-					description:
-						'Complete bounded file body. May be empty only for an intentionally empty file.',
-				},
-			},
-			required: ['path', 'content'],
-			additionalProperties: false,
-		})
-		expect(WriteFileTool.inputSchema.safeParse({ path: 'doc.md', content: '' }).success).toBe(true)
-		expect(WriteFileTool.inputSchema.safeParse({ path: 'doc.md', newStr: 'legacy' }).success).toBe(
-			false,
-		)
-		expect(WriteFileTool.inputSchema.safeParse({ path: '   ', content: 'body' }).success).toBe(
-			false,
-		)
-	})
-
+describe('WriteFileTool — read-before-overwrite invariant', () => {
 	it('writes a new file without requiring a prior read', async () => {
 		const dir = mkdtempSync(join(tmpdir(), 'namzu-write-'))
 		const tracker = makeTracker()
@@ -66,28 +40,15 @@ describe('WriteFileTool — canonical contract and read-before-overwrite invaria
 		expect(tracker.hasRead(join(dir, 'fresh.txt'))).toBe(true)
 	})
 
-	it('preserves edge whitespace in a valid path', async () => {
+	it('accepts newStr as the canonical create/write content alias', async () => {
 		const dir = mkdtempSync(join(tmpdir(), 'namzu-write-'))
+		const tracker = makeTracker()
+		const ctx = makeContext(dir, tracker)
 
-		const result = await WriteFileTool.execute(
-			{ path: ' fresh.txt ', content: 'hello' },
-			makeContext(dir),
-		)
+		const result = await WriteFileTool.execute({ path: 'fresh.txt', newStr: 'hello' }, ctx)
 
 		expect(result.success).toBe(true)
-		expect(readFileSync(join(dir, ' fresh.txt '), 'utf-8')).toBe('hello')
-	})
-
-	it('rejects legacy content aliases even when execute is called directly', async () => {
-		const dir = mkdtempSync(join(tmpdir(), 'namzu-write-'))
-
-		const result = await WriteFileTool.execute(
-			{ path: 'fresh.txt', newStr: 'legacy' } as never,
-			makeContext(dir),
-		)
-
-		expect(result.success).toBe(false)
-		expect(result.error).toContain('Invalid write input')
+		expect(readFileSync(join(dir, 'fresh.txt'), 'utf-8')).toBe('hello')
 	})
 
 	it('refuses to overwrite an existing file the agent has not read', async () => {
@@ -123,14 +84,14 @@ describe('WriteFileTool — canonical contract and read-before-overwrite invaria
 		expect(readFileSync(filePath, 'utf-8')).toBe('replaced')
 	})
 
-	it('preserves existing hosts without a file read tracker', async () => {
+	it('falls back to legacy behaviour when no fileReadTracker is provided (back-compat)', async () => {
 		const dir = mkdtempSync(join(tmpdir(), 'namzu-write-'))
-		writeFileSync(join(dir, 'existing.txt'), 'before')
+		writeFileSync(join(dir, 'legacy.txt'), 'before')
 		const ctx = makeContext(dir)
 
-		const result = await WriteFileTool.execute({ path: 'existing.txt', content: 'after' }, ctx)
+		const result = await WriteFileTool.execute({ path: 'legacy.txt', content: 'after' }, ctx)
 
 		expect(result.success).toBe(true)
-		expect(readFileSync(join(dir, 'existing.txt'), 'utf-8')).toBe('after')
+		expect(readFileSync(join(dir, 'legacy.txt'), 'utf-8')).toBe('after')
 	})
 })

package/src/tools/builtins/bash.ts

@@ -11,7 +11,12 @@ const execAsync = promisify(exec)
 // but Namzu shouldn't read a consumer's env name. Consumers can
 // still alias their own var to `NAMZU_BASH_TIMEOUT_MS` at deploy
 // time if they want a unified knob.
-const DEFAULT_BASH_TIMEOUT_MS = readPositiveIntEnv('NAMZU_BASH_TIMEOUT_MS', 60 * 60 * 1000)
+// Two minutes, not an hour. The old default meant a wedged command held
+// the turn — and, before per-tool deadlines existed, the whole run — for
+// up to 3600s while ignoring Stop entirely. The model can still ask for
+// longer via the tool's own `timeout` argument when it knows a build is
+// slow; the point is that the DEFAULT is survivable.
+const DEFAULT_BASH_TIMEOUT_MS = readPositiveIntEnv('NAMZU_BASH_TIMEOUT_MS', 2 * 60 * 1000)
 const DEFAULT_BASH_MAX_BUFFER_BYTES = readPositiveIntEnv(
 	'NAMZU_BASH_MAX_BUFFER_BYTES',
 	100 * 1024 * 1024,
@@ -22,7 +27,7 @@ const inputSchema = z.object({
 		.string()
 		.min(1)
 		.describe(
-			'The bash command to execute. Required, non-empty. Single command per call (use `&&` / `;` chaining for compound commands). Avoid heredocs that span more than a few hundred bytes — create large content with bounded write plus exact marker-advancing edit calls instead.',
+			'The bash command to execute. Required, non-empty. Single command per call (use `&&` / `;` chaining for compound commands). Avoid heredocs that span more than a few hundred bytes — large content should be created with `write`, then extended with `edit` insertLine: "end", not piped into bash.',
 		),
 	timeout: z
 		.preprocess(
@@ -41,7 +46,7 @@ function isDangerousCommand(command: string): boolean {
 export const BashTool = defineTool({
 	name: 'bash',
 	description:
-		'Executes a bash command and returns stdout/stderr output. Command timeout is configurable. The `command` parameter is required — never call this tool with empty arguments. For very long content, prefer a bounded write with a deterministic marker followed by exact marker-advancing edit calls over a heredoc.',
+		'Executes a bash command and returns stdout/stderr output. Command timeout is configurable. The `command` parameter is required — never call this tool with empty arguments. For very long content (e.g. building a large file), prefer `write` for the opening and `edit` with insertLine: "end" for follow-up chunks over a heredoc to avoid hitting the output token limit mid-stream.',
 	inputSchema,
 	category: 'shell',
 	permissions: ['shell_execute'],
@@ -79,6 +84,9 @@ export const BashTool = defineTool({
 			const result = await context.sandbox.exec('/bin/sh', ['-c', input.command], {
 				timeout: input.timeout,
 				env: context.env,
+				// Same reason as the host path below: a Stop must reach the
+				// process, not just the promise waiting on it.
+				signal: context.abortSignal,
 			})
 
 			if (result.timedOut) {
@@ -89,9 +97,21 @@ export const BashTool = defineTool({
 				}
 			}
 
+			// The sandbox reports when IT clipped a stream. Dropping those
+			// flags meant the model saw a complete-looking result that had
+			// silently lost its tail — and the kernel's own convention is
+			// that it does not truncate silently.
+			const clipped = [
+				result.stdoutTruncated ? 'stdout' : '',
+				result.stderrTruncated ? 'stderr' : '',
+			].filter(Boolean)
+
 			const output = [
 				result.stdout ? `STDOUT:\n${result.stdout}` : '',
 				result.stderr ? `STDERR:\n${result.stderr}` : '',
+				clipped.length > 0
+					? `[${clipped.join(' and ')} was truncated by the sandbox output cap — re-run with a filter (grep/head/tail) to see the rest]`
+					: '',
 			]
 				.filter(Boolean)
 				.join('\n\n')
@@ -99,16 +119,26 @@ export const BashTool = defineTool({
 			return {
 				success: result.exitCode === 0,
 				output: output || '(no output)',
-				data: { exitCode: result.exitCode, sandboxed: true },
+				data: {
+					exitCode: result.exitCode,
+					sandboxed: true,
+					stdoutTruncated: result.stdoutTruncated ?? false,
+					stderrTruncated: result.stderrTruncated ?? false,
+				},
 				error: result.exitCode !== 0 ? `Command exited with code ${result.exitCode}` : undefined,
 			}
 		}
 
+		// Thread the run/deadline signal into the child process. Without it
+		// a Stop tore down the model stream and left the command running,
+		// and the executor's deadline could only ever DETACH from the tool
+		// rather than end the work it started.
 		const { stdout, stderr } = await execAsync(input.command, {
 			cwd: context.workingDirectory,
 			timeout: input.timeout,
 			env: { ...process.env, ...context.env },
 			maxBuffer: DEFAULT_BASH_MAX_BUFFER_BYTES,
+			signal: context.abortSignal,
 		})
 
 		const output = [stdout ? `STDOUT:\n${stdout}` : '', stderr ? `STDERR:\n${stderr}` : '']

package/src/tools/builtins/computer-use.ts

@@ -101,9 +101,15 @@ function resultToToolResult(result: ComputerUseResult): ToolResult {
 	switch (result.type) {
 		case 'screenshot': {
 			const { data, mimeType, width, height } = result.result
+			// `output` used to BE the base64 payload, which meant the model
+			// received 400 KB–2.7 MB of undecodable characters as text —
+			// roughly 100k–670k tokens — and could not see the screen at
+			// all. The image now travels as a content block; `output` keeps
+			// the short human/transcript-facing description.
 			return {
 				success: true,
-				output: data.toString('base64'),
+				output: `Screenshot captured (${width}x${height}, ${mimeType}).`,
+				content: [{ type: 'image', data: data.toString('base64'), mediaType: mimeType }],
 				data: { mimeType, width, height, encoding: 'base64' },
 			}
 		}