@code-yeongyu/senpi 2026.9.23-5 → 2026.9.24-2

package/node_modules/@code-yeongyu/senpi-codemode/src/tool/display-js.ts

@@ -0,0 +1,100 @@
+import { isRecord, parseFile, type SourceNode } from "./display-js-ast.ts";
+import { finishLayout } from "./display-js-layout.ts";
+import { maskSource, restoreComments, restoreValues } from "./display-js-mask.ts";
+
+// Bun.Transpiler is a transpiler, not a formatter: printed directly it rewrites literals ("a\nb"
+// becomes a multi-line template, 0xff becomes 255, emoji become escapes), folds `typeof
+// undefined`, and drops comments and directives. It only ever lays out a masked cell here, and the
+// original text is substituted back; a cell that cannot be restored exactly is shown as sent.
+const INDENT = "  ";
+
+export type JsPrinter = (code: string) => string;
+
+let bunPrinter: JsPrinter | null | undefined;
+
+function resolveBunPrinter(): JsPrinter | null {
+	if (typeof process.versions.bun !== "string") return null;
+	const bun: unknown = Reflect.get(globalThis, "Bun");
+	if (!isRecord(bun) || typeof bun.Transpiler !== "function") return null;
+	const transpiler: unknown = Reflect.construct(bun.Transpiler, [
+		{ loader: "js", trimUnusedImports: false, deadCodeElimination: false, inline: false },
+	]);
+	if (!isRecord(transpiler) || typeof transpiler.transformSync !== "function") return null;
+	const transformSync = transpiler.transformSync;
+	return (code) => {
+		const output: unknown = Reflect.apply(transformSync, transpiler, [code]);
+		if (typeof output !== "string") throw new TypeError("Bun.Transpiler.transformSync returned a non-string");
+		return output;
+	};
+}
+
+/** The built-in Bun printer when this renderer runs on Bun; null on Node. */
+export function bunJsPrinter(): JsPrinter | null {
+	if (bunPrinter === undefined) bunPrinter = resolveBunPrinter();
+	return bunPrinter;
+}
+
+function layout(masked: string, prefix: string, print: JsPrinter): string | undefined {
+	try {
+		return print(masked).trim();
+	} catch {
+		// Module syntax only parses unwrapped; the kernel's top-level `return` only inside a function.
+	}
+	const header = `async function ${prefix}cell() {`;
+	let lines: string[];
+	try {
+		lines = print(`${header}\n${masked}\n}`).trim().split("\n");
+	} catch {
+		return undefined;
+	}
+	if (lines[0] !== header || lines.at(-1) !== "}") return undefined;
+	return lines
+		.slice(1, -1)
+		.map((line) => (line.startsWith(INDENT) ? line.slice(INDENT.length) : line))
+		.join("\n");
+}
+
+function sameTokens(left: string, right: string): boolean {
+	const strip = (text: string) => text.replace(/[\s;,()]/gu, "");
+	return strip(left) === strip(right);
+}
+
+const POSITION_KEYS = new Set([
+	"start",
+	"end",
+	"loc",
+	"range",
+	"extra",
+	"leadingComments",
+	"trailingComments",
+	"innerComments",
+]);
+
+// Positions, raw spellings, and parenthesization flags aside, the preview must be the same program:
+// the character guard alone cannot see a dropped `(`, which can change how an expression groups.
+function programSignature(file: SourceNode): string {
+	return JSON.stringify({ program: file.record.program, comments: file.record.comments }, (key, value: unknown) => {
+		if (POSITION_KEYS.has(key)) return undefined;
+		if (typeof value === "bigint") return `${value}n`;
+		// A stray `;` in a statement list is a no-op the printer drops.
+		return Array.isArray(value) ? value.filter((item) => !isRecord(item) || item.type !== "EmptyStatement") : value;
+	});
+}
+
+function sameProgram(original: SourceNode, preview: string): boolean {
+	const reparsed = parseFile(preview);
+	return reparsed !== undefined && programSignature(reparsed) === programSignature(original);
+}
+
+/** The printer's layout of `code` with its literal, name, and comment text intact, or undefined. */
+export function prettifyJs(code: string, print: JsPrinter): string | undefined {
+	const file = parseFile(code);
+	if (file === undefined) return undefined;
+	const mask = maskSource(code, file);
+	if (mask === undefined) return undefined;
+	const printed = layout(mask.masked, mask.prefix, print);
+	const withComments = printed === undefined ? undefined : restoreComments(printed, mask.comments);
+	const restored = withComments === undefined ? undefined : restoreValues(withComments, mask);
+	const finished = restored === undefined ? undefined : finishLayout(restored);
+	return finished !== undefined && sameTokens(finished, code) && sameProgram(file, finished) ? finished : undefined;
+}

