@namzu/sdk 32.0.0 → 33.1.0

package/src/tools/builtins/skill.ts

@@ -1,3 +1,4 @@
+import { createHash } from 'node:crypto'
 import { z } from 'zod'
 
 import { isInvocableBy, skillInvocation } from '../../types/skills/index.js'
@@ -23,11 +24,213 @@ const inputSchema = z.object({
 	name: z
 		.string()
 		.min(1)
-		.describe('The skill to load, exactly as listed in the available-skills manifest.'),
+		.optional()
+		.describe(
+			'The skill to load, exactly as listed in the available-skills manifest. Omit it to list model-invocable skills.',
+		),
+	cursor: z
+		.string()
+		.max(160)
+		.optional()
+		.describe('Opaque continuation cursor returned by an earlier call in the same mode.'),
 })
 
 type SkillInput = z.infer<typeof inputSchema>
 
+const CURSOR_PATTERN = /^v1\.([1-9][0-9]*)\.([A-Za-z0-9_-]{43})$/
+const LIST_CURSOR_PATTERN = /^v1\.list\.(0|[1-9][0-9]*)\.([01])\.([A-Za-z0-9_-]{43})$/
+const MAX_SKILLS_PER_PAGE = 20
+const OVERSIZED_CATALOG_WARNING =
+	'Some skills were omitted because their metadata is too large for this response budget.'
+
+interface SkillSnapshot {
+	readonly name: string
+	readonly body: string
+	readonly allowedTools: readonly string[] | undefined
+	readonly invocation: ReturnType<typeof skillInvocation>
+}
+
+interface SkillPage {
+	readonly output: string
+	readonly nextCursor?: string
+}
+
+interface ListedSkill {
+	readonly name: string
+	readonly description: string
+	readonly location: string
+	readonly allowedTools?: string
+}
+
+interface SkillListPage {
+	readonly skills: readonly ListedSkill[]
+	readonly warnings: readonly string[]
+	readonly nextCursor: string | null
+}
+
+function snapshotDigest(snapshot: SkillSnapshot): string {
+	return createHash('sha256')
+		.update(
+			JSON.stringify({
+				version: 1,
+				name: snapshot.name,
+				body: snapshot.body,
+				allowedTools: snapshot.allowedTools ?? null,
+				invocation: snapshot.invocation,
+			}),
+		)
+		.digest('base64url')
+}
+
+function cursorFor(offset: number, digest: string): string {
+	return `v1.${offset}.${digest}`
+}
+
+function parseCursor(cursor: string): { offset: number; digest: string } | undefined {
+	const match = CURSOR_PATTERN.exec(cursor)
+	if (!match) return undefined
+	const offset = Number(match[1])
+	if (!Number.isSafeInteger(offset)) return undefined
+	return { offset, digest: match[2] ?? '' }
+}
+
+function listCursorFor(offset: number, warned: boolean, digest: string): string {
+	return `v1.list.${offset}.${warned ? 1 : 0}.${digest}`
+}
+
+function parseListCursor(
+	cursor: string,
+): { offset: number; warned: boolean; digest: string } | undefined {
+	const match = LIST_CURSOR_PATTERN.exec(cursor)
+	if (!match) return undefined
+	const offset = Number(match[1])
+	if (!Number.isSafeInteger(offset)) return undefined
+	return { offset, warned: match[2] === '1', digest: match[3] ?? '' }
+}
+
+function activeOutputCap(maxChars: number | undefined): number | undefined {
+	return maxChars !== undefined && maxChars > 0 ? maxChars : undefined
+}
+
+function listDigest(skills: readonly ListedSkill[], maxChars: number | undefined): string {
+	return createHash('sha256')
+		.update(JSON.stringify({ version: 1, kind: 'list', maxChars: maxChars ?? null, skills }))
+		.digest('base64url')
+}
+
+function serializeListPage(page: SkillListPage): string {
+	return JSON.stringify(page)
+}
+
+function fitsListBudget(page: SkillListPage, maxChars: number | undefined): boolean {
+	return maxChars === undefined || serializeListPage(page).length <= maxChars
+}
+
+function pageSkillCatalog(input: {
+	readonly skills: readonly ListedSkill[]
+	readonly digest: string
+	readonly start: number
+	readonly warningAlreadyShown: boolean
+	readonly maxChars: number | undefined
+}): SkillListPage | undefined {
+	const { skills, digest, start, warningAlreadyShown, maxChars } = input
+	const retained: Array<{ index: number; skill: ListedSkill }> = []
+	let omitted = false
+	let hasRetainedLater = false
+
+	// Work backwards so the final retained entry is tested without a cursor.
+	// A last entry that fits by itself must not be dropped merely because an
+	// earlier page will need a continuation token to reach it.
+	for (let index = skills.length - 1; index >= start; index -= 1) {
+		const skill = skills[index]
+		if (!skill) continue
+		const nextCursor = hasRetainedLater ? listCursorFor(index + 1, true, digest) : null
+		if (fitsListBudget({ skills: [skill], warnings: [], nextCursor }, maxChars)) {
+			retained.push({ index, skill })
+			hasRetainedLater = true
+		} else {
+			omitted = true
+		}
+	}
+	retained.reverse()
+
+	const warning = omitted && !warningAlreadyShown ? [OVERSIZED_CATALOG_WARNING] : []
+	let count = Math.min(MAX_SKILLS_PER_PAGE, retained.length)
+	while (count > 0) {
+		const selected = retained.slice(0, count)
+		const last = selected.at(-1)
+		const hasMore = count < retained.length
+		const page: SkillListPage = {
+			skills: selected.map((entry) => entry.skill),
+			warnings: warning,
+			nextCursor:
+				hasMore && last
+					? listCursorFor(last.index + 1, warningAlreadyShown || warning.length > 0, digest)
+					: null,
+		}
+		if (fitsListBudget(page, maxChars)) return page
+		count -= 1
+	}
+
+	if (warning.length > 0) {
+		const page: SkillListPage = {
+			skills: [],
+			warnings: warning,
+			nextCursor: retained.length > 0 ? listCursorFor(start, true, digest) : null,
+		}
+		if (fitsListBudget(page, maxChars)) return page
+	}
+
+	const empty: SkillListPage = { skills: [], warnings: [], nextCursor: null }
+	return retained.length === 0 && fitsListBudget(empty, maxChars) ? empty : undefined
+}
+
+function isCodePointBoundary(text: string, index: number): boolean {
+	if (index <= 0 || index >= text.length) return true
+	const before = text.charCodeAt(index - 1)
+	const after = text.charCodeAt(index)
+	return !(before >= 0xd800 && before <= 0xdbff && after >= 0xdc00 && after <= 0xdfff)
+}
+
+function boundaryAtOrBefore(text: string, index: number): number {
+	const bounded = Math.max(0, Math.min(text.length, index))
+	return isCodePointBoundary(text, bounded) ? bounded : bounded - 1
+}
+
+function continuationNotice(name: string, cursor: string): string {
+	return `\n\n[More skill instructions remain. Call skill again with name "${name}" and cursor "${cursor}" before acting.]`
+}
+
+function pageSkillBody(input: {
+	readonly snapshot: SkillSnapshot
+	readonly digest: string
+	readonly start: number
+	readonly notice: string
+	readonly maxChars: number | undefined
+}): SkillPage | undefined {
+	const { snapshot, digest, start, notice, maxChars } = input
+	const remaining = `${snapshot.body.slice(start)}${notice}`
+	if (maxChars === undefined || maxChars <= 0 || remaining.length <= maxChars) {
+		return { output: remaining }
+	}
+
+	// Estimate once, then remove exactly the overflow until the page fits.
+	// The cursor grows only at powers of ten, so this converges in a handful
+	// of steps without allocating an index for every character in a large file.
+	let end = boundaryAtOrBefore(snapshot.body, Math.min(snapshot.body.length - 1, start + maxChars))
+	while (end > start) {
+		const nextCursor = cursorFor(end, digest)
+		const output = `${snapshot.body.slice(start, end)}${continuationNotice(
+			snapshot.name,
+			nextCursor,
+		)}${notice}`
+		if (output.length <= maxChars) return { output, nextCursor }
+		end = boundaryAtOrBefore(snapshot.body, end - Math.max(1, output.length - maxChars))
+	}
+
+	return undefined
+}
+
 /**
  * `allowed-tools` as a list.
  *
@@ -54,7 +257,7 @@ export const SKILL_TOOL_NAME = 'skill'
 export const SkillTool = defineTool({
 	name: SKILL_TOOL_NAME,
 	description:
-		'Loads the full instructions for a skill listed in the available-skills manifest. Call this before doing work the skill describes; the manifest carries only names and descriptions.',
+		'Lists model-invocable skills when called without a name, or loads one skill by its exact listed name. Long lists and bodies return an opaque continuation cursor; keep calling in the same mode with that cursor until no continuation remains. The manifest carries only names and descriptions.',
 	inputSchema,
 	category: 'analysis',
 	permissions: [],
@@ -75,6 +278,75 @@ export const SkillTool = defineTool({
 			}
 		}
 
+		if (input.name === undefined) {
+			if (!context.skills.catalog) {
+				return {
+					success: false,
+					output: '',
+					error:
+						'This skills registry cannot enumerate model-safe metadata. Use a skill name from the available-skills manifest.',
+				}
+			}
+			const skills = (await context.skills.catalog())
+				.filter(
+					(entry) =>
+						entry.invocation === undefined ||
+						entry.invocation === 'model' ||
+						entry.invocation === 'both',
+				)
+				.map(
+					(entry): ListedSkill => ({
+						name: entry.registeredName,
+						description: entry.description,
+						location: entry.location,
+						...(entry.allowedTools === undefined ? {} : { allowedTools: entry.allowedTools }),
+					}),
+				)
+			const maxChars = activeOutputCap(context.maxToolOutputChars)
+			const digest = listDigest(skills, maxChars)
+			let start = 0
+			let warningAlreadyShown = false
+			if (input.cursor !== undefined) {
+				const parsed = parseListCursor(input.cursor)
+				if (!parsed || parsed.digest !== digest || parsed.offset >= skills.length) {
+					return {
+						success: false,
+						output: '',
+						error:
+							'The skill-list continuation cursor is stale or invalid. Call skill again without a cursor to read the current catalog.',
+					}
+				}
+				start = parsed.offset
+				warningAlreadyShown = parsed.warned
+			}
+
+			const page = pageSkillCatalog({
+				skills,
+				digest,
+				start,
+				warningAlreadyShown,
+				maxChars,
+			})
+			if (!page) {
+				return {
+					success: false,
+					output: '',
+					error:
+						'The model-visible tool-output budget is too small to list skill metadata safely. Increase maxToolOutputChars and retry.',
+				}
+			}
+
+			return {
+				success: true,
+				output: serializeListPage(page),
+				data: {
+					kind: 'list',
+					count: page.skills.length,
+					...(page.nextCursor === null ? {} : { nextCursor: page.nextCursor }),
+				},
+			}
+		}
+
 		// The registry answers with a load RESULT, not a skill — the shape
 		// mirrors the implementation rather than an adapter, so there is
 		// nothing between them to drift.
@@ -92,6 +364,7 @@ export const SkillTool = defineTool({
 		}
 
 		const skill = loaded.skill
+		const invocation = skillInvocation(skill)
 		if (!isInvocableBy(skill, 'model')) {
 			// Reachable even though the manifest omits it: the model can name
 			// anything, and a check that only filtered the listing would be a
@@ -105,6 +378,54 @@ export const SkillTool = defineTool({
 		}
 
 		const allowed = parseAllowedTools(skill.metadata.allowedTools)
+		const snapshot: SkillSnapshot = {
+			name: input.name,
+			body: skill.body ?? '(this skill has no body)',
+			allowedTools: allowed,
+			invocation,
+		}
+		const digest = snapshotDigest(snapshot)
+		let start = 0
+		if (input.cursor !== undefined) {
+			const parsed = parseCursor(input.cursor)
+			if (
+				!parsed ||
+				parsed.digest !== digest ||
+				parsed.offset >= snapshot.body.length ||
+				!isCodePointBoundary(snapshot.body, parsed.offset)
+			) {
+				return {
+					success: false,
+					output: '',
+					error: `The continuation cursor for "${input.name}" is stale or invalid. Call skill again without a cursor to read the current instructions.`,
+				}
+			}
+			start = parsed.offset
+		}
+
+		const notice =
+			allowed === undefined
+				? ''
+				: `\n\n[While following this skill, restrict yourself to: ${allowed.length > 0 ? allowed.join(', ') : '(no tools)'}. This takes effect from your next turn.]`
+		const page = pageSkillBody({
+			snapshot,
+			digest,
+			start,
+			notice,
+			maxChars: context.maxToolOutputChars,
+		})
+		if (!page) {
+			return {
+				success: false,
+				output: '',
+				error: `The model-visible tool-output budget is too small to read "${input.name}" safely. Increase maxToolOutputChars and retry.`,
+			}
+		}
+
+		// Cursor and policy validation must finish before this mutation. A
+		// continuation is bound to the body AND its effective authorization
+		// metadata, so an edit to allowed-tools or invocation cannot widen the
+		// next batch under an old cursor.
 		if (allowed !== undefined) {
 			// Adopted, not merely announced. The notice below tells the model
 			// what happened; this is what makes it true whether or not the
@@ -117,17 +438,14 @@ export const SkillTool = defineTool({
 			// advice.
 			context.adoptSkillScope?.({ skill: skill.metadata.name, allowedTools: allowed })
 		}
-		const notice =
-			allowed === undefined
-				? ''
-				: `\n\n[While following this skill, restrict yourself to: ${allowed.length > 0 ? allowed.join(', ') : '(no tools)'}. This takes effect from your next turn.]`
 
 		return {
 			success: true,
-			output: `${skill.body ?? '(this skill has no body)'}${notice}`,
+			output: page.output,
 			data: {
 				skill: skill.metadata.name,
 				...(allowed === undefined ? {} : { allowedTools: allowed }),
+				...(page.nextCursor === undefined ? {} : { nextCursor: page.nextCursor }),
 			},
 		}
 	},

package/src/tools/coordinator/agent.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod'
 
 import type { AgentRuntimeContext } from '../../types/agent/base.js'
-import type { TaskScheduler } from '../../types/agent/scheduler.js'
+import type { CreateTaskOptions, TaskHandle, TaskScheduler } from '../../types/agent/scheduler.js'
 import type { ToolDefinition } from '../../types/tool/index.js'
 import { defineTool } from '../defineTool.js'
 import { wrapUntrusted } from '../untrusted-envelope.js'
@@ -146,40 +146,42 @@ export function buildAgentTool(opts: AgentToolOptions): ToolDefinition {
 					error: `Unknown subagent_type "${agentId}" — choose one of: ${agentIds.join(', ')}`,
 				}
 			}
-			const handle = await gateway.createTask({
-				agentId,
-				prompt,
-				workingDirectory: cwd,
-				runtimeContext: opts.runtimeContext,
-				// Hang the child off the executing tool's span, so the
-				// delegation appears inside the turn that asked for it rather
-				// than as a disconnected root trace. `create_task` has done
-				// this all along; this tool — the kernel's other delegation
-				// surface, and the one it exports as the canonical shape —
-				// did not.
-				...(context.parentSpan ? { parentSpan: context.parentSpan } : {}),
-				// The parent's environment, which is the whole point of setting
-				// one: a delegate that cannot see it runs against different
-				// services than the run that launched it, silently.
-				// `ToolContext.env` is the parent's own resolved map, per run.
-				...(Object.keys(context.env ?? {}).length > 0
-					? { configOverrides: { env: context.env } }
-					: {}),
-			})
-
-			onTaskLaunched?.(handle.taskId, {
-				agentId,
-				description,
-				// Same canonical-envelope plumbing as coordinator/index.ts
-				// (ses_009-task-notification-envelope). For Agent-tool path
-				// the subagent run is awaited synchronously below, so this
-				// id is only used if a probe / hook unexpectedly forks the
-				// completion to the background notification channel.
-				originalToolUseId: context.toolUseId,
+			const { handle, completed } = await runBlockingAgentTask({
+				gateway,
+				signal: context.abortSignal,
+				create: {
+					agentId,
+					prompt,
+					workingDirectory: cwd,
+					runtimeContext: opts.runtimeContext,
+					// Hang the child off the executing tool's span, so the
+					// delegation appears inside the turn that asked for it rather
+					// than as a disconnected root trace. `create_task` has done
+					// this all along; this tool — the kernel's other delegation
+					// surface, and the one it exports as the canonical shape —
+					// did not.
+					...(context.parentSpan ? { parentSpan: context.parentSpan } : {}),
+					// The parent's environment, which is the whole point of setting
+					// one: a delegate that cannot see it runs against different
+					// services than the run that launched it, silently.
+					// `ToolContext.env` is the parent's own resolved map, per run.
+					...(Object.keys(context.env ?? {}).length > 0
+						? { configOverrides: { env: context.env } }
+						: {}),
+				},
+				onCreated: (handle) =>
+					onTaskLaunched?.(handle.taskId, {
+						agentId,
+						description,
+						// Same canonical-envelope plumbing as coordinator/index.ts
+						// (ses_009-task-notification-envelope). For Agent-tool path
+						// the subagent run is awaited synchronously below, so this
+						// id is only used if a probe / hook unexpectedly forks the
+						// completion to the background notification channel.
+						originalToolUseId: context.toolUseId,
+					}),
 			})
 
-			const completed = await gateway.waitForTask(handle.taskId)
-
 			// Both authorities must agree — see `taskSucceeded` for which two
 			// and why either alone is wrong. The reasoning used to live here
 			// alone, which is exactly how `create_task` came to ship without
@@ -253,3 +255,76 @@ export function buildAgentTool(opts: AgentToolOptions): ToolDefinition {
 		},
 	})
 }
+
+interface BlockingAgentTaskInput {
+	readonly gateway: TaskScheduler
+	readonly signal: AbortSignal
+	readonly create: CreateTaskOptions
+	readonly onCreated?: (handle: TaskHandle) => void
+}
+
+/**
+ * Own a blocking child from before creation until its terminal handle.
+ *
+ * The late-create branch is load-bearing. `createTask()` can be inside an
+ * asynchronous workspace/config build when its parent is cancelled. Racing
+ * that await lets the parent settle promptly, but the eventual handle still
+ * has to be cancelled or the task is born after its authority disappeared.
+ */
+async function runBlockingAgentTask(
+	input: BlockingAgentTaskInput,
+): Promise<{ handle: TaskHandle; completed: TaskHandle }> {
+	const { gateway, signal } = input
+	signal.throwIfAborted()
+
+	let handle: TaskHandle | undefined
+	let cancellationRequested = false
+	let taskCancellationAttempted = false
+	let rejectAbort: (reason: unknown) => void = () => {}
+	const aborted = new Promise<never>((_resolve, reject) => {
+		rejectAbort = reject
+	})
+	const cancel = (task: TaskHandle): void => {
+		if (taskCancellationAttempted) return
+		taskCancellationAttempted = true
+		try {
+			gateway.cancelTask(task.taskId, 'parent')
+		} catch {
+			// Parent cancellation is authoritative even when a host scheduler
+			// cannot honour cancellation for its delegate. Do not replace the
+			// parent's exact abort reason with a secondary capability error.
+		}
+	}
+	const onAbort = (): void => {
+		cancellationRequested = true
+		if (handle) cancel(handle)
+		rejectAbort(signal.reason)
+	}
+
+	signal.addEventListener('abort', onAbort, { once: true })
+	if (signal.aborted) onAbort()
+	const creation = gateway.createTask(input.create)
+	// The abort race can win first. Observe the losing creation promise and
+	// cancel its eventual task in `finally` rather than leaving a rejection or
+	// late child detached.
+	creation.catch(() => {})
+
+	try {
+		handle = await Promise.race([creation, aborted])
+		if (cancellationRequested || signal.aborted) {
+			cancel(handle)
+			signal.throwIfAborted()
+		}
+		input.onCreated?.(handle)
+		const completed = await Promise.race([gateway.waitForTask(handle.taskId), aborted])
+		return { handle, completed }
+	} catch (error) {
+		if (handle) cancel(handle)
+		throw error
+	} finally {
+		if (!handle && cancellationRequested) {
+			void creation.then(cancel, () => {})
+		}
+		signal.removeEventListener('abort', onAbort)
+	}
+}

