@prometheus-ai/agent 0.5.4 → 0.5.8

package/src/eval/js/shared/local-module-loader.ts

@@ -102,7 +102,7 @@ export class LocalModuleLoader {
 		});
 		const moduleDir = path.dirname(modulePath);
 		const localDeps = new Set<string>();
-		for (const specifier of collectModuleSourceSpecifiers(stripped)) {
+		for (const specifier of await collectModuleSourceSpecifiers(stripped)) {
 			const resolved = resolveImportSpecifier(moduleDir, specifier);
 			if (isLocalPathSpecifier(specifier) && isManagedLocalModulePath(resolved)) {
 				localDeps.add(resolved);
@@ -291,7 +291,7 @@ function buildRequire(fromPath: string): NodeJS.Require {
 function buildModuleSource(source: string, modulePath: string): string {
 	const moduleDir = path.dirname(modulePath);
 	return [
-		`const require = globalThis.__prometheus_get_require__(${JSON.stringify(pathToFileURL(modulePath).href)});`,
+		`const require = globalThis.__omp_get_require__(${JSON.stringify(pathToFileURL(modulePath).href)});`,
 		`const __filename = ${JSON.stringify(modulePath)};`,
 		`const __dirname = ${JSON.stringify(moduleDir)};`,
 		source,

package/src/eval/js/shared/prelude.txt

@@ -1,17 +1,85 @@
-if (!globalThis.__prometheus_js_prelude_loaded__) {
-	globalThis.__prometheus_js_prelude_loaded__ = true;
+if (!globalThis.__omp_js_prelude_loaded__) {
+	globalThis.__omp_js_prelude_loaded__ = true;
 
-	const toOptions = value => (value && typeof value === "object" && !Array.isArray(value) ? value : {});
-	const callHelper = (name, ...args) => globalThis.__prometheus_helpers__[name](...args);
+	const isNil = value => value === undefined || value === null;
+	const isPlainObject = value => value !== null && typeof value === "object" && !Array.isArray(value);
+	const positionalOptions = (name, args, keys, example) => {
+		for (let index = keys.length; index < args.length; index++) {
+			if (!isNil(args[index])) {
+				throw new TypeError(
+					`${name}() accepts at most ${keys.length} positional optional args; got ${args.length}. Pass ${name}(..., ${example}) for named options.`,
+				);
+			}
+		}
+		const options = {};
+		for (let index = 0; index < keys.length && index < args.length; index++) {
+			const value = args[index];
+			if (!isNil(value)) options[keys[index]] = value;
+		}
+		return options;
+	};
+	const optionsArg = (name, value, rest, keys, example) => {
+		if (isNil(value)) return positionalOptions(name, [value, ...rest], keys, example);
+		if (isPlainObject(value)) {
+			if (rest.some(arg => !isNil(arg))) {
+				throw new TypeError(
+					`${name}() takes either a single trailing options object like ${example} or positional optional args; do not mix both forms.`,
+				);
+			}
+			return value;
+		}
+		if (typeof value === "object") {
+			const kind = Array.isArray(value) ? "an array" : value.constructor?.name ?? "object";
+			throw new TypeError(
+				`${name}() options must be a plain object like ${example}, null/undefined, or positional optional args, not ${kind}.`,
+			);
+		}
+		return positionalOptions(name, [value, ...rest], keys, example);
+	};
+	const callHelper = (name, ...args) => globalThis.__omp_helpers__[name](...args);
+	const hasScheme = path => typeof path === "string" && /^[A-Za-z][A-Za-z0-9+.-]*:\/\//.test(path);
+	const shouldDelegateRead = path => hasScheme(path) && !path.toLowerCase().startsWith("local://");
+	const withReadLineSelector = (path, options) => {
+		const offset = typeof options.offset === "number" ? options.offset : 1;
+		const limit = typeof options.limit === "number" ? options.limit : undefined;
+		if (offset <= 1 && limit === undefined) return path;
+		if (limit !== undefined && limit <= 0) return null;
+		const start = Math.max(1, offset);
+		if (limit === undefined) return `${path}:${start}-`;
+		return `${path}:${start}-${start + limit - 1}`;
+	};
+	const readToolText = async path => {
+		const res = await globalThis.__omp_call_tool__("read", { path });
+		return res && typeof res === "object" && "text" in res ? res.text : res;
+	};
 
-	const read = (path, opts = {}) => callHelper("read", path, toOptions(opts));
+
+	const read = async (path, opts, ...rest) => {
+		const options = optionsArg("read", opts, rest, ["offset", "limit"], "{ offset, limit }");
+		if (shouldDelegateRead(path)) {
+			const toolPath = withReadLineSelector(path, options);
+			return toolPath === null ? "" : readToolText(toolPath);
+		}
+		return callHelper("read", path, options);
+	};
 	const write = async (path, data) => callHelper("writeFile", path, data);
 	const append = (path, content) => callHelper("append", path, content);
-	const sort = (text, opts = {}) => callHelper("sortText", text, toOptions(opts));
-	const uniq = (text, opts = {}) => callHelper("uniqText", text, toOptions(opts));
-	const counter = (items, opts = {}) => callHelper("counter", items, toOptions(opts));
+	const sort = (text, opts, ...rest) =>
+		callHelper("sortText", text, optionsArg("sort", opts, rest, ["reverse", "unique"], "{ reverse, unique }"));
+	const uniq = (text, opts, ...rest) => callHelper("uniqText", text, optionsArg("uniq", opts, rest, ["count"], "{ count }"));
+	const counter = (items, opts, ...rest) =>
+		callHelper("counter", items, optionsArg("counter", opts, rest, ["limit", "reverse"], "{ limit, reverse }"));
 	const diff = (a, b) => callHelper("diff", a, b);
-	const tree = (path = ".", opts = {}) => callHelper("tree", path, toOptions(opts));
+	const tree = (path = ".", opts, ...rest) => {
+		if (isPlainObject(path) && opts === undefined && rest.length === 0) {
+			return callHelper("tree", ".", path);
+		}
+		return callHelper(
+			"tree",
+			isNil(path) ? "." : path,
+			optionsArg("tree", opts, rest, ["maxDepth", "showHidden"], "{ maxDepth, showHidden }"),
+		);
+	};
 	const env = (key, value) => callHelper("env", key, value);
 
 	const tool = new Proxy(
@@ -19,7 +87,7 @@ if (!globalThis.__prometheus_js_prelude_loaded__) {
 		{
 			get(_target, prop) {
 				if (typeof prop !== "string") return undefined;
-				return async args => globalThis.__prometheus_call_tool__(prop, args ?? {});
+				return async args => globalThis.__omp_call_tool__(prop, args ?? {});
 			},
 		},
 	);
@@ -41,16 +109,23 @@ if (!globalThis.__prometheus_js_prelude_loaded__) {
 
 	const hasOwn = (object, key) => Object.prototype.hasOwnProperty.call(object, key);
 
-	const llm = async (prompt, opts = {}) => {
-		const o = toOptions(opts);
-		const res = await globalThis.__prometheus_call_tool__("__llm__", { prompt, ...o });
+	const completion = async (prompt, opts, ...rest) => {
+		const o = optionsArg("completion", opts, rest, ["model", "system", "schema"], "{ model, system, schema }");
+		const res = await globalThis.__omp_call_tool__("__completion__", { prompt, ...o });
 		const text = res && typeof res === "object" ? res.text : res;
 		return hasOwn(o, "schema") ? JSON.parse(text) : text;
 	};
 
-	const agent = async (prompt, opts = {}) => {
-		const o = toOptions(opts);
-		const res = await globalThis.__prometheus_call_tool__("__agent__", { prompt, ...o });
+	const llm = async (prompt, opts, ...rest) => {
+		const o = optionsArg("llm", opts, rest, ["model", "system", "schema"], "{ model, system, schema }");
+		const res = await globalThis.__omp_call_tool__("__llm__", { prompt, ...o });
+		const text = res && typeof res === "object" ? res.text : res;
+		return hasOwn(o, "schema") ? JSON.parse(text) : text;
+	};
+
+	const agent = async (prompt, opts, ...rest) => {
+		const o = optionsArg("agent", opts, rest, ["agentType", "model", "label", "schema"], "{ agentType, model, label, schema }");
+		const res = await globalThis.__omp_call_tool__("__agent__", { prompt, ...o });
 		const text = res && typeof res === "object" ? res.text : res;
 		return hasOwn(o, "schema") ? JSON.parse(text) : text;
 	};
@@ -60,7 +135,7 @@ if (!globalThis.__prometheus_js_prelude_loaded__) {
 	// reply) means unbounded — run every item at once.
 	const __concurrencyLimit = async () => {
 		try {
-			const r = await globalThis.__prometheus_call_tool__("__concurrency__", {});
+			const r = await globalThis.__omp_call_tool__("__concurrency__", {});
 			const n = Math.trunc(Number(r && typeof r === "object" ? r.limit : r));
 			return Number.isFinite(n) && n > 0 ? n : 0;
 		} catch {
@@ -74,15 +149,25 @@ if (!globalThis.__prometheus_js_prelude_loaded__) {
 		const limit = await __concurrencyLimit();
 		const concurrency = limit > 0 ? Math.min(limit, list.length) : list.length;
 		const results = new Array(list.length);
+		// Barrier semantics (mirrors the Python _pool_map): every item settles
+		// before we return or throw, then the lowest-index error propagates.
+		// Early-rejecting would orphan in-flight thunks (e.g. live agent()
+		// subagents) whose worker-side promises would never be observed.
+		const errors = new Map();
 		let next = 0;
 		const worker = async () => {
 			while (true) {
 				const index = next++;
 				if (index >= list.length) return;
-				results[index] = await fn(list[index], index);
+				try {
+					results[index] = await fn(list[index], index);
+				} catch (error) {
+					errors.set(index, error);
+				}
 			}
 		};
 		await Promise.all(Array.from({ length: concurrency }, () => worker()));
+		if (errors.size > 0) throw errors.get(Math.min(...errors.keys()));
 		return results;
 	};
 
@@ -101,15 +186,15 @@ if (!globalThis.__prometheus_js_prelude_loaded__) {
 		return current;
 	};
 
-	const log = message => globalThis.__prometheus_emit_status__("log", { message: String(message) });
+	const log = message => globalThis.__omp_emit_status__("log", { message: String(message) });
 
 	const phase = title => {
-		globalThis.__prometheus_phase__ = String(title);
-		globalThis.__prometheus_emit_status__("phase", { title: String(title) });
+		globalThis.__omp_phase__ = String(title);
+		globalThis.__omp_emit_status__("phase", { title: String(title) });
 	};
 
 	const __budgetSnap = async () => {
-		const r = await globalThis.__prometheus_call_tool__("__budget__", {});
+		const r = await globalThis.__omp_call_tool__("__budget__", {});
 		return r && typeof r === "object" ? r : {};
 	};
 
@@ -127,27 +212,79 @@ if (!globalThis.__prometheus_js_prelude_loaded__) {
 	};
 
 	const display = value => {
-		globalThis.__prometheus_display__(value);
+		globalThis.__omp_display__(value);
 	};
 
 	const formatArgs = args => args.map(arg => (typeof arg === "string" ? arg : arg));
 
+	const consoleTimers = new Map();
+	const consoleCounts = new Map();
 	const consoleBridge = {
-		log: (...args) => globalThis.__prometheus_log__("log", ...formatArgs(args)),
-		info: (...args) => globalThis.__prometheus_log__("info", ...formatArgs(args)),
-		warn: (...args) => globalThis.__prometheus_log__("warn", ...formatArgs(args)),
-		error: (...args) => globalThis.__prometheus_log__("error", ...formatArgs(args)),
-		debug: (...args) => globalThis.__prometheus_log__("debug", ...formatArgs(args)),
+		log: (...args) => globalThis.__omp_log__("log", ...formatArgs(args)),
+		info: (...args) => globalThis.__omp_log__("info", ...formatArgs(args)),
+		warn: (...args) => globalThis.__omp_log__("warn", ...formatArgs(args)),
+		error: (...args) => globalThis.__omp_log__("error", ...formatArgs(args)),
+		debug: (...args) => globalThis.__omp_log__("debug", ...formatArgs(args)),
 		table: (data, columns) =>
 			columns === undefined
-				? globalThis.__prometheus_table__(data)
-				: globalThis.__prometheus_table__(data, columns),
+				? globalThis.__omp_table__(data)
+				: globalThis.__omp_table__(data, columns),
+		dir: (value, _options) => globalThis.__omp_log__("log", value),
+		dirxml: (...args) => globalThis.__omp_log__("log", ...formatArgs(args)),
+		trace: (...args) => {
+			const stack = (new Error().stack ?? "").split("\n").slice(2).join("\n");
+			globalThis.__omp_log__("log", args.length > 0 ? `Trace: ${formatArgs(args).join(" ")}` : "Trace", `\n${stack}`);
+		},
+		assert: (condition, ...args) => {
+			if (condition) return;
+			if (args.length > 0) globalThis.__omp_log__("error", "Assertion failed:", ...formatArgs(args));
+			else globalThis.__omp_log__("error", "Assertion failed");
+		},
+		group: (...args) => {
+			if (args.length > 0) globalThis.__omp_log__("log", ...formatArgs(args));
+		},
+		groupCollapsed: (...args) => {
+			if (args.length > 0) globalThis.__omp_log__("log", ...formatArgs(args));
+		},
+		groupEnd: () => {},
+		time: label => {
+			consoleTimers.set(String(label ?? "default"), Date.now());
+		},
+		timeLog: (label, ...args) => {
+			const key = String(label ?? "default");
+			const start = consoleTimers.get(key);
+			if (start === undefined) {
+				globalThis.__omp_log__("warn", `Timer '${key}' does not exist`);
+				return;
+			}
+			globalThis.__omp_log__("log", `${key}: ${Date.now() - start}ms`, ...formatArgs(args));
+		},
+		timeEnd: label => {
+			const key = String(label ?? "default");
+			const start = consoleTimers.get(key);
+			if (start === undefined) {
+				globalThis.__omp_log__("warn", `Timer '${key}' does not exist`);
+				return;
+			}
+			consoleTimers.delete(key);
+			globalThis.__omp_log__("log", `${key}: ${Date.now() - start}ms`);
+		},
+		count: label => {
+			const key = String(label ?? "default");
+			const next = (consoleCounts.get(key) ?? 0) + 1;
+			consoleCounts.set(key, next);
+			globalThis.__omp_log__("log", `${key}: ${next}`);
+		},
+		countReset: label => {
+			consoleCounts.delete(String(label ?? "default"));
+		},
 	};
 
 	globalThis.console = consoleBridge;
 	globalThis.print = consoleBridge.log;
 	globalThis.display = display;
 	globalThis.tool = tool;
+	globalThis.completion = completion;
 	globalThis.llm = llm;
 	globalThis.output = output;
 	globalThis.agent = agent;

package/src/eval/js/shared/rewrite-imports.ts

@@ -1,9 +1,9 @@
-import { parse as babelParse } from "@babel/parser";
+import type * as BabelParser from "@babel/parser";
 
 // Static ESM `import` declarations are not valid inside vm.runInContext (script-mode parsing),
 // and dynamic `import(...)` would otherwise resolve specifiers against the worker module's URL
 // instead of the session cwd. We rewrite both forms so they route through the worker-injected
-// `__prometheus_import__` helper, which resolves the specifier against the active session cwd. A real
+// `__omp_import__` helper, which resolves the specifier against the active session cwd. A real
 // parser keeps imports embedded in string literals, template literals, or comments intact.
 
 type BabelImportDeclaration = {
@@ -64,9 +64,22 @@ type BabelModuleSourceDeclaration = {
 
 type BabelNode = { type: string; start: number; end: number; [key: string]: unknown };
 
-function parseProgram(code: string): { program: { body: ReadonlyArray<BabelProgramNode> } } | null {
+// @babel/parser sits on the CLI launch graph (tools → eval backend → worker-core →
+// runtime → this module) but only runs when an eval cell executes, so it is loaded
+// lazily and memoized.
+let babelParser: typeof BabelParser | undefined;
+
+async function loadBabelParser(): Promise<typeof BabelParser> {
+	if (!babelParser) {
+		babelParser = await import("@babel/parser");
+	}
+	return babelParser;
+}
+
+async function parseProgram(code: string): Promise<{ program: { body: ReadonlyArray<BabelProgramNode> } } | null> {
+	const { parse } = await loadBabelParser();
 	try {
-		return babelParse(code, {
+		return parse(code, {
 			sourceType: "module",
 			allowAwaitOutsideFunction: true,
 			allowReturnOutsideFunction: true,
@@ -82,12 +95,18 @@ function parseProgram(code: string): { program: { body: ReadonlyArray<BabelProgr
 	}
 }
 
+// Callee substituted for dynamic `import(...)` calls. Functions handed to puppeteer
+// (`tab.evaluate`, `page.evaluate`, `waitForFunction`, `$$eval`, ...) are serialized with
+// `Function.prototype.toString()` and re-evaluated inside the browser page, where the
+// worker-injected `__omp_import__` global does not exist. The swap therefore guards on the
+// helper's presence and falls back to native dynamic import, so serialized code keeps
+// working in foreign realms while in-worker code still resolves against the session cwd.
+const DYNAMIC_IMPORT_CALLEE = '(typeof __omp_import__ === "function" ? __omp_import__ : (s, o) => import(s, o))';
+
 function buildOmpImportCall(sourceLiteral: string, optionsLiteral: string | undefined): string {
-	// Route every static import through the worker-injected `__prometheus_import__` helper so the
+	// Route every static import through the worker-injected `__omp_import__` helper so the
 	// specifier resolves against the session cwd (and `with`-attribute imports keep working).
-	return optionsLiteral
-		? `__prometheus_import__(${sourceLiteral}, ${optionsLiteral})`
-		: `__prometheus_import__(${sourceLiteral})`;
+	return optionsLiteral ? `__omp_import__(${sourceLiteral}, ${optionsLiteral})` : `__omp_import__(${sourceLiteral})`;
 }
 
 // Walks every node in `root`, depth-first, invoking `visit` on each one. Skips Babel's
@@ -119,7 +138,7 @@ function buildOptionsLiteral(node: BabelImportDeclaration): string | undefined {
 		const key = attr.key.type === "Identifier" ? attr.key.name : JSON.stringify(attr.key.value);
 		return `${key}: ${JSON.stringify(attr.value.value)}`;
 	});
-	// Native dynamic import takes options as `{ with: { ... } }`. `__prometheus_import__` forwards the
+	// Native dynamic import takes options as `{ with: { ... } }`. `__omp_import__` forwards the
 	// options bag verbatim, so we wrap the attribute pairs accordingly.
 	return `{ with: { ${pairs.join(", ")} } }`;
 }
@@ -156,10 +175,10 @@ function rewriteImportNode(node: BabelImportDeclaration): string {
 	return `await ${importCall};`;
 }
 
-export function rewriteImports(code: string): string {
+export async function rewriteImports(code: string): Promise<string> {
 	if (!code.includes("import")) return code;
 
-	const ast = parseProgram(code);
+	const ast = await parseProgram(code);
 	if (!ast) {
 		// Parser bailed entirely — let the VM surface the real syntax error.
 		return code;
@@ -168,21 +187,21 @@ export function rewriteImports(code: string): string {
 	type Edit = { start: number; end: number; text: string };
 	const edits: Edit[] = [];
 
-	// Top-level static `import` declarations become `await __prometheus_import__(...)` calls.
+	// Top-level static `import` declarations become `await __omp_import__(...)` calls.
 	for (const node of ast.program.body) {
 		if (node.type !== "ImportDeclaration") continue;
 		const decl = node as unknown as BabelImportDeclaration;
 		edits.push({ start: decl.start, end: decl.end, text: rewriteImportNode(decl) });
 	}
 
-	// Dynamic `import(...)` expressions (anywhere) get their callee swapped for `__prometheus_import__`
+	// Dynamic `import(...)` expressions (anywhere) get their callee swapped for `__omp_import__`
 	// so the specifier resolves against the session cwd instead of the worker module's URL.
 	walkNodes(ast, node => {
 		if (node.type !== "CallExpression") return;
 		const call = node as unknown as { callee?: { type?: string; start?: number; end?: number } };
 		const callee = call.callee;
 		if (callee?.type !== "Import" || typeof callee.start !== "number" || typeof callee.end !== "number") return;
-		edits.push({ start: callee.start, end: callee.end, text: "__prometheus_import__" });
+		edits.push({ start: callee.start, end: callee.end, text: DYNAMIC_IMPORT_CALLEE });
 	});
 
 	if (edits.length === 0) return code;
@@ -195,8 +214,8 @@ export function rewriteImports(code: string): string {
 	}
 	return result;
 }
-export function collectModuleSourceSpecifiers(code: string): string[] {
-	const ast = parseProgram(code);
+export async function collectModuleSourceSpecifiers(code: string): Promise<string[]> {
+	const ast = await parseProgram(code);
 	if (!ast) return [];
 	const sources: string[] = [];
 	for (const node of ast.program.body) {
@@ -212,8 +231,11 @@ export function collectModuleSourceSpecifiers(code: string): string[] {
 	return sources;
 }
 
-export function rewriteModuleSourceSpecifiers(code: string, replacer: (source: string) => string): string {
-	const ast = parseProgram(code);
+export async function rewriteModuleSourceSpecifiers(
+	code: string,
+	replacer: (source: string) => string,
+): Promise<string> {
+	const ast = await parseProgram(code);
 	if (!ast) return code;
 
 	type Edit = { start: number; end: number; text: string };
@@ -243,9 +265,9 @@ export function rewriteModuleSourceSpecifiers(code: string, replacer: (source: s
 	return result;
 }
 
-export function rewriteDynamicImports(code: string, callee = "__prometheus_import__"): string {
+export async function rewriteDynamicImports(code: string, callee = "__omp_import__"): Promise<string> {
 	if (!code.includes("import")) return code;
-	const ast = parseProgram(code);
+	const ast = await parseProgram(code);
 	if (!ast) return code;
 
 	type Edit = { start: number; end: number; text: string };
@@ -333,10 +355,10 @@ function appendGlobalBindingPublish(source: string, names: readonly string[]): s
  * Nested declarations (inside functions, blocks, classes) are left alone \u2014 they're
  * scoped to their enclosing function/block regardless of `var` vs `let`/`const`.
  */
-function demoteTopLevelLexicals(code: string, options: { publishGlobals?: boolean } = {}): string {
+async function demoteTopLevelLexicals(code: string, options: { publishGlobals?: boolean } = {}): Promise<string> {
 	if (!/\b(?:const|let|class)\b/.test(code)) return code;
 
-	const ast = parseProgram(code);
+	const ast = await parseProgram(code);
 	if (!ast) {
 		return code;
 	}
@@ -375,8 +397,8 @@ function demoteTopLevelLexicals(code: string, options: { publishGlobals?: boolea
 	return result;
 }
 
-function returnFinalExpression(code: string): { source: string; returned: boolean } {
-	const ast = parseProgram(code);
+async function returnFinalExpression(code: string): Promise<{ source: string; returned: boolean }> {
+	const ast = await parseProgram(code);
 	const body = ast?.program.body;
 	if (!body) return { source: code, returned: false };
 	let lastIndex = body.length - 1;
@@ -389,18 +411,18 @@ function returnFinalExpression(code: string): { source: string; returned: boolea
 		const suffix = code.slice(expression.end);
 		const semicolonMatch = statement.match(/;\s*$/);
 		const trimmedStatement = semicolonMatch ? statement.slice(0, semicolonMatch.index) : statement;
-		return { source: `${prefix}__prometheus_set_final_expr__((${trimmedStatement}));${suffix}`, returned: true };
+		return { source: `${prefix}__omp_set_final_expr__((${trimmedStatement}));${suffix}`, returned: true };
 	}
 	if (last?.type === "ReturnStatement") {
 		// Top-level `return value;` is otherwise swallowed: it forces the cell into an async IIFE
-		// wrapper that discards the returned value. Rewrite into `__prometheus_set_final_expr__((expr))`
+		// wrapper that discards the returned value. Rewrite into `__omp_set_final_expr__((expr))`
 		// so the runtime can surface the value to the caller just like a trailing expression.
 		const ret = last as unknown as { start: number; end: number; argument?: { start: number; end: number } | null };
 		if (!ret.argument) return { source: code, returned: false };
 		const prefix = code.slice(0, ret.start);
 		const suffix = code.slice(ret.end);
 		const expr = code.slice(ret.argument.start, ret.argument.end);
-		return { source: `${prefix}__prometheus_set_final_expr__((${expr}));${suffix}`, returned: true };
+		return { source: `${prefix}__omp_set_final_expr__((${expr}));${suffix}`, returned: true };
 	}
 	return { source: code, returned: false };
 }
@@ -440,8 +462,8 @@ function containsAsyncWrapperSyntax(value: unknown): boolean {
 	return false;
 }
 
-function requiresAsyncWrapper(code: string): boolean {
-	const ast = parseProgram(code);
+async function requiresAsyncWrapper(code: string): Promise<boolean> {
+	const ast = await parseProgram(code);
 	if (!ast) return false;
 	for (const node of ast.program.body) {
 		if (containsAsyncWrapperSyntax(node)) return true;
@@ -488,13 +510,15 @@ export function stripTypeScriptSyntax(
 const LOOKS_LIKE_TS =
 	/(?:\bimport\s+type\b|\bexport\s+type\b|\b(?:import|export)\s*\{[^}\n]*\btype\s+\w|\binterface\s+\w|\btype\s+\w+\s*=|\b(?:as|satisfies)\s+(?:[A-Z]|\bconst\b)|:\s*(?:string|number|boolean|any|unknown|void|never|object|[A-Z]\w*)\b|<\s*[A-Z]\w*\s*[,>])/;
 
-export function wrapCode(code: string): { source: string; asyncWrapped: boolean; finalExpressionReturned: boolean } {
-	const finalExpression = returnFinalExpression(code);
+export async function wrapCode(
+	code: string,
+): Promise<{ source: string; asyncWrapped: boolean; finalExpressionReturned: boolean }> {
+	const finalExpression = await returnFinalExpression(code);
 	const stripped = stripTypeScript(finalExpression.source);
-	const importsRewritten = rewriteImports(stripped);
-	const needsAsyncWrapper = requiresAsyncWrapper(importsRewritten);
+	const importsRewritten = await rewriteImports(stripped);
+	const needsAsyncWrapper = await requiresAsyncWrapper(importsRewritten);
 	const rewritten = {
-		source: demoteTopLevelLexicals(importsRewritten, { publishGlobals: needsAsyncWrapper }),
+		source: await demoteTopLevelLexicals(importsRewritten, { publishGlobals: needsAsyncWrapper }),
 		returned: finalExpression.returned,
 	};
 	if (!needsAsyncWrapper) {

package/src/eval/js/shared/runtime.ts

@@ -37,11 +37,16 @@ export interface RuntimeOptions {
 	initialCwd: string;
 	sessionId: string;
 	/**
-	 * Extra globals installed alongside `__prometheus_helpers__` / prelude. Use for stable, lifetime-
+	 * Extra globals installed alongside `__omp_helpers__` / prelude. Use for stable, lifetime-
 	 * of-the-worker bindings (e.g. browser's `page`, `browser`). Per-run scope should be set
 	 * via `setRunScope()` instead.
 	 */
 	extraGlobals?: Record<string, unknown>;
+	/**
+	 * On-disk roots the helpers substitute for internal-URL schemes (e.g.
+	 * `{ local: "/…/artifacts/local" }`). Stable for the worker's lifetime.
+	 */
+	localRoots?: Record<string, string>;
 }
 
 // Strict base64: characters from the standard alphabet plus optional `=` padding, and a
@@ -126,15 +131,18 @@ export class JsRuntime {
 	#env: Map<string, string>;
 	#als = new AsyncLocalStorage<RunContext>();
 	#moduleLoader: LocalModuleLoader;
+	#localRoots: Record<string, string>;
 
 	constructor(opts: RuntimeOptions) {
 		this.#cwd = opts.initialCwd;
 		this.sessionId = opts.sessionId;
 		this.#env = new Map();
 		this.#moduleLoader = new LocalModuleLoader(this.sessionId);
+		this.#localRoots = opts.localRoots ?? {};
 		this.helpers = createHelpers({
 			cwd: () => this.#activeCwd(),
 			env: this.#env,
+			localRoots: () => this.#localRoots,
 			emitStatus: event => this.#activeHooks("emitStatus")?.onDisplay({ type: "status", event }),
 		});
 		this.#install(opts.extraGlobals);
@@ -146,7 +154,7 @@ export class JsRuntime {
 
 	setCwd(cwd: string): void {
 		this.#cwd = cwd;
-		const session = (globalThis as { __prometheus_session__?: { cwd?: string } }).__prometheus_session__;
+		const session = (globalThis as { __omp_session__?: { cwd?: string } }).__omp_session__;
 		if (session) session.cwd = cwd;
 	}
 
@@ -173,7 +181,7 @@ export class JsRuntime {
 			finalExpressionValue: undefined,
 		};
 		return await this.#als.run(context, async () => {
-			const wrapped = wrapCode(code);
+			const wrapped = await wrapCode(code);
 			const value = indirectEval(wrapped.source, filename);
 			if (wrapped.finalExpressionReturned) {
 				const awaited = await awaitMaybePromise(value);
@@ -267,38 +275,38 @@ export class JsRuntime {
 
 	#install(extraGlobals: Record<string, unknown> | undefined): void {
 		const injected: Record<string, unknown> = {
-			__prometheus_session__: { cwd: this.#cwd, sessionId: this.sessionId },
-			__prometheus_helpers__: this.helpers,
-			__prometheus_call_tool__: async (name: string, args: unknown) => {
+			__omp_session__: { cwd: this.#cwd, sessionId: this.sessionId },
+			__omp_helpers__: this.helpers,
+			__omp_call_tool__: async (name: string, args: unknown) => {
 				const hooks = this.#activeHooks("tool");
 				if (!hooks) return undefined;
 				return await hooks.callTool(name, args);
 			},
-			__prometheus_import__: async (source: string, options?: ImportCallOptions) => {
+			__omp_import__: async (source: string, options?: ImportCallOptions) => {
 				const resolved = await this.#moduleLoader.resolveForRun(this.#activeCwd(), source);
 				if (resolved.mode === "local") return resolved.value;
 				const target = resolved.target;
 				return options !== undefined ? await import(target, options) : await import(target);
 			},
-			__prometheus_import_from__: async (moduleUrl: string, source: string, options?: ImportCallOptions) => {
+			__omp_import_from__: async (moduleUrl: string, source: string, options?: ImportCallOptions) => {
 				const resolved = await this.#moduleLoader.resolveForModule(moduleUrl, source, this.#activeCwd());
 				if (resolved.mode === "local") return resolved.value;
 				const target = resolved.target;
 				return options !== undefined ? await import(target, options) : await import(target);
 			},
-			__prometheus_get_require__: (moduleUrl?: string) => this.#activeRequire(moduleUrl),
-			__prometheus_get_filename__: (moduleUrl?: string) => this.#moduleFilename(moduleUrl),
-			__prometheus_get_dirname__: (moduleUrl?: string) => this.#moduleDirname(moduleUrl),
-			__prometheus_emit_status__: (op: string, data: Record<string, unknown> = {}) => {
+			__omp_get_require__: (moduleUrl?: string) => this.#activeRequire(moduleUrl),
+			__omp_get_filename__: (moduleUrl?: string) => this.#moduleFilename(moduleUrl),
+			__omp_get_dirname__: (moduleUrl?: string) => this.#moduleDirname(moduleUrl),
+			__omp_emit_status__: (op: string, data: Record<string, unknown> = {}) => {
 				const event: JsStatusEvent = { op, ...data };
 				this.#activeHooks("emitStatus")?.onDisplay({ type: "status", event });
 			},
-			__prometheus_log__: (level: string, ...args: unknown[]) => {
+			__omp_log__: (level: string, ...args: unknown[]) => {
 				const prefix = level === "error" ? "[error] " : level === "warn" ? "[warn] " : "";
 				const text = `${prefix}${formatConsoleArgs(args)}`;
 				this.#activeHooks("log")?.onText(text.endsWith("\n") ? text : `${text}\n`);
 			},
-			__prometheus_table__: (...args: unknown[]) => {
+			__omp_table__: (...args: unknown[]) => {
 				const hooks = this.#activeHooks("table");
 				if (!hooks) return;
 				let buffer = "";
@@ -312,8 +320,8 @@ export class JsRuntime {
 				(tableConsole.table as (...a: unknown[]) => void)(...args);
 				hooks.onText(buffer.endsWith("\n") ? buffer : `${buffer}\n`);
 			},
-			__prometheus_display__: (value: unknown) => this.displayValue(value),
-			__prometheus_set_final_expr__: (value: unknown) => {
+			__omp_display__: (value: unknown) => this.displayValue(value),
+			__omp_set_final_expr__: (value: unknown) => {
 				const context = this.#als.getStore();
 				if (!context) {
 					logger.warn("js runtime final expression set outside an active run");

package/src/eval/js/tool-bridge.ts

@@ -3,6 +3,7 @@ import type { ToolSession } from "../../tools";
 import { ToolError } from "../../tools/tool-errors";
 import { EVAL_AGENT_BRIDGE_NAME, runEvalAgent } from "../agent-bridge";
 import { EVAL_BUDGET_BRIDGE_NAME, type EvalBudgetResult, runEvalBudget } from "../budget-bridge";
+import { EVAL_COMPLETION_BRIDGE_NAME, runEvalCompletion } from "../completion-bridge";
 import { EVAL_CONCURRENCY_BRIDGE_NAME, type EvalConcurrencyResult, runEvalConcurrency } from "../concurrency-bridge";
 import { EVAL_LLM_BRIDGE_NAME, runEvalLlm } from "../llm-bridge";
 import type { JsStatusEvent } from "./shared/types";
@@ -107,6 +108,9 @@ function summarizeToolResult(
 }
 
 export async function callSessionTool(name: string, args: unknown, options: ToolBridgeOptions): Promise<ToolValue> {
+	if (name === EVAL_COMPLETION_BRIDGE_NAME) {
+		return await runEvalCompletion(args, options);
+	}
 	if (name === EVAL_LLM_BRIDGE_NAME) {
 		return await runEvalLlm(args, options);
 	}

package/src/eval/js/worker-core.ts

@@ -71,6 +71,7 @@ export class WorkerCore {
 		this.#runtime = new JsRuntime({
 			initialCwd: snapshot.cwd,
 			sessionId: snapshot.sessionId,
+			localRoots: snapshot.localRoots,
 		});
 		return this.#runtime;
 	}