package/node_modules/@code-yeongyu/senpi-codemode/src/tool/display-python-script.ts

@@ -0,0 +1,127 @@
+// Runs in the user's own Python interpreter: `python -c <script> <ruff timeout s> <strategies...>` with the cell on
+// stdin, printing {"via", "code"} as JSON. A strategy's output is kept only when it parses to the same
+// AST as the source and keeps every string, number, and comment token's text (senpi#2076).
+export const PYTHON_FORMATTER_SCRIPT = [
+	"import ast, io, json, re, shutil, subprocess, sys, tokenize",
+	"",
+	"def emit(via, code):",
+	"    sys.stdout.write(json.dumps({'via': via, 'code': code}))",
+	"    sys.exit(0)",
+	"",
+	"RUFF_TIMEOUT = float(sys.argv[1])",
+	"FLAGS = ast.PyCF_ONLY_AST | getattr(ast, 'PyCF_ALLOW_TOP_LEVEL_AWAIT', 0)",
+	"",
+	"def parse(text):",
+	"    return compile(text, '<cell>', 'exec', flags=FLAGS, dont_inherit=True)",
+	"",
+	"def literal_texts(text):",
+	"    kinds = {tokenize.STRING, tokenize.NUMBER, tokenize.COMMENT} | token_kinds('FSTRING_MIDDLE', 'TSTRING_MIDDLE')",
+	"    return [t.string for t in tokenize.generate_tokens(io.StringIO(text).readline) if t.type in kinds]",
+	"",
+	"def equivalent(source, formatted):",
+	"    try:",
+	"        same_tree = ast.dump(parse(source)) == ast.dump(parse(formatted))",
+	"        return same_tree and literal_texts(source) == literal_texts(formatted)",
+	"    except (SyntaxError, ValueError, tokenize.TokenError):",
+	"        return False",
+	"",
+	"def ruff_binary():",
+	"    found = shutil.which('ruff')",
+	"    if found:",
+	"        return found",
+	"    try:",
+	"        from ruff.__main__ import find_ruff_bin",
+	"        return find_ruff_bin()",
+	"    except Exception:",
+	"        return None",
+	"",
+	"def with_ruff(source):",
+	"    binary = ruff_binary()",
+	"    if not binary:",
+	"        return None",
+	"    args = [binary, 'format', '--quiet', '--no-cache', '--config', \"format.quote-style = 'preserve'\",",
+	"            '--stdin-filename', 'cell.py', '-']",
+	"    try:",
+	"        done = subprocess.run(args, input=source, capture_output=True, text=True, timeout=RUFF_TIMEOUT)",
+	"    except Exception:",
+	"        return None",
+	"    return done.stdout if done.returncode == 0 else None",
+	"",
+	"def with_black(source):",
+	"    try:",
+	"        import black",
+	"        return black.format_str(source, mode=black.Mode(string_normalization=False))",
+	"    except Exception:",
+	"        return None",
+	"",
+	"def token_kinds(*names):",
+	"    return {getattr(tokenize, name) for name in names if hasattr(tokenize, name)}",
+	"",
+	"def literal_spans(source):",
+	"    tokens = list(tokenize.generate_tokens(io.StringIO(source).readline))",
+	"    starts = [0]",
+	"    for line in source.splitlines(keepends=True):",
+	"        starts.append(starts[-1] + len(line))",
+	"    offset = lambda position: starts[position[0] - 1] + position[1]",
+	"    opening, closing = token_kinds('FSTRING_START', 'TSTRING_START'), token_kinds('FSTRING_END', 'TSTRING_END')",
+	"    spans, depth = [], 0",
+	"    for token in tokens:",
+	"        if token.type == tokenize.COMMENT:",
+	"            return None",
+	"        if depth:",
+	"            depth += 1 if token.type in opening else -1 if token.type in closing else 0",
+	"            if depth == 0:",
+	"                spans[-1][1] = offset(token.end)",
+	"            continue",
+	"        is_string = token.type == tokenize.STRING or token.type in opening",
+	"        if not is_string and token.type != tokenize.NUMBER:",
+	"            continue",
+	"        start, end = offset(token.start), offset(token.end)",
+	"        joined = spans and spans[-1][2] and is_string and not re.sub(r'[\\s\\\\]', '', source[spans[-1][1]:start])",
+	"        if joined:",
+	"            spans[-1][1] = end",
+	"        else:",
+	"            spans.append([start, end, is_string])",
+	"        if token.type in opening:",
+	"            depth = 1",
+	"    return spans",
+	"",
+	"def with_ast(source):",
+	"    if not hasattr(ast, 'unparse'):",
+	"        return None",
+	"    try:",
+	"        spans = literal_spans(source)",
+	"    except (tokenize.TokenError, SyntaxError):",
+	"        return None",
+	"    if spans is None:",
+	"        return None",
+	"    prefix = '_display'",
+	"    while prefix in source:",
+	"        prefix += '_'",
+	"    raws, masked, cursor = {}, [], 0",
+	"    for index, (start, end, _) in enumerate(spans):",
+	"        name = prefix + str(index)",
+	"        raws[name] = source[start:end]",
+	"        masked.append(source[cursor:start] + name)",
+	"        cursor = end",
+	"    masked.append(source[cursor:])",
+	"    try:",
+	"        tree = parse(''.join(masked))",
+	"    except (SyntaxError, ValueError):",
+	"        return None",
+	"    seen = []",
+	"    def restore(match):",
+	"        seen.append(match.group(0))",
+	"        return raws.get(match.group(0), match.group(0))",
+	"    text = re.sub(r'\\b' + re.escape(prefix) + r'\\d+\\b', restore, ast.unparse(tree))",
+	"    return text if sorted(seen) == sorted(raws) else None",
+	"",
+	"STRATEGIES = {'ruff': with_ruff, 'black': with_black, 'ast': with_ast}",
+	"source = sys.stdin.read()",
+	"for name in sys.argv[2:]:",
+	"    strategy = STRATEGIES.get(name)",
+	"    formatted = strategy(source) if strategy else None",
+	"    if formatted is not None and equivalent(source, formatted):",
+	"        emit(name, formatted.rstrip('\\n'))",
+	"emit('none', source)",
+].join("\n");