package/src/types/agent/manager.ts

@@ -16,7 +16,7 @@ export interface AgentManagerContract {
 		listener?: RunEventListener,
 	): Promise<AgentTask>
 
-	cancel(taskId: TaskId): void
+	cancel(taskId: TaskId, cause?: CancelCause): void
 	/**
 	 * Defaults to `'parent'` when a caller names nothing, because this call
 	 * site IS a parent abandoning its children — unlike `AbstractAgent.cancel`,

package/src/types/agent/scheduler.ts

@@ -1,5 +1,6 @@
 import type { TaskId } from '../ids/index.js'
 import type { AgentPersona } from '../persona/index.js'
+import type { CancelCause } from '../run/cancel-cause.js'
 import type { AgentRuntimeContext, BaseAgentConfig, BaseAgentResult } from './base.js'
 import type { AgentTaskState } from './task.js'
 
@@ -93,7 +94,15 @@ export interface TaskScheduler {
 
 	continueTask(taskId: TaskId, message: string): Promise<void>
 
-	cancelTask(taskId: TaskId): void
+	/**
+	 * Stop one task. A cause is relative to the child: a blocking delegation
+	 * abandoned by the run that launched it is cancelled by its `parent`.
+	 *
+	 * Optional so existing host schedulers remain structurally compatible. A
+	 * scheduler that can preserve the cause should carry it to the task's abort
+	 * signal; built-in local and foreign-delegate schedulers do.
+	 */
+	cancelTask(taskId: TaskId, cause?: CancelCause): void
 
 	/**
 	 * The task's current state, or `undefined` if this gateway does not know

package/src/types/bidi/index.ts

@@ -44,6 +44,7 @@ export type BidiEvent =
 	| { readonly type: 'audio'; readonly data: string; readonly mediaType: string }
 	| {
 			readonly type: 'tool_call'
+			/** Unique for the complete session; a duplicate is a protocol failure. */
 			readonly id: string
 			readonly name: string
 			/** JSON, as the model produced it. */
