@oh-my-pi/pi-coding-agent 16.1.12 → 16.1.14

package/src/tools/eval-render.ts

@@ -2,11 +2,12 @@
  * TUI rendering for the eval tool.
  *
  * Split out from `eval.ts` so the renderer can be imported by `renderers.ts`
- * without dragging the eval *runtime* (JS/Python backends -> agent bridge ->
- * task executor -> sdk -> extension loader -> root barrel) into the renderer
- * module graph. That transitive chain re-enters `renderers.ts` while `eval.ts`
- * is still initializing, which previously crashed module load with a TDZ
- * `Cannot access 'evalToolRenderer' before initialization`.
+ * without dragging the eval *runtime* (JS/Python/Ruby/Julia backends ->
+ * agent bridge -> task executor -> sdk -> extension loader -> root barrel)
+ * into the renderer module graph. That transitive chain re-enters
+ * `renderers.ts` while `eval.ts` is still initializing, which previously
+ * crashed module load with a TDZ `Cannot access 'evalToolRenderer' before
+ * initialization`.
  */
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Markdown, Text } from "@oh-my-pi/pi-tui";
@@ -41,8 +42,11 @@ import {
 } from "./render-utils";
 export const EVAL_DEFAULT_PREVIEW_LINES = 10;
 
-function languageForHighlighter(language: EvalLanguage | undefined): "python" | "javascript" {
-	return language === "js" ? "javascript" : "python";
+function languageForHighlighter(language: EvalLanguage | undefined): "python" | "javascript" | "ruby" | "julia" {
+	if (language === "js") return "javascript";
+	if (language === "ruby") return "ruby";
+	if (language === "julia") return "julia";
+	return "python";
 }
 
 interface EvalRenderCellArg {
@@ -70,7 +74,10 @@ interface EvalRenderCell {
 }
 
 function normalizeRenderLanguage(value: string | undefined): EvalLanguage {
-	return value === "js" ? "js" : "python";
+	if (value === "js") return "js";
+	if (value === "rb" || value === "ruby") return "ruby";
+	if (value === "jl" || value === "julia") return "julia";
+	return "python";
 }
 
 function getRenderCells(args: EvalRenderArgs | undefined): EvalRenderCell[] {
@@ -506,6 +513,7 @@ export const evalToolRenderer = {
 						{
 							code: cell.code,
 							language: languageForHighlighter(cell.language),
+							showLanguage: true,
 							index: i,
 							total: cells.length,
 							title: cell.title,
@@ -608,6 +616,7 @@ export const evalToolRenderer = {
 							{
 								code: cell.code,
 								language: languageForHighlighter(cell.language ?? details?.language),
+								showLanguage: true,
 								index: i,
 								total: cellResults.length,
 								title: cell.title,

package/src/tools/eval.ts

@@ -2,7 +2,7 @@ import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallb
 import type { ImageContent, ToolExample } from "@oh-my-pi/pi-ai";
 import { prompt } from "@oh-my-pi/pi-utils";
 import { type } from "arktype";
-import { jsBackend, pythonBackend } from "../eval";
+import { jsBackend, juliaBackend, pythonBackend, rubyBackend } from "../eval";
 import type { ExecutorBackend, ExecutorBackendResult } from "../eval/backend";
 import { EVAL_TIMEOUT_PAUSE_OP, EVAL_TIMEOUT_RESUME_OP } from "../eval/bridge-timeout";
 import { IdleTimeout } from "../eval/idle-timeout";
@@ -14,7 +14,7 @@ import { webpExclusionForModel } from "../utils/image-loading";
 import { formatDimensionNote, resizeImage } from "../utils/image-resize";
 import type { ToolSession } from ".";
 import { truncateForPrompt } from "./approval";
-import { resolveEvalBackends } from "./eval-backends";
+import { type EvalBackendsAllowance, resolveEvalBackends } from "./eval-backends";
 import { upsertStatusEvent } from "./eval-render";
 import { resolveOutputMaxColumns, resolveOutputSinkHeadBytes } from "./output-meta";
 import { ToolAbortError, ToolError } from "./tool-errors";
@@ -23,29 +23,112 @@ import { clampTimeout } from "./tool-timeouts";
 
 export { EVAL_DEFAULT_PREVIEW_LINES, evalToolRenderer } from "./eval-render";
 
-/**
- * Per-cell input. Each cell runs in order; state persists within a language
- * across cells and across tool calls.
- */
-const evalCellSchema = type({
-	language: type("'py' | 'js'").describe('runtime: "py" for the IPython kernel, "js" for the persistent JS VM'),
-	code: type("string").describe("cell body, verbatim. Use top-level await freely."),
+/** Language tokens the eval tool accepts, in stable display order. */
+export type EvalLanguageToken = "py" | "js" | "rb" | "jl";
+const EVAL_LANGUAGE_ORDER: readonly EvalLanguageToken[] = ["py", "js", "rb", "jl"];
+const EVAL_LANGUAGE_RUNTIME: Record<EvalLanguageToken, string> = {
+	py: '"py" for the IPython kernel',
+	js: '"js" for the persistent JS VM',
+	rb: '"rb" for the persistent Ruby kernel',
+	jl: '"jl" for the persistent Julia kernel',
+};
+const EVAL_LANGUAGE_NAME: Record<EvalLanguageToken, string> = {
+	py: "Python",
+	js: "JavaScript",
+	rb: "Ruby",
+	jl: "Julia",
+};
+const EVAL_CELLS_DESCRIPTION =
+	"cells executed in order. State persists within each language across cells and tool calls.";
+
+/** Join names as an English "or" list: ["A"]→"A", ["A","B"]→"A or B", 3+→"A, B, or C". */
+function joinWithOr(items: readonly string[]): string {
+	if (items.length <= 1) return items[0] ?? "";
+	if (items.length === 2) return `${items[0]} or ${items[1]}`;
+	return `${items.slice(0, -1).join(", ")}, or ${items[items.length - 1]}`;
+}
+
+function describeLanguageField(langs: readonly EvalLanguageToken[]): string {
+	return `runtime: ${langs.map(lang => EVAL_LANGUAGE_RUNTIME[lang]).join(", ")}`;
+}
+
+function describeCodeField(langs: readonly EvalLanguageToken[]): string {
+	const replLangs = langs.filter(lang => lang === "rb" || lang === "jl");
+	// No persistent REPL backends → keep the original py/js phrasing verbatim so the
+	// default (rb/jl off) wire schema stays byte-identical to the pre-feature one.
+	if (replLangs.length === 0) return "cell body, verbatim. Use top-level await freely.";
+	const awaitLangs = langs.filter(lang => lang === "py" || lang === "js");
+	const clauses: string[] = [];
+	if (awaitLangs.length > 0) clauses.push(`Top-level \`await\` is available in ${awaitLangs.join("/")}`);
+	clauses.push(`${replLangs.join("/")} auto-display the last expression like a REPL`);
+	return `cell body, verbatim. ${clauses.join("; ")}.`;
+}
+
+/** One-line discovery summary listing the runtimes available this session. */
+function summarizeEvalLanguages(langs: readonly EvalLanguageToken[]): string {
+	const names = langs.map(lang => EVAL_LANGUAGE_NAME[lang]);
+	const list = names.length > 0 ? joinWithOr(names) : "Python or JavaScript";
+	// "in-process" matches the historical py/js summary; persistent kernels (rb/jl) switch wording.
+	const backend = langs.some(lang => lang === "rb" || lang === "jl") ? "a persistent" : "an in-process";
+	return `Execute ${list} code in ${backend} eval backend`;
+}
+
+/** Resolved-allowance → enabled language tokens, preserving display order. */
+function enabledEvalLanguages(backends: EvalBackendsAllowance): EvalLanguageToken[] {
+	const allowed: Record<EvalLanguageToken, boolean> = {
+		py: backends.python,
+		js: backends.js,
+		rb: backends.ruby,
+		jl: backends.julia,
+	};
+	return EVAL_LANGUAGE_ORDER.filter(lang => allowed[lang]);
+}
+
+const evalCellCommonFields = {
 	"title?": type("string").describe('short label shown in transcript (e.g. "imports", "load config")'),
 	"timeout?": type("number").describe("per-cell timeout in seconds"),
 	"reset?": type("boolean").describe(
 		"wipe this cell's language kernel before running. Other languages are untouched.",
 	),
+};
+
+/**
+ * Per-cell input. Each cell runs in order; state persists within a language
+ * across cells and across tool calls. This static schema carries the full
+ * language union for typing; {@link buildEvalSchema} narrows the wire copy per
+ * session so disabled backends are never advertised to the model.
+ */
+const evalCellSchema = type({
+	language: type("'py' | 'js' | 'rb' | 'jl'").describe(describeLanguageField(EVAL_LANGUAGE_ORDER)),
+	code: type("string").describe(describeCodeField(EVAL_LANGUAGE_ORDER)),
+	...evalCellCommonFields,
 });
 export type EvalCellInput = typeof evalCellSchema.infer;
 
 export const evalSchema = type({
-	cells: evalCellSchema
-		.array()
-		.atLeastLength(1)
-		.describe("cells executed in order. State persists within each language across cells and tool calls."),
+	cells: evalCellSchema.array().atLeastLength(1).describe(EVAL_CELLS_DESCRIPTION),
 });
 export type EvalToolParams = typeof evalSchema.infer;
 
+/**
+ * Build a session-scoped copy of the eval schema whose `language` enum and field
+ * descriptions advertise only the runtimes enabled for this session. Disabled
+ * backends never reach the model: the wire schema, BM25 discovery corpus, and
+ * tool description stay in lockstep with {@link resolveEvalBackends}. The static
+ * {@link evalSchema} (full union) remains the type-level source of truth.
+ */
+function buildEvalSchema(langs: readonly EvalLanguageToken[]): typeof evalSchema {
+	const cellSchema = type({
+		language: type.enumerated(...langs).describe(describeLanguageField(langs)),
+		code: type("string").describe(describeCodeField(langs)),
+		...evalCellCommonFields,
+	});
+	const schema = type({
+		cells: cellSchema.array().atLeastLength(1).describe(EVAL_CELLS_DESCRIPTION),
+	});
+	return schema as unknown as typeof evalSchema;
+}
+
 export type EvalToolResult = {
 	content: Array<{ type: "text"; text: string }>;
 	details: EvalToolDetails | undefined;
@@ -88,6 +171,8 @@ function formatDisplayOutputsForText(outputs: EvalDisplayOutput[]): string {
 export interface EvalToolDescriptionOptions {
 	py?: boolean;
 	js?: boolean;
+	rb?: boolean;
+	jl?: boolean;
 	/**
 	 * Whether `agent()` is allowed in this session. Driven by the parent's
 	 * spawn policy (`getSessionSpawns`). Defaults to `true` for backward
@@ -101,8 +186,10 @@ export interface EvalToolDescriptionOptions {
 export function getEvalToolDescription(options: EvalToolDescriptionOptions = {}): string {
 	const py = options.py ?? true;
 	const js = options.js ?? true;
+	const rb = options.rb ?? false;
+	const jl = options.jl ?? false;
 	const spawns = options.spawns ?? true;
-	return prompt.render(evalDescription, { py, js, spawns });
+	return prompt.render(evalDescription, { py, js, rb, jl, spawns });
 }
 
 export interface EvalToolOptions {
@@ -142,19 +229,61 @@ async function resolveBackend(session: ToolSession, language: EvalLanguage): Pro
 	const backends = resolveEvalBackends(session);
 	const allowPy = backends.python;
 	const allowJs = backends.js;
+	const allowRb = backends.ruby;
+	const allowJl = backends.julia;
 
 	if (language === "python") {
 		if (!allowPy) throw new ToolError("Python backend is disabled (PI_PY=0 or eval.py = false).");
 		if (!(await pythonBackend.isAvailable(session))) {
+			const alternatives = [allowJs ? '"js"' : null, allowRb ? '"rb"' : null, allowJl ? '"jl"' : null].filter(
+				Boolean,
+			);
 			throw new ToolError(
-				'Python backend is unavailable in this session. Pass language: "js" or install the python kernel.',
+				alternatives.length > 0
+					? `Python backend is unavailable in this session. Pass language: ${alternatives.join(" or ")} or install the python kernel.`
+					: 'Python backend is unavailable in this session. Install the python kernel to use language: "py".',
 			);
 		}
 		return { backend: pythonBackend };
 	}
+	if (language === "ruby") {
+		if (!allowRb) throw new ToolError("Ruby backend is disabled (PI_RB=0 or eval.rb = false).");
+		if (!(await rubyBackend.isAvailable(session))) {
+			const alternatives = [allowJs ? '"js"' : null, allowPy ? '"py"' : null, allowJl ? '"jl"' : null].filter(
+				Boolean,
+			);
+			throw new ToolError(
+				alternatives.length > 0
+					? `Ruby backend is unavailable in this session. Pass language: ${alternatives.join(" or ")} or install Ruby.`
+					: 'Ruby backend is unavailable in this session. Install Ruby to use language: "rb".',
+			);
+		}
+		return { backend: rubyBackend };
+	}
+	if (language === "julia") {
+		if (!allowJl) throw new ToolError("Julia backend is disabled (PI_JL=0 or eval.jl = false).");
+		if (!(await juliaBackend.isAvailable(session))) {
+			const alternatives = [allowJs ? '"js"' : null, allowPy ? '"py"' : null, allowRb ? '"rb"' : null].filter(
+				Boolean,
+			);
+			throw new ToolError(
+				alternatives.length > 0
+					? `Julia backend is unavailable in this session. Pass language: ${alternatives.join(" or ")} or install Julia.`
+					: 'Julia backend is unavailable in this session. Install Julia to use language: "jl".',
+			);
+		}
+		return { backend: juliaBackend };
+	}
 	if (!allowJs) throw new ToolError("JavaScript backend is disabled (PI_JS=0 or eval.js = false).");
 	return { backend: jsBackend };
 }
+function formatEvalInputLanguage(value: string): string {
+	if (value === "py" || value === "python") return "python";
+	if (value === "js" || value === "javascript") return "javascript";
+	if (value === "rb" || value === "ruby") return "ruby";
+	if (value === "jl" || value === "julia") return "julia";
+	return value;
+}
 
 export class EvalTool implements AgentTool<typeof evalSchema> {
 	readonly name = "eval";
@@ -164,7 +293,8 @@ export class EvalTool implements AgentTool<typeof evalSchema> {
 		const cells = Array.isArray(params.cells) ? params.cells : [];
 		const firstCell = cells[0] as Partial<EvalCellInput> | undefined;
 		if (!firstCell) return [];
-		const language = typeof firstCell.language === "string" ? firstCell.language : "(missing)";
+		const language =
+			typeof firstCell.language === "string" ? formatEvalInputLanguage(firstCell.language) : "javascript (default)";
 		const code = typeof firstCell.code === "string" ? firstCell.code : "";
 		const lines = [`Language: ${language}`, `Code:\n${truncateForPrompt(code)}`];
 		if (cells.length > 1) {
@@ -172,7 +302,9 @@ export class EvalTool implements AgentTool<typeof evalSchema> {
 		}
 		return lines;
 	};
-	readonly summary = "Execute Python or JavaScript code in an in-process eval backend";
+	get summary(): string {
+		return summarizeEvalLanguages(this.#enabledLanguages());
+	}
 	readonly loadMode = "discoverable";
 	readonly label = "Eval";
 	get description(): string {
@@ -180,7 +312,13 @@ export class EvalTool implements AgentTool<typeof evalSchema> {
 		const backends = resolveEvalBackends(this.session);
 		const sessionSpawns = this.session.getSessionSpawns?.() ?? "*";
 		const spawnsAllowed = sessionSpawns !== "" && sessionSpawns !== null;
-		return getEvalToolDescription({ py: backends.python, js: backends.js, spawns: spawnsAllowed });
+		return getEvalToolDescription({
+			py: backends.python,
+			js: backends.js,
+			rb: backends.ruby,
+			jl: backends.julia,
+			spawns: spawnsAllowed,
+		});
 	}
 	readonly examples: readonly ToolExample<typeof evalSchema.infer>[] = [
 		{
@@ -201,7 +339,16 @@ export class EvalTool implements AgentTool<typeof evalSchema> {
 			},
 		},
 	];
-	readonly parameters = evalSchema;
+	get parameters(): typeof evalSchema {
+		const langs = this.#enabledLanguages();
+		if (langs.length === 0 || langs.length === EVAL_LANGUAGE_ORDER.length) return evalSchema;
+		const key = langs.join(",");
+		if (this.#paramsKey !== key) {
+			this.#cachedParams = buildEvalSchema(langs);
+			this.#paramsKey = key;
+		}
+		return this.#cachedParams ?? evalSchema;
+	}
 	readonly concurrency = "exclusive";
 	readonly strict = true;
 	readonly intent = (args: Partial<typeof evalSchema.infer>): string | undefined => {
@@ -209,13 +356,24 @@ export class EvalTool implements AgentTool<typeof evalSchema> {
 		const first = cells.find(c => c && typeof c === "object");
 		if (!first) return "evaluating";
 		const title = typeof first.title === "string" ? first.title : undefined;
-		const language = typeof first.language === "string" ? first.language : "?";
+		const language = typeof first.language === "string" ? formatEvalInputLanguage(first.language) : "javascript";
 		const label = title || `running ${language}`;
 		return cells.length > 1 ? `${label} (+${cells.length - 1})` : label;
 	};
 
 	readonly #proxyExecutor?: EvalProxyExecutor;
 
+	#paramsKey?: string;
+	#cachedParams?: typeof evalSchema;
+
+	/**
+	 * Languages enabled for this session, in display order. Detached tools (no
+	 * session) fall back to the shipped defaults (py/js; rb/jl are opt-in).
+	 */
+	#enabledLanguages(): EvalLanguageToken[] {
+		return this.session ? enabledEvalLanguages(resolveEvalBackends(this.session)) : ["py", "js"];
+	}
+
 	constructor(
 		private readonly session: ToolSession | null,
 		options?: EvalToolOptions,
@@ -243,7 +401,14 @@ export class EvalTool implements AgentTool<typeof evalSchema> {
 		const cells: ResolvedEvalCell[] = [];
 		for (let i = 0; i < params.cells.length; i++) {
 			const cell = params.cells[i];
-			const language: EvalLanguage = cell.language === "py" ? "python" : "js";
+			const language: EvalLanguage =
+				cell.language === "py"
+					? "python"
+					: cell.language === "rb"
+						? "ruby"
+						: cell.language === "jl"
+							? "julia"
+							: "js";
 			const resolved = await resolveBackend(session, language);
 			cells.push({
 				index: i,
@@ -348,7 +513,7 @@ export class EvalTool implements AgentTool<typeof evalSchema> {
 					// The per-cell `timeout` is a budget on the cell runtime's *own*
 					// work. Host-side `agent()`/`parallel()`/`completion()` bridge calls suspend
 					// that budget entirely and restart a fresh timeout window when control
-					// returns to Python/JS. Compute, stdout, `log()`/`phase()`, and
+					// returns to the active backend runtime. Compute, stdout, `log()`/`phase()`, and
 					// ordinary tool calls all count against the budget. The watchdog drives
 					// `combinedSignal`; we pass no wall-clock deadline downstream so the
 					// backends never arm a competing fixed timer.

package/src/tools/index.ts

@@ -7,7 +7,9 @@ import type { Rule } from "../capability/rule";
 import type { PromptTemplate } from "../config/prompt-templates";
 import type { Settings } from "../config/settings";
 import { EditTool } from "../edit";
+import { checkJuliaKernelAvailability } from "../eval/jl/kernel";
 import { checkPythonKernelAvailability } from "../eval/py/kernel";
+import { checkRubyKernelAvailability } from "../eval/rb/kernel";
 import type { ToolPathWithSource } from "../extensibility/custom-tools";
 import type { Skill } from "../extensibility/skills";
 import type { GoalModeState, GoalRuntime } from "../goals";
@@ -165,7 +167,7 @@ export interface ToolSession {
 	suppressSpawnAdvisory?: boolean;
 	/** Optional fetch implementation injected into the URL read pipeline (tests, proxies). Defaults to global fetch. */
 	fetch?: FetchImpl;
-	/** Skip Python kernel availability check and warmup */
+	/** Skip subprocess-kernel availability checks and warmup */
 	skipPythonPreflight?: boolean;
 	/** Pre-loaded context files (AGENTS.md, etc) */
 	contextFiles?: ContextFileEntry[];
@@ -202,13 +204,13 @@ export interface ToolSession {
 	requireYieldTool?: boolean;
 	/** Task recursion depth (0 = top-level, 1 = first child, etc.) */
 	taskDepth?: number;
-	/** Get shared eval executor session ID. Subagents inherit this to share JS/Python state. */
+	/** Get shared eval executor session ID. Subagents inherit this to share JS/Python/Ruby/Julia state. */
 	getEvalSessionId?: () => string | null;
 	/** Get session file */
 	getSessionFile: () => string | null;
 	/** Get eval kernel owner ID for session-scoped retained-kernel cleanup. */
 	getEvalKernelOwnerId?: () => string | null;
-	/** Reject new eval (python or js) work once session disposal has started. */
+	/** Reject new eval work once session disposal has started. */
 	assertEvalExecutionAllowed?: () => void;
 	/** Track tool-owned eval work so session disposal can await/abort it like direct session eval runs. */
 	trackEvalExecution?<T>(execution: Promise<T>, abortController: AbortController): Promise<T>;
@@ -486,36 +488,57 @@ export async function createTools(session: ToolSession, toolNames?: string[]): P
 	const backends = resolveEvalBackends(session);
 	const allowPython = backends.python;
 	const allowJs = backends.js;
-	const skipPythonPreflight = session.skipPythonPreflight === true;
-	// Eval tool is enabled if EITHER backend is reachable. We only need to know
-	// whether python is reachable when JS is disabled — otherwise allowEval is
-	// already true and the python-availability check can be deferred to first
-	// invocation of the python backend (already handled inside the executor).
+	const allowRuby = backends.ruby;
+	const allowJulia = backends.julia;
+	const skipEvalPreflight = session.skipPythonPreflight === true;
+	// Eval tool is enabled if ANY backend is reachable. JS needs no preflight, so
+	// we only probe Python/Ruby/Julia when JS is disabled — otherwise allowEval is
+	// already true and per-backend availability is checked at first invocation.
 	let pythonAvailable = true;
-	if (
-		!skipPythonPreflight &&
-		allowPython &&
-		!allowJs &&
-		(requestedTools === undefined || requestedTools.includes("eval"))
-	) {
-		const availability = await logger.time(
-			"createTools:pythonCheck",
-			checkPythonKernelAvailability,
-			session.cwd,
-			session.settings.get("python.interpreter")?.trim() || undefined,
-		);
-		pythonAvailable = availability.ok;
-		if (!availability.ok) {
-			logger.warn("Python kernel unavailable and JS backend disabled; eval will be unavailable", {
-				reason: availability.reason,
-			});
+	let rubyAvailable = true;
+	let juliaAvailable = true;
+	const evalRequested = requestedTools === undefined || requestedTools.includes("eval");
+	if (!skipEvalPreflight && !allowJs && evalRequested) {
+		if (allowPython) {
+			const availability = await logger.time(
+				"createTools:pythonCheck",
+				checkPythonKernelAvailability,
+				session.cwd,
+				session.settings.get("python.interpreter")?.trim() || undefined,
+			);
+			pythonAvailable = availability.ok;
+			if (!availability.ok) {
+				logger.warn("Python kernel unavailable and JS backend disabled", { reason: availability.reason });
+			}
+		}
+		if (allowRuby) {
+			const availability = await checkRubyKernelAvailability(
+				session.cwd,
+				session.settings.get("ruby.interpreter")?.trim() || undefined,
+			);
+			rubyAvailable = availability.ok;
+			if (!availability.ok) {
+				logger.warn("Ruby kernel unavailable and JS backend disabled", { reason: availability.reason });
+			}
+		}
+		if (allowJulia) {
+			const availability = await checkJuliaKernelAvailability(
+				session.cwd,
+				session.settings.get("julia.interpreter")?.trim() || undefined,
+			);
+			juliaAvailable = availability.ok;
+			if (!availability.ok) {
+				logger.warn("Julia kernel unavailable and JS backend disabled", { reason: availability.reason });
+			}
 		}
 	}
 
 	const effectivePythonAllowed = allowPython && pythonAvailable;
-	// Eval is exposed whenever any backend is reachable. The python backend may
-	// be unreachable, in which case eval dispatches exclusively to js.
-	const allowEval = effectivePythonAllowed || allowJs;
+	const effectiveRubyAllowed = allowRuby && rubyAvailable;
+	const effectiveJuliaAllowed = allowJulia && juliaAvailable;
+	// Eval is exposed whenever any backend is reachable. A backend may be
+	// unreachable, in which case eval dispatches exclusively to the others.
+	const allowEval = effectivePythonAllowed || allowJs || effectiveRubyAllowed || effectiveJuliaAllowed;
 
 	// Auto-include AST counterparts when their text-based sibling is present
 	if (requestedTools) {