@langchain/quickjs 0.2.0

package/dist/index.js

@@ -0,0 +1,749 @@
+import { createMiddleware, tool } from "langchain";
+import { z } from "zod/v4";
+import { StateBackend } from "deepagents";
+import dedent from "dedent";
+import { shouldInterruptAfterDeadline } from "quickjs-emscripten";
+import { newQuickJSAsyncWASMModuleFromVariant } from "quickjs-emscripten-core";
+import { compile } from "json-schema-to-typescript";
+import { toJsonSchema } from "@langchain/core/utils/json_schema";
+import { Parser } from "acorn";
+import { tsPlugin } from "@sveltejs/acorn-typescript";
+import { walk } from "estree-walker";
+import MagicString from "magic-string";
+import { getCurrentTaskInput } from "@langchain/langgraph";
+
+//#region src/utils.ts
+/**
+* Convert a snake_case or kebab-case string to camelCase.
+*/
+function toCamelCase(name) {
+	return name.replace(/[-_]([a-z])/g, (_, c) => c.toUpperCase());
+}
+/**
+* Format the result of a REPL evaluation for the agent.
+*/
+function formatReplResult(result) {
+	const parts = [];
+	if (result.logs.length > 0) parts.push(result.logs.join("\n"));
+	if (result.ok) {
+		if (result.value !== void 0) {
+			const formatted = typeof result.value === "string" ? result.value : JSON.stringify(result.value, null, 2);
+			parts.push(`→ ${formatted}`);
+		}
+	} else if (result.error) {
+		const errName = result.error.name || "Error";
+		const errMsg = result.error.message || "Unknown error";
+		parts.push(`${errName}: ${errMsg}`);
+		if (result.error.stack) parts.push(result.error.stack);
+	}
+	return parts.join("\n") || "(no output)";
+}
+function safeToJsonSchema(schema) {
+	try {
+		return toJsonSchema(schema);
+	} catch {
+		return;
+	}
+}
+async function schemaToInterface(jsonSchema, interfaceName) {
+	return (await compile({
+		...jsonSchema,
+		additionalProperties: false
+	}, interfaceName, {
+		bannerComment: "",
+		additionalProperties: false
+	})).replace(/^export /, "").trimEnd();
+}
+function capitalize(s) {
+	return s.charAt(0).toUpperCase() + s.slice(1);
+}
+async function toolToTypeSignature(name, description, jsonSchema) {
+	const inputType = `${capitalize(name)}Input`;
+	if (!jsonSchema || !jsonSchema.properties) return dedent`
+      /**
+       * ${description}
+       */
+      async tools.${name}(input: Record<string, unknown>): Promise<string>
+    `;
+	return dedent`
+    ${await schemaToInterface(jsonSchema, inputType)}
+
+    /**
+     * ${description}
+     */
+    async tools.${name}(input: ${inputType}): Promise<string>
+  `;
+}
+
+//#endregion
+//#region src/transform.ts
+/**
+* AST-based code transform pipeline for the REPL.
+*
+* Transforms TypeScript/JavaScript code into plain JS that can be
+* evaluated inside QuickJS with proper state persistence:
+*
+* 1. Parse with acorn + acorn-typescript (handles TS syntax)
+* 2. Strip TypeScript-only nodes (type annotations, interfaces, etc.)
+* 3. Hoist top-level declarations to globalThis for cross-eval persistence
+* 4. Auto-return the last expression
+* 5. Wrap in async IIFE so top-level await works
+*/
+const TSParser = Parser.extend(tsPlugin());
+/**
+* Transform code for REPL evaluation.
+*
+* - Strips TypeScript syntax
+* - Hoists top-level variable declarations to globalThis
+* - Auto-returns the last expression
+* - Wraps in async IIFE for top-level await support
+*/
+function transformForEval(code) {
+	let ast;
+	try {
+		ast = TSParser.parse(code, {
+			ecmaVersion: "latest",
+			sourceType: "module",
+			locations: true
+		});
+	} catch {
+		return `(async () => {\n${code}\n})()`;
+	}
+	const s = new MagicString(code);
+	const topLevelNodes = ast.body;
+	for (let i = 0; i < topLevelNodes.length; i++) {
+		const node = topLevelNodes[i];
+		if (isTSOnlyNode(node)) {
+			s.remove(node.start, node.end);
+			continue;
+		}
+		if (node.type === "ImportDeclaration" || node.type === "ExportNamedDeclaration" || node.type === "ExportDefaultDeclaration" || node.type === "ExportAllDeclaration") {
+			s.remove(node.start, node.end);
+			continue;
+		}
+		if (node.type === "VariableDeclaration") {
+			hoistDeclaration(s, node);
+			continue;
+		}
+		if (node.type === "FunctionDeclaration" || node.type === "ClassDeclaration") {
+			stripTypeAnnotations(s, node);
+			const name = node.id?.name;
+			if (name) s.appendRight(node.end, `\nglobalThis.${name} = ${name};`);
+			continue;
+		}
+	}
+	for (const node of topLevelNodes) {
+		if (isTSOnlyNode(node)) continue;
+		if (node.type === "ImportDeclaration" || node.type === "ExportNamedDeclaration" || node.type === "ExportDefaultDeclaration" || node.type === "ExportAllDeclaration") continue;
+		if (node.type !== "VariableDeclaration") walk(node, { enter(n) {
+			stripTypeAnnotationFromNode(s, n);
+		} });
+	}
+	const lastNode = findLastNonEmptyNode(topLevelNodes, s);
+	if (lastNode && isExpression(lastNode)) {
+		const { expression } = lastNode;
+		s.prependLeft(lastNode.start, "return (");
+		s.appendRight(expression.end, ")");
+	}
+	s.prepend("(async () => {\n");
+	s.append("\n})()");
+	return s.toString();
+}
+function isTSOnlyNode(node) {
+	const t = node.type;
+	return t === "TSTypeAliasDeclaration" || t === "TSInterfaceDeclaration" || t === "TSEnumDeclaration" || t === "TSModuleDeclaration" || t === "TSDeclareFunction" || t.startsWith("TS");
+}
+/**
+* Rewrite a top-level VariableDeclaration to globalThis assignments.
+*
+* `const x = 1, y = 2` → `globalThis.x = 1; globalThis.y = 2`
+*
+*/
+function hoistDeclaration(s, decl) {
+	const parts = [];
+	for (const d of decl.declarations) {
+		const id = d.id;
+		if (id.type === "Identifier") {
+			const initCode = d.init ? extractCleanInit(s, d) : "undefined";
+			parts.push(`globalThis.${id.name} = ${initCode}`);
+		} else if (id.type === "ObjectPattern" || id.type === "ArrayPattern") {
+			const bindings = extractBindingNames(d.id);
+			const initCode = d.init ? extractCleanInit(s, d) : "undefined";
+			const patternCode = extractCleanSource(s, d.id);
+			parts.push(`var ${patternCode} = ${initCode}`);
+			for (const name of bindings) parts.push(`globalThis.${name} = ${name}`);
+		}
+	}
+	s.overwrite(decl.start, decl.end, parts.join("; ") + ";");
+}
+/**
+* Extract the initializer code, stripping TypeScript annotations from
+* within the expression (e.g. `as Type`, generics, parameter types in
+* arrow functions).
+*/
+function extractCleanInit(s, d) {
+	if (!d.init) return "undefined";
+	return extractCleanSource(s, d.init);
+}
+function extractBindingNames(pattern) {
+	const names = [];
+	if (pattern.type === "Identifier") {
+		if (pattern.name) names.push(pattern.name);
+	} else if (pattern.type === "ObjectPattern") for (const prop of pattern.properties || []) if (prop.type === "RestElement") names.push(...extractBindingNames(prop.argument));
+	else names.push(...extractBindingNames(prop.value));
+	else if (pattern.type === "ArrayPattern") {
+		for (const el of pattern.elements || []) if (el) names.push(...extractBindingNames(el));
+	} else if (pattern.type === "RestElement") names.push(...extractBindingNames(pattern.argument));
+	else if (pattern.type === "AssignmentPattern") names.push(...extractBindingNames(pattern.left));
+	return names;
+}
+function stripTypeAnnotations(s, node) {
+	walk(node, { enter(n) {
+		stripTypeAnnotationFromNode(s, n);
+	} });
+}
+function stripTypeAnnotationFromNode(s, n, offset = 0) {
+	if (n.typeAnnotation && n.typeAnnotation.start != null) s.remove(n.typeAnnotation.start - offset, n.typeAnnotation.end - offset);
+	if (n.returnType && n.returnType.start != null) s.remove(n.returnType.start - offset, n.returnType.end - offset);
+	if (n.typeParameters && n.typeParameters.start != null) s.remove(n.typeParameters.start - offset, n.typeParameters.end - offset);
+	if (n.typeArguments && n.typeArguments.start != null) s.remove(n.typeArguments.start - offset, n.typeArguments.end - offset);
+	if (n.type === "TSAsExpression" && n.expression) s.remove(n.expression.end - offset, n.end - offset);
+	if (n.type === "TSNonNullExpression" && n.expression) s.remove(n.expression.end - offset, n.end - offset);
+	if (n.type === "TSSatisfiesExpression" && n.expression) s.remove(n.expression.end - offset, n.end - offset);
+}
+/**
+* Extract a clean JS source string from an AST node, stripping all
+* TypeScript annotations. Works on a copy so the main MagicString is
+* not mutated.
+*/
+function extractCleanSource(s, node) {
+	const offset = node.start;
+	const source = new MagicString(s.slice(node.start, node.end));
+	walk(node, { enter(n) {
+		stripTypeAnnotationFromNode(source, n, offset);
+	} });
+	return source.toString();
+}
+function findLastNonEmptyNode(nodes, s) {
+	for (let i = nodes.length - 1; i >= 0; i--) {
+		const node = nodes[i];
+		const slice = s.slice(node.start, node.end).trim();
+		if (slice === "" || slice === ";") continue;
+		return node;
+	}
+	return null;
+}
+function isExpression(node) {
+	return node.type === "ExpressionStatement";
+}
+
+//#endregion
+//#region src/session.ts
+/**
+* Core REPL engine built on quickjs-emscripten (asyncify variant).
+*
+* Host async functions (backend I/O, PTC tools) are exposed as
+* promise-returning functions inside the QuickJS guest. Guest code
+* uses `await` to consume them, enabling real concurrency via
+* `Promise.all`, `Promise.race`, etc.
+*
+* We still use the asyncify WASM variant because `evalCodeAsync` is
+* required to drive promise resolution from the host side.
+*
+* ## Architecture
+*
+* `ReplSession` is a serializable handle that can live in LangGraph state.
+* It holds an `id` that keys into a static session map. The heavy QuickJS
+* runtime is lazily started on the first `.eval()` call, making the session
+* safe across graph interrupts and checkpointing.
+*
+* File writes inside the REPL are buffered (`pendingWrites`) and only
+* flushed to the backend after a script finishes executing. Call
+* `session.flushWrites(backend)` after eval to persist them.
+*/
+const DEFAULT_MEMORY_LIMIT = 50 * 1024 * 1024;
+const DEFAULT_MAX_STACK_SIZE = 320 * 1024;
+const DEFAULT_EXECUTION_TIMEOUT = 3e4;
+const DEFAULT_SESSION_ID = "__default__";
+let asyncModulePromise;
+async function getAsyncModule() {
+	if (!asyncModulePromise) asyncModulePromise = (async () => {
+		const variant = await import("@jitl/quickjs-ng-wasmfile-release-asyncify");
+		return newQuickJSAsyncWASMModuleFromVariant(variant.default ?? variant);
+	})();
+	return asyncModulePromise;
+}
+/**
+* Sandboxed JavaScript REPL session backed by QuickJS WASM.
+*
+* Serializable — holds an `id` that keys into a static session map.
+* The QuickJS runtime is lazily started on the first `.eval()` call
+* and reconnected if a session with the same id already exists.
+* This makes it safe to store in LangGraph state across interrupts.
+*
+* File writes are buffered during execution and flushed via
+* `flushWrites(backend)` after eval completes.
+*/
+var ReplSession = class ReplSession {
+	static sessions = /* @__PURE__ */ new Map();
+	id;
+	pendingWrites = [];
+	runtime = null;
+	context = null;
+	logs = [];
+	_options;
+	_backend = null;
+	constructor(id, options = {}) {
+		this.id = id;
+		this._options = options;
+	}
+	get backend() {
+		return this._backend;
+	}
+	set backend(b) {
+		this._backend = b;
+	}
+	async ensureStarted() {
+		if (this.runtime) return;
+		const { memoryLimitBytes = DEFAULT_MEMORY_LIMIT, maxStackSizeBytes = DEFAULT_MAX_STACK_SIZE, backend, tools } = this._options;
+		const runtime = (await getAsyncModule()).newRuntime();
+		runtime.setMemoryLimit(memoryLimitBytes);
+		runtime.setMaxStackSize(maxStackSizeBytes);
+		const context = runtime.newContext();
+		this.runtime = runtime;
+		this.context = context;
+		this.setupConsole();
+		if (backend) this._backend = backend;
+		this.injectVfs();
+		if (tools && tools.length > 0) this.injectTools(tools);
+	}
+	/**
+	* Get or create a session for the given id.
+	*
+	* Sessions are deduped by id — calling `getOrCreate` twice with the
+	* same id returns the same instance. The QuickJS runtime is lazily
+	* started on the first `.eval()` call.
+	*/
+	static getOrCreate(id, options = {}) {
+		const existing = ReplSession.sessions.get(id);
+		if (existing) {
+			if (options.backend) existing._backend = options.backend;
+			return existing;
+		}
+		const session = new ReplSession(id, options);
+		ReplSession.sessions.set(id, session);
+		return session;
+	}
+	/**
+	* Retrieve an existing session by id, or null if none exists.
+	*/
+	static get(id) {
+		return ReplSession.sessions.get(id) ?? null;
+	}
+	/**
+	* Evaluate code in this session.
+	*
+	* Lazily starts the QuickJS runtime on the first call. Code is
+	* transformed via an AST pipeline that strips TypeScript syntax,
+	* hoists top-level declarations to globalThis for cross-eval
+	* persistence, auto-returns the last expression, and wraps in an
+	* async IIFE.
+	*/
+	async eval(code, timeoutMs) {
+		await this.ensureStarted();
+		const runtime = this.runtime;
+		const context = this.context;
+		this.logs.length = 0;
+		if (timeoutMs >= 0) runtime.setInterruptHandler(shouldInterruptAfterDeadline(Date.now() + timeoutMs));
+		else runtime.setInterruptHandler(() => false);
+		const transformed = transformForEval(code);
+		const result = await context.evalCodeAsync(transformed);
+		if (result.error) {
+			const error = context.dump(result.error);
+			result.error.dispose();
+			return {
+				ok: false,
+				error,
+				logs: [...this.logs]
+			};
+		}
+		const promiseState = context.getPromiseState(result.value);
+		if (promiseState.type === "fulfilled") {
+			if (promiseState.notAPromise) {
+				const value = context.dump(result.value);
+				result.value.dispose();
+				return {
+					ok: true,
+					value,
+					logs: [...this.logs]
+				};
+			}
+			const value = context.dump(promiseState.value);
+			promiseState.value.dispose();
+			result.value.dispose();
+			return {
+				ok: true,
+				value,
+				logs: [...this.logs]
+			};
+		}
+		if (promiseState.type === "rejected") {
+			const error = context.dump(promiseState.error);
+			promiseState.error.dispose();
+			result.value.dispose();
+			return {
+				ok: false,
+				error,
+				logs: [...this.logs]
+			};
+		}
+		const noTimeout = timeoutMs < 0;
+		const deadline = noTimeout ? Infinity : Date.now() + timeoutMs;
+		while (noTimeout || Date.now() < deadline) {
+			context.runtime.executePendingJobs();
+			const state = context.getPromiseState(result.value);
+			if (state.type === "fulfilled") {
+				const value = context.dump(state.value);
+				state.value.dispose();
+				result.value.dispose();
+				return {
+					ok: true,
+					value,
+					logs: [...this.logs]
+				};
+			}
+			if (state.type === "rejected") {
+				const error = context.dump(state.error);
+				state.error.dispose();
+				result.value.dispose();
+				return {
+					ok: false,
+					error,
+					logs: [...this.logs]
+				};
+			}
+			await new Promise((r) => setTimeout(r, 1));
+		}
+		result.value.dispose();
+		return {
+			ok: false,
+			error: { message: "Promise timed out — execution interrupted" },
+			logs: [...this.logs]
+		};
+	}
+	async flushWrites(backend) {
+		const writes = this.pendingWrites.splice(0);
+		for (const { path, content } of writes) await backend.write(path, content);
+	}
+	dispose() {
+		try {
+			this.context?.dispose();
+		} catch {}
+		try {
+			this.runtime?.dispose();
+		} catch {}
+		this.runtime = null;
+		this.context = null;
+		ReplSession.sessions.delete(this.id);
+	}
+	toJSON() {
+		return { id: this.id };
+	}
+	static fromJSON(data) {
+		return ReplSession.sessions.get(data.id) ?? new ReplSession(data.id);
+	}
+	/**
+	* Clear the static session cache. Useful for testing.
+	* @internal
+	*/
+	static clearCache() {
+		for (const session of ReplSession.sessions.values()) session.dispose();
+		ReplSession.sessions.clear();
+	}
+	setupConsole() {
+		const context = this.context;
+		const logs = this.logs;
+		const consoleHandle = context.newObject();
+		for (const method of [
+			"log",
+			"warn",
+			"error",
+			"info",
+			"debug"
+		]) {
+			const fnHandle = context.newFunction(method, (...args) => {
+				const formatted = args.map((a) => context.dump(a)).map((a) => typeof a === "object" && a !== null ? JSON.stringify(a) : String(a)).join(" ");
+				logs.push(method === "log" || method === "info" || method === "debug" ? formatted : `[${method}] ${formatted}`);
+			});
+			context.setProp(consoleHandle, method, fnHandle);
+			fnHandle.dispose();
+		}
+		context.setProp(context.global, "console", consoleHandle);
+		consoleHandle.dispose();
+	}
+	injectVfs() {
+		const context = this.context;
+		const getBackend = () => this._backend;
+		const { pendingWrites } = this;
+		const readFileHandle = context.newFunction("readFile", (pathHandle) => {
+			const backend = getBackend();
+			if (!backend) {
+				const promise = context.newPromise();
+				const err = context.newError("Backend not available");
+				promise.reject(err);
+				err.dispose();
+				promise.settled.then(context.runtime.executePendingJobs);
+				return promise.handle;
+			}
+			const path = context.getString(pathHandle);
+			const promise = context.newPromise();
+			(async () => {
+				try {
+					const fileData = await backend.readRaw(path);
+					const val = context.newString(fileData.content.join("\n"));
+					promise.resolve(val);
+					val.dispose();
+				} catch {
+					const err = context.newError(`ENOENT: no such file or directory '${path}'.`);
+					promise.reject(err);
+					err.dispose();
+				}
+				promise.settled.then(context.runtime.executePendingJobs);
+			})();
+			return promise.handle;
+		});
+		context.setProp(context.global, "readFile", readFileHandle);
+		readFileHandle.dispose();
+		const writeFileHandle = context.newFunction("writeFile", (pathHandle, contentHandle) => {
+			const path = context.getString(pathHandle);
+			const content = context.getString(contentHandle);
+			const promise = context.newPromise();
+			pendingWrites.push({
+				path,
+				content
+			});
+			promise.resolve(context.undefined);
+			promise.settled.then(context.runtime.executePendingJobs);
+			return promise.handle;
+		});
+		context.setProp(context.global, "writeFile", writeFileHandle);
+		writeFileHandle.dispose();
+	}
+	injectTools(tools) {
+		const context = this.context;
+		const toolsNs = context.newObject();
+		for (const t of tools) {
+			const camelName = toCamelCase(t.name);
+			const fnHandle = context.newFunction(camelName, (inputHandle) => {
+				const input = context.dump(inputHandle);
+				const promise = context.newPromise();
+				(async () => {
+					try {
+						const rawInput = typeof input === "object" && input !== null ? input : {};
+						const result = await t.invoke(rawInput);
+						const val = context.newString(typeof result === "string" ? result : JSON.stringify(result));
+						promise.resolve(val);
+						val.dispose();
+					} catch (e) {
+						const msg = e != null && typeof e.message === "string" ? e.message : String(e);
+						const err = context.newError(`Tool '${t.name}' failed: ${msg}`);
+						promise.reject(err);
+						err.dispose();
+					}
+					promise.settled.then(context.runtime.executePendingJobs);
+				})();
+				return promise.handle;
+			});
+			context.setProp(toolsNs, camelName, fnHandle);
+			fnHandle.dispose();
+		}
+		context.setProp(context.global, "tools", toolsNs);
+		toolsNs.dispose();
+	}
+};
+
+//#endregion
+//#region src/middleware.ts
+/**
+* QuickJS REPL middleware for deepagents.
+*
+* Provides a `js_eval` tool that runs JavaScript in a WASM-sandboxed QuickJS
+* interpreter. Supports:
+* - Persistent state across evaluations (true REPL)
+* - VFS integration via readFile/writeFile
+* - Programmatic tool calling (PTC)
+*/
+/**
+* Backend-provided tools excluded from PTC by default.
+* These are redundant inside the REPL since VFS helpers (readFile/writeFile)
+* already cover file I/O against the agent's in-memory working set.
+*/
+const DEFAULT_PTC_EXCLUDED_TOOLS = [
+	"ls",
+	"read_file",
+	"write_file",
+	"edit_file",
+	"glob",
+	"grep",
+	"execute"
+];
+const REPL_SYSTEM_PROMPT = dedent`
+  ## TypeScript/JavaScript REPL (\`js_eval\`)
+
+  You have access to a sandboxed TypeScript/JavaScript REPL running in an isolated interpreter.
+  TypeScript syntax (type annotations, interfaces, generics, \`as\` casts) is supported and stripped at evaluation time.
+  Variables, functions, and closures persist across calls within the same session.
+
+  ### Hard rules
+
+  - **No network, no filesystem** — only the helpers below. Do not attempt \`fetch\`, \`require\`, or \`import\`.
+  - **Cite your sources** — when reporting values from files, include the path and key/index so the user can verify.
+  - **Use console.log()** for output — it is captured and returned. \`console.warn()\` and \`console.error()\` are also available.
+  - **Reuse state from previous cells** — variables, functions, and results from earlier \`js_eval\` calls persist across calls. Reference them by name in follow-up cells instead of re-embedding data as inline JSON literals.
+
+  ### First-time usage
+
+  \`\`\`typescript
+  // Read a file from the agent's virtual filesystem
+  const raw: string = await readFile("/data.json");
+  const data = JSON.parse(raw) as { n: number };
+  console.log(data);
+
+  // Write results back
+  await writeFile("/output.txt", JSON.stringify({ result: data.n }));
+  \`\`\`
+
+  ### API Reference — built-in globals
+
+  \`\`\`typescript
+  /**
+   * Read a file from the agent's virtual filesystem. Throws if the file does not exist.
+   */
+  async readFile(path: string): Promise<string>
+
+  /**
+   * Write a file to the agent's virtual filesystem.
+   */
+  async writeFile(path: string, content: string): Promise<void>
+  \`\`\`
+
+  ### Limitations
+
+  - ES2023+ syntax with TypeScript support. No Node.js APIs, no \`require\`, no \`import\`.
+  - Output is truncated beyond a fixed character limit — be selective about what you log.
+  - Execution timeout per call (default 30 s).
+`;
+/**
+* Generate the PTC API Reference section for the system prompt.
+*/
+async function generatePtcPrompt(tools) {
+	if (tools.length === 0) return "";
+	return dedent`
+
+    ### API Reference — \`tools\` namespace
+
+    The following agent tools are callable as async functions inside the REPL.
+    Each takes a single object argument and returns a Promise that resolves to a string.
+    Use \`await\` to call them. Promise APIs like \`Promise.all\` are also available.
+
+    **Example usage:**
+    \`\`\`javascript
+    // Call a tool
+    const result = await tools.searchWeb({ query: "QuickJS tutorial" });
+    console.log(result);
+
+    // Concurrent calls
+    const [a, b] = await Promise.all([
+      tools.fetchData({ url: "https://api.example.com/a" }),
+      tools.fetchData({ url: "https://api.example.com/b" }),
+    ]);
+    \`\`\`
+
+    **Available functions:**
+    \`\`\`typescript
+    ${(await Promise.all(tools.map((t) => {
+		const jsonSchema = t.schema ? safeToJsonSchema(t.schema) : void 0;
+		return toolToTypeSignature(toCamelCase(t.name), t.description, jsonSchema);
+	}))).join("\n\n")}
+    \`\`\`
+  `;
+}
+/**
+* Resolve backend from factory or instance.
+*/
+function getBackend(backend, stateAndStore) {
+	if (typeof backend === "function") return backend(stateAndStore);
+	return backend;
+}
+/**
+* Create the QuickJS REPL middleware.
+*/
+function createQuickJSMiddleware(options = {}) {
+	const { backend = (stateAndStore) => new StateBackend(stateAndStore), ptc = false, memoryLimitBytes = DEFAULT_MEMORY_LIMIT, maxStackSizeBytes = DEFAULT_MAX_STACK_SIZE, executionTimeoutMs = DEFAULT_EXECUTION_TIMEOUT, systemPrompt: customSystemPrompt = null } = options;
+	const usePtc = ptc !== false;
+	const baseSystemPrompt = customSystemPrompt || REPL_SYSTEM_PROMPT;
+	let cachedPtcPrompt = null;
+	let ptcTools = [];
+	function filterToolsForPtc(allTools) {
+		if (ptc === false) return [];
+		const candidates = allTools.filter((t) => t.name !== "js_eval");
+		if (ptc === true) {
+			const excluded = new Set(DEFAULT_PTC_EXCLUDED_TOOLS);
+			return candidates.filter((t) => !excluded.has(t.name));
+		}
+		if (Array.isArray(ptc)) {
+			const included = new Set(ptc);
+			return candidates.filter((t) => included.has(t.name));
+		}
+		if ("include" in ptc) {
+			const included = new Set(ptc.include);
+			return candidates.filter((t) => included.has(t.name));
+		}
+		if ("exclude" in ptc) {
+			const excluded = new Set([...DEFAULT_PTC_EXCLUDED_TOOLS, ...ptc.exclude]);
+			return candidates.filter((t) => !excluded.has(t.name));
+		}
+		return [];
+	}
+	return createMiddleware({
+		name: "QuickJSMiddleware",
+		tools: [tool(async (input, config) => {
+			const threadId = config.configurable?.thread_id || DEFAULT_SESSION_ID;
+			const resolvedBackend = getBackend(backend, {
+				state: getCurrentTaskInput(config) || {},
+				store: config.configurable?.__pregel_store
+			});
+			const session = ReplSession.getOrCreate(threadId, {
+				memoryLimitBytes,
+				maxStackSizeBytes,
+				backend: resolvedBackend,
+				tools: ptcTools
+			});
+			const result = await session.eval(input.code, executionTimeoutMs);
+			await session.flushWrites(resolvedBackend);
+			return formatReplResult(result);
+		}, {
+			name: "js_eval",
+			description: dedent`
+        Evaluate TypeScript/JavaScript code in a sandboxed REPL. State persists across calls.
+        Use readFile(path) and writeFile(path, content) for file access.
+        Use console.log() for output. Returns the result of the last expression.
+      `,
+			schema: z.object({ code: z.string().describe("TypeScript/JavaScript code to evaluate in the sandboxed REPL") })
+		})],
+		wrapModelCall: async (request, handler) => {
+			const agentTools = request.tools || [];
+			ptcTools = usePtc ? filterToolsForPtc(agentTools) : [];
+			if (ptcTools.length > 0 && !cachedPtcPrompt) cachedPtcPrompt = await generatePtcPrompt(ptcTools);
+			const systemMessage = request.systemMessage.concat(baseSystemPrompt).concat(cachedPtcPrompt || "");
+			return handler({
+				...request,
+				systemMessage
+			});
+		}
+	});
+}
+
+//#endregion
+export { DEFAULT_EXECUTION_TIMEOUT, DEFAULT_MAX_STACK_SIZE, DEFAULT_MEMORY_LIMIT, DEFAULT_PTC_EXCLUDED_TOOLS, ReplSession, createQuickJSMiddleware, formatReplResult, toCamelCase, transformForEval };
+//# sourceMappingURL=index.js.map