@@ -51,7 +52,11 @@ export type BidiEvent =
 	  }
 	/** The model finished a stretch of output and is waiting. */
 	| { readonly type: 'turn_complete' }
-	/** The human spoke over the model; anything in flight is now stale. */
+	/**
+	 * The human spoke over the model; work that has not started publishing a
+	 * result is now stale. This is not run cancellation: tool code keeps its
+	 * live signal so an irreversible side effect is not stopped halfway.
+	 */
 	| { readonly type: 'interrupted' }
 	| { readonly type: 'error'; readonly message: string }
 	| { readonly type: 'closed'; readonly reason?: string }
@@ -60,6 +65,10 @@ export interface BidiConnectParams {
 	readonly model: string
 	readonly system?: string
 	readonly tools?: readonly LLMToolSchema[]
+	/**
+	 * Lifetime of the host-owned run. A provider uses it for connection and
+	 * ongoing transport work; the host also invokes `close()` when it aborts.
+	 */
 	readonly signal?: AbortSignal
 }
 
@@ -72,9 +81,14 @@ export interface BidiSession {
 	 * Separate from {@link send} because it is not input from the human:
 	 * a driver has to attach it to the call it answers, and a session that
 	 * received it as ordinary input would have to guess.
+	 *
+	 * Atomically publish one result. Entering this call is the commit point:
+	 * a later conversational interruption cannot recall it. Resolve only after
+	 * the provider accepted the result; reject when it did not.
 	 */
 	sendToolResult(id: string, output: string, isError?: boolean): Promise<void>
 	events(): AsyncIterable<BidiEvent>
+	/** Stop the event stream and release provider resources. Called at most once. */
 	close(): Promise<void>
 }
 