package/node_modules/@code-yeongyu/senpi-codemode/src/tool/display-python.ts

@@ -0,0 +1,150 @@
+import { spawn } from "node:child_process";
+import { createInterpreterDetector } from "../interpreters/detect.ts";
+import { PYTHON_FORMATTER_SCRIPT } from "./display-python-script.ts";
+
+export type PythonStrategy = "ruff" | "black" | "ast";
+export type PythonInvocation = { readonly command: string; readonly args: readonly string[] };
+
+export interface PythonFormatOptions {
+	readonly strategies: readonly PythonStrategy[];
+	readonly timeoutMs: number;
+	readonly env?: NodeJS.ProcessEnv;
+}
+
+export interface PythonDisplayOptions extends PythonFormatOptions {
+	readonly interpreter: () => Promise<PythonInvocation | null>;
+}
+
+export interface PythonDisplay {
+	/**
+	 * The formatted cell once it is known, otherwise the cell as sent. With `onFormatted`, a missing
+	 * result is formatted in the background and `onFormatted` runs when a formatted cell is ready.
+	 */
+	display(code: string, onFormatted?: () => void): string;
+}
+
+const DEFAULT_STRATEGIES: readonly PythonStrategy[] = ["ruff", "black", "ast"];
+const FORMAT_TIMEOUT_MS = 5_000;
+const MAX_CONCURRENT_FORMATTERS = 2;
+const CACHE_LIMIT = 64;
+
+function formattedCode(stdout: string): string | undefined {
+	try {
+		const parsed: unknown = JSON.parse(stdout);
+		if (parsed === null || typeof parsed !== "object" || !("code" in parsed)) return undefined;
+		return typeof parsed.code === "string" ? parsed.code : undefined;
+	} catch (error) {
+		if (error instanceof SyntaxError) return undefined;
+		throw error;
+	}
+}
+
+// ruff runs inside the formatter process, so it gets most of the caller's budget and never outlives it.
+function ruffTimeoutSeconds(timeoutMs: number): string {
+	return String(Math.max(1, timeoutMs - 1_000) / 1_000);
+}
+
+export function formatPythonCell(
+	code: string,
+	invocation: PythonInvocation,
+	options: PythonFormatOptions,
+): Promise<string | undefined> {
+	return new Promise((resolve) => {
+		const child = spawn(
+			invocation.command,
+			[
+				...invocation.args,
+				"-c",
+				PYTHON_FORMATTER_SCRIPT,
+				ruffTimeoutSeconds(options.timeoutMs),
+				...options.strategies,
+			],
+			{
+				stdio: ["pipe", "pipe", "ignore"],
+				timeout: options.timeoutMs,
+				windowsHide: true,
+				...(options.env === undefined ? {} : { env: options.env }),
+			},
+		);
+		let stdout = "";
+		child.stdout.setEncoding("utf8");
+		child.stdout.on("data", (chunk: string) => {
+			stdout += chunk;
+		});
+		child.on("error", () => resolve(undefined));
+		child.on("close", (exitCode) => resolve(exitCode === 0 ? formattedCode(stdout) : undefined));
+		child.stdin.on("error", () => resolve(undefined));
+		child.stdin.end(code);
+	});
+}
+
+export function createPythonDisplay(options: PythonDisplayOptions): PythonDisplay {
+	const settled = new Map<string, string>();
+	const listeners = new Map<string, Set<() => void>>();
+	const queue: string[] = [];
+	let running = 0;
+
+	const remember = (code: string, formatted: string) => {
+		if (settled.size >= CACHE_LIMIT) settled.delete(settled.keys().next().value ?? "");
+		settled.set(code, formatted);
+	};
+
+	const format = async (code: string): Promise<string | undefined> => {
+		const invocation = await options.interpreter();
+		return invocation === null ? undefined : formatPythonCell(code, invocation, options);
+	};
+
+	const pump = () => {
+		while (running < MAX_CONCURRENT_FORMATTERS) {
+			const code = queue.shift();
+			if (code === undefined) return;
+			running += 1;
+			void format(code)
+				.catch(() => undefined)
+				.then((formatted) => {
+					remember(code, formatted ?? code);
+					const waiting = listeners.get(code);
+					listeners.delete(code);
+					if (formatted !== undefined && formatted !== code) for (const listener of waiting ?? []) listener();
+				})
+				.finally(() => {
+					running -= 1;
+					pump();
+				});
+		}
+	};
+
+	return {
+		display(code, onFormatted) {
+			const known = settled.get(code);
+			if (known !== undefined || onFormatted === undefined) return known ?? code;
+			const waiting = listeners.get(code);
+			if (waiting !== undefined) {
+				waiting.add(onFormatted);
+				return code;
+			}
+			listeners.set(code, new Set([onFormatted]));
+			queue.push(code);
+			pump();
+			return code;
+		},
+	};
+}
+
+async function detectedPython(): Promise<PythonInvocation | null> {
+	const detected = await createInterpreterDetector().detect("py");
+	if (!detected.ok) return null;
+	const [command, ...args] = detected.path.split(" ");
+	return command === undefined ? null : { command, args };
+}
+
+let userPython: Promise<PythonInvocation | null> | undefined;
+
+export const pythonDisplay: PythonDisplay = createPythonDisplay({
+	interpreter: () => {
+		userPython ??= detectedPython();
+		return userPython;
+	},
+	strategies: DEFAULT_STRATEGIES,
+	timeoutMs: FORMAT_TIMEOUT_MS,
+});