@@ -106,7 +120,10 @@ export type BidiRunEvent =
 			readonly output: string
 			readonly isError: boolean
 	  }
-	/** A tool's answer was thrown away because the human interrupted. */
+	/**
+	 * A tool's answer was thrown away because the human interrupted before
+	 * publication began. The operation itself may have run to completion.
+	 */
 	| {
 			readonly type: 'tool_abandoned'
 			readonly runId: RunId

package/src/types/computer-use/index.ts

@@ -109,6 +109,25 @@ export type ComputerUseResult =
 	| { readonly type: 'cursor_position'; readonly point: Point }
 	| { readonly type: 'ok' }
 
+/**
+ * A state-changing desktop action started, but its subprocess did not report
+ * a clean completion. The desktop may already have changed, so treating this
+ * as an ordinary failure and automatically replaying the action is unsafe.
+ *
+ * Host packages throw an error carrying this shape. The SDK recognises it
+ * structurally so separately installed host and SDK versions do not need to
+ * share an error constructor identity.
+ */
+export interface ComputerUseOutcomeUnknown {
+	readonly code: 'computer_use_outcome_unknown'
+	readonly action: ComputerUseAction['type']
+	readonly outcome: 'unknown'
+	readonly retrySafety: 'unsafe'
+	readonly timedOut: boolean
+	readonly exitCode: number
+	readonly message: string
+}
+
 // ---------------------------------------------------------------------------
 // Host interface — the core abstraction. Mirrors Sandbox/SandboxProvider shape.
 // Implementations live outside @namzu/sdk (e.g. @namzu/computer-use).

package/src/types/connector/execution-context.ts

@@ -13,6 +13,7 @@ export type {
 export type {
 	CommandOptions,
 	CommandResult,
+	CommandTermination,
 	CommandExecutor,
 	RemoteCommandHandler,
 } from '../execution/index.js'
@@ -33,6 +34,8 @@ export interface LocalExecutionContextConfig extends ExecutionContextBase {
 	fsAccess: boolean
 	envVars?: Record<string, string>
 	shell?: string
+	/** Retained bytes per stdout/stderr stream. Defaults to 4 MiB; maximum 64 MiB. */
+	maxOutputBytes?: number
 }
 
 export interface RemoteExecutionContextConfig extends ExecutionContextBase {