package/node_modules/@code-yeongyu/senpi-codemode/src/tool/eval-request.ts

@@ -1,5 +1,11 @@
 import type { ExtensionContext } from "@code-yeongyu/senpi";
-import type { EvalControlInput, EvalToolInput, EvalToolRequest } from "./types.ts";
+import {
+	type EvalControlInput,
+	type EvalLanguage,
+	type EvalToolInput,
+	type EvalToolRequest,
+	evalLanguageOrder,
+} from "./types.ts";
 
 const NON_INTERACTIVE_MODES = new Set(["print", "json"]);
 
@@ -11,7 +17,10 @@ export function normalizeEvalSummary(value: unknown): string | undefined {
 	return normalized.length === 0 ? undefined : normalized;
 }
 
-export function parseEvalRequest(params: unknown): EvalToolRequest {
+export function parseEvalRequest(
+	params: unknown,
+	enabledLanguages: readonly EvalLanguage[] = evalLanguageOrder,
+): EvalToolRequest {
 	if (!isRecord(params)) throw new TypeError("eval parameters must be an object");
 	if (params.action === "list") return { action: "list" };
 	if (params.action === "peek" || params.action === "stop") {
@@ -21,8 +30,9 @@ export function parseEvalRequest(params: unknown): EvalToolRequest {
 	}
 	if (params.action !== undefined && params.action !== "run")
 		throw new TypeError(`Unknown eval action "${String(params.action)}"`);
-	if (!isEvalLanguage(params.language)) throw new TypeError("eval run requires language");
-	if (typeof params.code !== "string") throw new TypeError("eval run requires code");
+	if (!isEvalLanguage(params.language)) throw new TypeError(evalRunRequiresLanguageMessage(enabledLanguages));
+	if (typeof params.code !== "string")
+		throw new TypeError("eval run requires code — the cell body to execute, verbatim");
 	const summary = normalizeEvalSummary(params.summary);
 	if (summary === undefined)
 		throw new TypeError(
@@ -57,3 +67,7 @@ function isRecord(value: unknown): value is Record<string, unknown> {
 function isEvalLanguage(value: unknown): value is EvalToolInput["language"] {
 	return value === "py" || value === "js" || value === "rb" || value === "jl";
 }
+
+function evalRunRequiresLanguageMessage(languages: readonly EvalLanguage[]): string {
+	return `eval run requires language — one of ${languages.map((language) => `"${language}"`).join(", ")}`;
+}

package/node_modules/@code-yeongyu/senpi-codemode/src/tool/eval-tool.ts

@@ -73,7 +73,7 @@ export function createEvalTool(options: CreateEvalToolOptions) {
 	async function execute(
 		...[toolCallId, params, signal, onUpdate, ctx]: EvalExecuteArgs<EvalToolRequest>
 	): Promise<AgentToolResult<EvalResultDetails>> {
-		const request = parseEvalRequest(params);
+		const request = parseEvalRequest(params, languages);
 		if (isEvalControlRequest(request)) return await executeEvalControl(cellManager, request);
 		if (options.proxyExecutor) return await options.proxyExecutor(request, signal);
 		if (!languages.includes(request.language))

package/node_modules/@code-yeongyu/senpi-codemode/src/tool/render.ts

@@ -1,7 +1,6 @@
 // allow: SIZE_OK — one eval render pipeline avoids the runtime/render TDZ that motivated this module boundary.
 import {
 	type AgentToolResult,
-	highlightCode,
 	sanitizeTerminalLabel,
 	type Theme,
 	type ThemeColor,
@@ -10,6 +9,7 @@ import {
 	truncateToVisualLines,
 } from "@code-yeongyu/senpi";
 import type { TruncationMeta } from "../output/output-meta.ts";
+import { highlightedCode } from "./code-preview.ts";
 import { displayCode } from "./display-code.ts";
 import { normalizeEvalSummary } from "./eval-request.ts";
 import {
@@ -26,7 +26,6 @@ import { codePointPrefix, formatDuration, renderToolCallWidget } from "./tool-wi
 import type {
 	EvalCellResult,
 	EvalInputSchema,
-	EvalLanguage,
 	EvalResultDetails,
 	EvalStatusEvent,
 	EvalToolDetails,
@@ -269,6 +268,8 @@ type RenderEnvironment = {
 	readonly meta: TruncationMeta | undefined;
 	/** Render-time clock, injected so elapsed time is deterministic under test. */
 	readonly now: number;
+	/** Repaints the row once a background-formatted code preview is ready; absent while args stream. */
+	readonly repaint?: () => void;
 };
 type CellBadges = {
 	readonly reset: boolean;
@@ -288,27 +289,6 @@ function assertNever(value: never): never {
 	throw new TypeError(`Unhandled eval render variant: ${String(value)}`);
 }
 
-function languageForHighlighter(language: EvalLanguage): "python" | "javascript" | "ruby" | "julia" {
-	switch (language) {
-		case "py":
-			return "python";
-		case "js":
-			return "javascript";
-		case "rb":
-			return "ruby";
-		case "jl":
-			return "julia";
-		default:
-			return assertNever(language);
-	}
-}
-
-function highlightedCode(code: string, language: EvalLanguage, theme: Theme | undefined): string {
-	const normalizedCode = code.trim().length > 0 ? code : "...";
-	const lines = highlightCode(displayCode(normalizedCode, language), languageForHighlighter(language));
-	return (theme === undefined ? lines.map((line) => line.replace(/\u001b\[[0-9;]*m/gu, "")) : lines).join("\n");
-}
-
 function spinner(frame: number | undefined): string {
 	return SPINNER_FRAMES.at((frame ?? 0) % SPINNER_FRAMES.length) ?? SPINNER_FRAMES[0];
 }
@@ -644,7 +624,7 @@ function renderCell(cell: EvalCellResult, environment: RenderEnvironment, badges
 	}
 	const innerWidth = Math.max(1, environment.width - 2);
 	const codePreview = previewText(
-		highlightedCode(cell.code, cell.language, environment.theme),
+		highlightedCode(cell.code, cell.language, environment.theme, environment.repaint),
 		environment.expanded ? Number.POSITIVE_INFINITY : CODE_PREVIEW_LINES,
 		innerWidth,
 	);
@@ -926,7 +906,9 @@ export function renderEvalCall(
 				text: style(
 					theme,
 					"mdCodeBlock",
-					args.code.trim().length > 0 ? displayCode(args.code, args.language) : "...",
+					args.code.trim().length > 0
+						? displayCode(args.code, args.language, context.argsComplete ? context.invalidate : undefined)
+						: "...",
 				),
 				maxVisualLines: context.expanded ? undefined : CODE_PREVIEW_LINES,
 				collapseKind: "code",
@@ -946,6 +928,7 @@ export function renderEvalCall(
 					width,
 					meta: undefined,
 					now: renderNow(context),
+					...(context.argsComplete ? { repaint: context.invalidate } : {}),
 				};
 				const cell: EvalCellResult = {
 					index: 0,
@@ -998,6 +981,7 @@ export function renderEvalResult(
 							width,
 							meta: details.meta,
 							now: renderNow(context),
+							repaint: context.invalidate,
 						},
 						args: context.args,
 						showImageFallback: context.showImages && imageProtocol === null,

package/node_modules/@code-yeongyu/senpi-codemode/src/tool/types.ts

@@ -65,6 +65,12 @@ export type EvalControlInput =
 
 export type EvalToolRequest = EvalToolInput | EvalControlInput;
 
+// Like `summary`, `language` and `code` stay optional in the wire schema because control
+// actions share it; the description teaches the requirement and parseEvalRequest enforces it.
+const LANGUAGE_FIELD_DESCRIPTION =
+	"REQUIRED for run. Kernel that runs the cell; each language keeps its own persistent state across eval calls.";
+const CODE_FIELD_DESCRIPTION = "REQUIRED for run. Cell body, verbatim.";
+
 function evalInputProperties<Language extends TSchema>(languageSchema: Language, deadlines: EvalDeadlineSeconds) {
 	return {
 		action: Type.Optional(
@@ -74,7 +80,7 @@ function evalInputProperties<Language extends TSchema>(languageSchema: Language,
 			}),
 		),
 		language: Type.Optional(languageSchema),
-		code: Type.Optional(Type.String({ description: "Cell body, verbatim." })),
+		code: Type.Optional(Type.String({ description: CODE_FIELD_DESCRIPTION })),
 		summary: Type.Optional(
 			Type.String({
 				description:
@@ -96,11 +102,15 @@ function evalInputProperties<Language extends TSchema>(languageSchema: Language,
 	};
 }
 
+function evalLanguageUnion(languages: readonly EvalLanguage[]) {
+	return Type.Union(
+		languages.map((item) => Type.Literal(item)),
+		{ description: LANGUAGE_FIELD_DESCRIPTION },
+	);
+}
+
 const fullEvalInputSchema = Type.Object(
-	evalInputProperties(
-		Type.Union([Type.Literal("js"), Type.Literal("py"), Type.Literal("rb"), Type.Literal("jl")]),
-		defaultEvalDeadlineSeconds,
-	),
+	evalInputProperties(evalLanguageUnion(evalLanguageOrder), defaultEvalDeadlineSeconds),
 );
 
 /** Runtime accepts a discriminated run/control union. */
@@ -112,10 +122,7 @@ export function createEvalInputSchema(
 ): EvalInputSchema {
 	const languages = enabledLanguageList(enabled);
 	if (languages.length === 0) throw new Error("eval requires at least one enabled language");
-	const languageSchema =
-		languages.length === 1
-			? Type.Union([Type.Literal(languages[0])])
-			: Type.Union(languages.map((item) => Type.Literal(item)));
+	const languageSchema = evalLanguageUnion(languages);
 	return Type.Unsafe<EvalToolRequest>(
 		Type.Object(evalInputProperties(languageSchema, deadlines), {
 			anyOf: [

package/node_modules/@earendil-works/pi-agent-core/dist/agent-loop.d.ts

@@ -26,7 +26,7 @@ export declare class StreamStartTimeoutError extends Error {
     constructor(timeoutMs: number);
 }
 /** Build the provider context using the same transform and conversion pipeline as an agent request. */
-export declare function buildProviderContext(context: AgentContext, config: Pick<AgentLoopConfig, "convertToLlm" | "transformContext">, signal?: AbortSignal): Promise<Context>;
+export declare function buildProviderContext(context: AgentContext, config: Pick<AgentLoopConfig, "convertToLlm" | "transformContext"> & Partial<Pick<AgentLoopConfig, "model">>, signal?: AbortSignal): Promise<Context>;
 export interface PreparedAgentToolCall {
     toolCall: AgentToolCall;
     tool: AgentTool;

package/node_modules/@earendil-works/pi-agent-core/dist/agent-loop.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"agent-loop.d.ts","sourceRoot":"","sources":["../src/agent-loop.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAIN,KAAK,OAAO,EAEZ,WAAW,EAIX,MAAM,uBAAuB,CAAC;AAW/B,OAAO,EAAE,6BAA6B,EAAE,MAAM,qBAAqB,CAAC;AAEpE,OAAO,KAAK,EACX,YAAY,EACZ,UAAU,EACV,eAAe,EAEf,YAAY,EACZ,SAAS,EACT,aAAa,EAEb,QAAQ,EACR,MAAM,YAAY,CAAC;AAEpB,MAAM,MAAM,cAAc,GAAG,CAAC,KAAK,EAAE,UAAU,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;AAEzE;;;GAGG;AACH,wBAAgB,SAAS,CACxB,OAAO,EAAE,YAAY,EAAE,EACvB,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,eAAe,EACvB,MAAM,EAAE,WAAW,GAAG,SAAS,EAC/B,QAAQ,EAAE,QAAQ,GAChB,WAAW,CAAC,UAAU,EAAE,YAAY,EAAE,CAAC,CAiBzC;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAChC,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,eAAe,EACvB,MAAM,EAAE,WAAW,GAAG,SAAS,EAC/B,QAAQ,EAAE,QAAQ,GAChB,WAAW,CAAC,UAAU,EAAE,YAAY,EAAE,CAAC,CAwBzC;AAED,wBAAsB,YAAY,CACjC,OAAO,EAAE,YAAY,EAAE,EACvB,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,eAAe,EACvB,IAAI,EAAE,cAAc,EACpB,MAAM,EAAE,WAAW,GAAG,SAAS,EAC/B,QAAQ,EAAE,QAAQ,GAChB,OAAO,CAAC,YAAY,EAAE,CAAC,CAgBzB;AAED,wBAAsB,oBAAoB,CACzC,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,eAAe,EACvB,IAAI,EAAE,cAAc,EACpB,MAAM,EAAE,WAAW,GAAG,SAAS,EAC/B,QAAQ,EAAE,QAAQ,GAChB,OAAO,CAAC,YAAY,EAAE,CAAC,CAiBzB;AAmBD,qBAAa,uBAAwB,SAAQ,KAAK;IACjD,YAAY,SAAS,EAAE,MAAM,EAK5B;CACD;AA2ND,uGAAuG;AACvG,wBAAsB,oBAAoB,CACzC,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,IAAI,CAAC,eAAe,EAAE,cAAc,GAAG,kBAAkB,CAAC,EAClE,MAAM,CAAC,EAAE,WAAW,GAClB,OAAO,CAAC,OAAO,CAAC,CAIlB;AAknBD,MAAM,WAAW,qBAAqB;IACrC,QAAQ,EAAE,aAAa,CAAC;IACxB,IAAI,EAAE,SAAS,CAAC;IAChB,IAAI,EAAE,OAAO,CAAC;CACd;AAED,OAAO,EAAE,6BAA6B,EAAE,CAAC;AAEzC,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,SAAS,EAAE,QAAQ,EAAE,aAAa,GAAG,qBAAqB,CAOpG"}
+{"version":3,"file":"agent-loop.d.ts","sourceRoot":"","sources":["../src/agent-loop.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAIN,KAAK,OAAO,EAEZ,WAAW,EAKX,MAAM,uBAAuB,CAAC;AAW/B,OAAO,EAAE,6BAA6B,EAAE,MAAM,qBAAqB,CAAC;AAEpE,OAAO,KAAK,EACX,YAAY,EACZ,UAAU,EACV,eAAe,EAEf,YAAY,EACZ,SAAS,EACT,aAAa,EAEb,QAAQ,EACR,MAAM,YAAY,CAAC;AAEpB,MAAM,MAAM,cAAc,GAAG,CAAC,KAAK,EAAE,UAAU,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;AAEzE;;;GAGG;AACH,wBAAgB,SAAS,CACxB,OAAO,EAAE,YAAY,EAAE,EACvB,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,eAAe,EACvB,MAAM,EAAE,WAAW,GAAG,SAAS,EAC/B,QAAQ,EAAE,QAAQ,GAChB,WAAW,CAAC,UAAU,EAAE,YAAY,EAAE,CAAC,CAiBzC;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAChC,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,eAAe,EACvB,MAAM,EAAE,WAAW,GAAG,SAAS,EAC/B,QAAQ,EAAE,QAAQ,GAChB,WAAW,CAAC,UAAU,EAAE,YAAY,EAAE,CAAC,CAwBzC;AAED,wBAAsB,YAAY,CACjC,OAAO,EAAE,YAAY,EAAE,EACvB,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,eAAe,EACvB,IAAI,EAAE,cAAc,EACpB,MAAM,EAAE,WAAW,GAAG,SAAS,EAC/B,QAAQ,EAAE,QAAQ,GAChB,OAAO,CAAC,YAAY,EAAE,CAAC,CAgBzB;AAED,wBAAsB,oBAAoB,CACzC,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,eAAe,EACvB,IAAI,EAAE,cAAc,EACpB,MAAM,EAAE,WAAW,GAAG,SAAS,EAC/B,QAAQ,EAAE,QAAQ,GAChB,OAAO,CAAC,YAAY,EAAE,CAAC,CAiBzB;AAmBD,qBAAa,uBAAwB,SAAQ,KAAK;IACjD,YAAY,SAAS,EAAE,MAAM,EAK5B;CACD;AA+OD,uGAAuG;AACvG,wBAAsB,oBAAoB,CACzC,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,IAAI,CAAC,eAAe,EAAE,cAAc,GAAG,kBAAkB,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,eAAe,EAAE,OAAO,CAAC,CAAC,EAC5G,MAAM,CAAC,EAAE,WAAW,GAClB,OAAO,CAAC,OAAO,CAAC,CAQlB;AAknBD,MAAM,WAAW,qBAAqB;IACrC,QAAQ,EAAE,aAAa,CAAC;IACxB,IAAI,EAAE,SAAS,CAAC;IAChB,IAAI,EAAE,OAAO,CAAC;CACd;AAED,OAAO,EAAE,6BAA6B,EAAE,CAAC;AAEzC,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,SAAS,EAAE,QAAQ,EAAE,aAAa,GAAG,qBAAqB,CAOpG"}

package/node_modules/@earendil-works/pi-agent-core/dist/agent-loop.js

@@ -2,7 +2,7 @@
  * Agent loop that works with AgentMessage throughout.
  * Transforms to Message[] only at the LLM call boundary.
  */
-import { EventStream, isCursorExecResolved, validateToolArguments, } from "@earendil-works/pi-ai";
+import { EventStream, isCursorExecResolved, supportsAllowedToolChoice, validateToolArguments, } from "@earendil-works/pi-ai";
 import { createTerminalFailureAssistantMessage, demoteToolUseWithoutToolCalls, isStreamIdleTimeoutError, normalizeTerminalAssistantMessage, promoteStopWithPendingToolCalls, shouldFinalizeIdleAsStop, shouldTerminateAssistantTurn, } from "./assistant-terminal-state.js";
 import { getDefaultStreamFn, withEmptyAssistantRecovery } from "./stream-fn.js";
 import { prepareAgentToolCallArguments } from "./tool-arguments.js";
@@ -279,12 +279,32 @@ async function runLoop(initialContext, newMessages, initialConfig, signal, emit,
     }
     await emit({ type: "agent_end", messages: newMessages });
 }
+/**
+ * senpi#2095: a model that accepts an allowed-tools restriction receives every declared tool plus the
+ * callable subset by name; any other model receives the callable tools alone, as before.
+ */
+function providerTools(context, model) {
+    const declaredTools = context.declaredTools;
+    if (declaredTools === undefined || model === undefined || !supportsAllowedToolChoice(model)) {
+        return { tools: context.tools };
+    }
+    const activeTools = context.tools ?? [];
+    const declaredNames = new Set(declaredTools.map((tool) => tool.name));
+    return {
+        tools: [...declaredTools, ...activeTools.filter((tool) => !declaredNames.has(tool.name))],
+        activeToolNames: activeTools.map((tool) => tool.name),
+    };
+}
 /** Build the provider context using the same transform and conversion pipeline as an agent request. */
 export async function buildProviderContext(context, config, signal) {
     let messages = context.messages;
     if (config.transformContext)
         messages = await config.transformContext(messages, signal);
-    return { systemPrompt: context.systemPrompt, messages: await config.convertToLlm(messages), tools: context.tools };
+    return {
+        systemPrompt: context.systemPrompt,
+        messages: await config.convertToLlm(messages),
+        ...providerTools(context, config.model),
+    };
 }
 /**
  * Stream an assistant response from the LLM.