@langchain/quickjs 0.3.0 → 0.5.0

package/dist/index.js

@@ -1,17 +1,100 @@
 import { createMiddleware, tool } from "langchain";
 import { z } from "zod/v4";
+import { SUBAGENT_RESPONSE_FORMAT_CONFIG_KEY } from "deepagents";
 import dedent from "dedent";
-import { getCurrentTaskInput } from "@langchain/langgraph";
-import { adaptBackendProtocol, resolveBackend } from "deepagents";
 import { shouldInterruptAfterDeadline } from "quickjs-emscripten";
 import { newQuickJSAsyncWASMModuleFromVariant } from "quickjs-emscripten-core";
-import * as posix from "node:path/posix";
+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 { compile } from "json-schema-to-typescript";
-import { toJsonSchema } from "@langchain/core/utils/json_schema";
+import PQueue from "p-queue";
+//#region src/errors.ts
+/**
+* Thrown when a single eval exhausts its configured PTC call budget.
+*/
+var PTCCallBudgetExceededError = class extends Error {
+	limit;
+	attempted;
+	functionName;
+	constructor(options) {
+		super(`PTC call budget exceeded (limit=${options.limit}, attempted=${options.attempted}, function=${options.functionName})`);
+		this.name = "PTCCallBudgetExceededError";
+		this.limit = options.limit;
+		this.attempted = options.attempted;
+		this.functionName = options.functionName;
+	}
+};
+//#endregion
+//#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) {
+		let logsText = result.logs.join("\n");
+		if (result.logsDroppedChars > 0) logsText += `\n[truncated ${result.logsDroppedChars} chars]`;
+		parts.push(logsText);
+	}
+	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.
@@ -87,7 +170,11 @@ function transformForEval(code) {
 }
 function isTSOnlyNode(node) {
 	const t = node.type;
-	return t === "TSTypeAliasDeclaration" || t === "TSInterfaceDeclaration" || t === "TSEnumDeclaration" || t === "TSModuleDeclaration" || t === "TSDeclareFunction" || t.startsWith("TS");
+	if (t === "TSTypeAliasDeclaration" || t === "TSInterfaceDeclaration" || t === "TSEnumDeclaration" || t === "TSModuleDeclaration" || t === "TSDeclareFunction" || t.startsWith("TS")) return true;
+	if (t === "VariableDeclaration" && node.declare === true) return true;
+	if (t === "ImportDeclaration" && node.importKind === "type") return true;
+	if (t === "ExportNamedDeclaration" && node.exportKind === "type") return true;
+	return false;
 }
 /**
 * Rewrite a top-level VariableDeclaration to globalThis assignments.
@@ -139,7 +226,11 @@ function stripTypeAnnotations(s, node) {
 	} });
 }
 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.optional === true && n.typeAnnotation && n.typeAnnotation.start != null) s.remove(n.typeAnnotation.start - 1 - offset, n.typeAnnotation.end - offset);
+	else if (n.optional === true && !n.typeAnnotation) {
+		const nameEnd = n.type === "Identifier" && typeof n.name === "string" ? n.start + n.name.length : null;
+		if (nameEnd != null) s.remove(nameEnd - offset, nameEnd + 1 - offset);
+	} else 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);
@@ -205,228 +296,38 @@ function stripTypeSyntax(code) {
 	return magicString.toString();
 }
 //#endregion
-//#region src/skills.ts
-/**
-* File extensions the loader will enumerate from a skill directory.
-*/
-const SKILL_MODULE_EXTENSIONS = [
-	".js",
-	".mjs",
-	".cjs",
-	".ts",
-	".mts",
-	".cts",
-	".jsx",
-	".tsx"
-];
-/**
-* Hard cap on total bytes pulled for one skill's bundle (1 MiB).
-*/
-const MAX_SKILL_BUNDLE_BYTES = 1 * 1024 * 1024;
-/**
-* Validates a skill name against the spec's kebab-case rule.
-*/
-const SKILL_NAME_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
-/**
-* Matches `"@/skills/<name>"` or `'@/skills/<name>'` references in source.
-* Template literals and computed specifiers are not caught.
-*/
-const SKILL_SPECIFIER_RE = /["']@\/skills\/([a-z0-9]+(?:-[a-z0-9]+)*)["']/g;
-/**
-* List every code-extension file under `skillDir` (recursive).
-*/
-async function enumerateCodeFiles(backend, skillDir, skillName) {
-	const seen = /* @__PURE__ */ new Set();
-	for (const ext of SKILL_MODULE_EXTENSIONS) {
-		const result = await backend.glob(`**/*${ext}`, skillDir);
-		if (result.error !== void 0) throw new Error(`Skill '${skillName}': failed to list '${skillDir}': ${result.error}`);
-		const matches = result.files ?? [];
-		for (const match of matches) seen.add(match.path);
-	}
-	return [...seen].sort();
-}
-/**
-* Decode download responses into [path, source] pairs.
-*/
-function decodeFiles(responses, skillName) {
-	const decoder = new TextDecoder("utf-8", { fatal: true });
-	const pairs = [];
-	for (const response of responses) {
-		if (response.error !== null || response.content === null) throw new Error(`Skill '${skillName}': failed to download '${response.path}': ${response.error ?? "no content"}`);
-		let source;
-		try {
-			source = decoder.decode(response.content);
-		} catch {
-			throw new Error(`Skill '${skillName}': file '${response.path}' is not valid UTF-8`);
-		}
-		pairs.push([response.path, source]);
-	}
-	return pairs;
-}
-/**
-* Throws an Error when the total decoded size of all files exceeds
-* `MAX_SKILL_BUNDLE_BYTES`. Counts characters rather than bytes, which
-* over-counts multi-byte UTF-8. Intentionally errs toward rejection.
-*/
-function validateBundleSize(pairs, skillName) {
-	let total = 0;
-	for (const [, source] of pairs) total += source.length;
-	if (total > 1048576) throw new Error(`Skill '${skillName}': bundle exceeds ${MAX_SKILL_BUNDLE_BYTES} bytes (total ${total})`);
-}
+//#region src/eval-queue.ts
 /**
-* Express `absolutePath` as a POSIX-relative path under `skillDir`.
-* Throws an Error if the path escapes the skill directory which indicates
-* a backend bug, not a user error.
-*/
-function relativeUnder(skillDir, absolutePath, skillName) {
-	const rel = posix.relative(skillDir, absolutePath);
-	if (rel === "" || rel.startsWith("..")) throw new Error(`Skill '${skillName}': file ${absolutePath} is not under '${skillDir}'`);
-	return rel;
-}
-/**
-* Build the relative-path → source map, applying `stripTypeSyntax` to each file.
-*/
-function buildFilesMap(skillDir, entryRel, pairs, skillName) {
-	const files = /* @__PURE__ */ new Map();
-	let entryPresent = false;
-	for (const [absPath, source] of pairs) {
-		const rel = relativeUnder(skillDir, absPath, skillName);
-		files.set(rel, stripTypeSyntax(source));
-		if (rel === entryRel) entryPresent = true;
-	}
-	if (!entryPresent) throw new Error(`Skill '${skillName}': module path '${entryRel}' did not match any file in the skill directory`);
-	return files;
-}
-/**
-* Build a `LoadedSkill` from a skill's metadata and a backend handle.
-*
-* Enumerates code files under the skill directory, downloads them,
-* strips TypeScript syntax, and validates the entrypoint is present.
-*/
-async function loadSkill(metadata, backend) {
-	const name = metadata.name;
-	if (!SKILL_NAME_RE.test(name)) throw new Error(`Skill name '${name}' is not a valid kebab-case identifier`);
-	const entryRel = metadata.module;
-	if (entryRel === void 0 || entryRel === "") throw new Error(`Skill '${name}' has no 'module' frontmatter key - only skills with a declared entrypoint are installable`);
-	const adapted = adaptBackendProtocol(backend);
-	if (adapted.downloadFiles === void 0) throw new Error(`Skill '${name}': backend does not implement downloadFiles`);
-	const skillDir = posix.dirname(metadata.path);
-	const codeFiles = await enumerateCodeFiles(adapted, skillDir, name);
-	if (codeFiles.length === 0) throw new Error(`Skill '${name}': no JS/TS files under '${skillDir}'`);
-	const filePairs = decodeFiles(await adapted.downloadFiles(codeFiles), name);
-	validateBundleSize(filePairs, name);
-	const files = buildFilesMap(skillDir, entryRel, filePairs, name);
-	return {
-		name,
-		specifier: `@/skills/${name}`,
-		entryRel,
-		files
-	};
-}
-/**
-* Extract skill names referenced by `"@/skills/<name>"` literals in source.
+* Serializes async operations on a shared WASM module.
 *
-* Used as a pre-eval scan so the middleware can surface `SkillNotAvailable`
-* before evaluation starts. Dynamic imports with computed specifiers are
-* not detected.
+* The quickjs-emscripten asyncify variant allows only one concurrent
+* async call per module instance. This queue enforces that constraint
+* by chaining operations into a promise queue — each caller waits for
+* the previous one to finish before executing.
 */
-function scanSkillReferences(source) {
-	const names = /* @__PURE__ */ new Set();
-	const matches = source.matchAll(SKILL_SPECIFIER_RE);
-	for (const match of matches) names.add(match[1]);
-	return names;
-}
-//#endregion
-//#region src/errors.ts
-/**
-* Thrown when a single eval exhausts its configured PTC call budget.
-*/
-var PTCCallBudgetExceededError = class extends Error {
-	limit;
-	attempted;
-	functionName;
-	constructor(options) {
-		super(`PTC call budget exceeded (limit=${options.limit}, attempted=${options.attempted}, function=${options.functionName})`);
-		this.name = "PTCCallBudgetExceededError";
-		this.limit = options.limit;
-		this.attempted = options.attempted;
-		this.functionName = options.functionName;
+var AsyncEvalQueue = class {
+	tail = Promise.resolve();
+	/**
+	* Enqueue an async operation. The operation will not start until all
+	* previously enqueued operations have completed.
+	*/
+	async enqueue(fn) {
+		let release;
+		const gate = new Promise((r) => {
+			release = r;
+		});
+		const prev = this.tail;
+		this.tail = gate;
+		return prev.then(async () => {
+			try {
+				return await fn();
+			} finally {
+				release();
+			}
+		});
 	}
 };
 //#endregion
-//#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) {
-		let logsText = result.logs.join("\n");
-		if (result.logsDroppedChars > 0) logsText += `\n[truncated ${result.logsDroppedChars} chars]`;
-		parts.push(logsText);
-	}
-	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>
-  `;
-}
-/**
-* Render a pre-eval error when referenced skills are not available on the agent.
-*/
-function formatSkillNotAvailable(missing) {
-	return `Skills unavailable: ${[...missing].sort().join(", ")}`;
-}
-//#endregion
 //#region src/session.ts
 /**
 * Core REPL engine built on quickjs-emscripten (asyncify variant).
@@ -451,64 +352,78 @@ const DEFAULT_MAX_STACK_SIZE = 320 * 1024;
 const DEFAULT_EXECUTION_TIMEOUT = 5e3;
 const DEFAULT_MAX_PTC_CALLS = 256;
 const DEFAULT_MAX_RESULTS_CHARS = 4e3;
+const LINE_NUMBER_RE = /^\s*\d+(?:\.\d+)?\t/;
 const variantImport = import("@jitl/quickjs-ng-wasmfile-release-asyncify");
-async function newAsyncModule() {
-	const variant = await variantImport;
-	return newQuickJSAsyncWASMModuleFromVariant(variant.default ?? variant);
-}
-function makeErrorSource(message) {
-	return `throw { name: "Error", message: ${JSON.stringify(message)} };`;
-}
 /**
-* Parse a canonicalized skill specifier into `{ name, rel }`.
-* Returns `undefined` for anything that isn't a valid `@/skills/<name>` or
-* `@/skills/<name>/<rel>` shape. `rel` is absent for the bare form.
+* Process-global eval queue. Serializes all evalCodeAsync calls across
+* sessions to enforce the asyncify one-at-a-time constraint.
 */
-function parseSkillSpecifier(specifier) {
-	if (!specifier.startsWith("@/skills/")) return;
-	const tail = specifier.slice(9);
-	const slashIdx = tail.indexOf("/");
-	const name = slashIdx === -1 ? tail : tail.slice(0, slashIdx);
-	if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(name)) return;
-	const rel = slashIdx === -1 ? void 0 : tail.slice(slashIdx + 1);
-	if (rel !== void 0 && rel === "") return;
-	return {
-		name,
-		rel
-	};
-}
+const sharedEvalQueue = new AsyncEvalQueue();
 /**
-* Return the `@/skills/<name>` prefix for the skill that owns `base`, or `undefined`.
+* Process-global WASM module shared by all sessions.
+*
+* Each session creates its own runtime and context on this module,
+* providing full isolation for globals, heap, and stack. The module
+* itself is stateless between runtimes — only the compiled WASM code
+* and Emscripten infrastructure are shared.
+*
+* This is safe because:
+* - The module loader is synchronous (preloaded skill cache), so
+*   imports don't cause asyncify suspensions.
+* - Tool injection uses the promise-based pattern (newFunction +
+*   newPromise), not newAsyncifiedFunction, so tool calls don't
+*   cause asyncify suspensions.
+* - The eval queue serializes evalCodeAsync calls to satisfy the
+*   one-concurrent-async-call-per-module constraint.
 */
-function matchSkillPrefix(base) {
-	const parsed = parseSkillSpecifier(base);
-	if (parsed === void 0) return;
-	return `@/skills/${parsed.name}`;
+let sharedModulePromise;
+function getSharedModule() {
+	if (!sharedModulePromise) sharedModulePromise = (async () => {
+		const variant = await variantImport;
+		return newQuickJSAsyncWASMModuleFromVariant(variant.default ?? variant);
+	})();
+	return sharedModulePromise;
 }
 /**
-* Return the directory portion of a slash-separated specifier path.
+* Unwrap a PTC tool result to a plain string for use inside QuickJS.
+*
+* Tool results may arrive as a raw string, or as an array of LangChain
+* content blocks (`{ type: "text", text: "..." }`). Blocks are joined
+* with newlines; non-text block types are silently skipped. Anything
+* else (objects, nulls) is JSON-serialised as a fallback.
+*
+* @param result - Raw return value from `tool.invoke()`.
+* @returns Plain string representation of the tool output.
 */
-function posixDirname(p) {
-	const idx = p.lastIndexOf("/");
-	if (idx === -1) return "";
-	return p.slice(0, idx);
+function extractToolText(result) {
+	if (typeof result === "string") return result;
+	if (Array.isArray(result)) {
+		const texts = [];
+		for (const block of result) if (typeof block === "object" && block !== null && block.type === "text" && typeof block.text === "string") texts.push(block.text);
+		if (texts.length > 0) return texts.join("\n");
+	}
+	return JSON.stringify(result);
 }
 /**
-* POSIX join for slash-separated specifiers. Avoids `node:path/posix`
-* since session.ts is consumed in browser bundles.
+* Remove the `cat -n` line-number prefix from every line of a string.
+*
+* The filesystem backend formats file content with line numbers in the
+* form `"     N\t"` so human readers can navigate by line. That prefix
+* is useful for the agent but noise for QuickJS code that parses the
+* text programmatically (e.g. swarm reading `/context.txt`).
+*
+* The function is conservative: if any non-empty line lacks the prefix,
+* the text is returned unchanged so nothing is silently corrupted.
+*
+* @param text - Raw file content, possibly line-number prefixed.
+* @returns Content with line-number prefixes stripped, or the original
+*          text if it doesn't match the expected format throughout.
 */
-function posixJoin(base, rel) {
-	const out = [];
-	const segments = `${base}/${rel}`.split("/");
-	for (const segment of segments) {
-		if (segment === "" || segment === ".") continue;
-		if (segment === "..") {
-			out.pop();
-			continue;
-		}
-		out.push(segment);
-	}
-	return out.join("/");
+function stripLineNumbers(text) {
+	const lines = text.split("\n");
+	if (lines.length === 0) return text;
+	if (!lines.every((l) => l === "" || LINE_NUMBER_RE.test(l))) return text;
+	return lines.map((l) => l.replace(LINE_NUMBER_RE, "")).join("\n");
 }
 /**
 * Fixed-size character buffer for capturing console output from the QuickJS VM.
@@ -570,11 +485,26 @@ var ReplSession = class ReplSession {
 	context = null;
 	consoleBuffer = new ConsoleBuffer(DEFAULT_MAX_RESULTS_CHARS);
 	options;
-	skillsContext;
-	skillsLoaded = /* @__PURE__ */ new Map();
-	skillsFailed = /* @__PURE__ */ new Map();
 	maxPtcCalls;
 	ptcCallsRemaining = null;
+	subagentQueue = null;
+	bridgeDispatchRef = null;
+	/** Allowed keys in the subagent input object. */
+	static SUBAGENT_ALLOWED_KEYS = new Set([
+		"description",
+		"subagentType",
+		"responseSchema"
+	]);
+	/**
+	* Reset the shared WASM module. Forces the next session to instantiate
+	* a fresh module. Only needed in tests where module state must be
+	* isolated between test files.
+	*
+	* @internal
+	*/
+	static resetSharedModule() {
+		sharedModulePromise = void 0;
+	}
 	constructor(id, options = {}) {
 		this.id = id;
 		this.options = options;
@@ -582,8 +512,8 @@ var ReplSession = class ReplSession {
 	}
 	async ensureStarted() {
 		if (this.runtime) return;
-		const { memoryLimitBytes = DEFAULT_MEMORY_LIMIT, maxStackSizeBytes = DEFAULT_MAX_STACK_SIZE, tools, skillsEnabled = false, maxResultChars = DEFAULT_MAX_RESULTS_CHARS, captureConsole = true } = this.options;
-		const runtime = (await newAsyncModule()).newRuntime();
+		const { memoryLimitBytes = DEFAULT_MEMORY_LIMIT, maxStackSizeBytes = DEFAULT_MAX_STACK_SIZE, tools, maxResultChars = DEFAULT_MAX_RESULTS_CHARS, captureConsole = true } = this.options;
+		const runtime = (await getSharedModule()).newRuntime();
 		runtime.setMemoryLimit(memoryLimitBytes);
 		runtime.setMaxStackSize(maxStackSizeBytes);
 		const context = runtime.newContext();
@@ -592,67 +522,15 @@ var ReplSession = class ReplSession {
 		this.consoleBuffer = new ConsoleBuffer(maxResultChars);
 		if (captureConsole) this.setupConsole();
 		if (tools !== void 0 && tools.length > 0) this.injectTools(tools);
-		if (skillsEnabled) this.installModuleLoader();
-	}
-	/**
-	* Load the skill into cache on first access and replay cached errors.
-	*/
-	async ensureSkillLoaded(name) {
-		const cached = this.skillsLoaded.get(name);
-		if (cached !== void 0) return cached;
-		const cachedError = this.skillsFailed.get(name);
-		if (cachedError !== void 0) throw cachedError;
-		const ctx = this.skillsContext;
-		if (ctx === void 0) throw new Error(`Skill '${name}' referenced but skills are not configured for this session`);
-		const metadata = ctx.metadata.find((m) => m.name === name);
-		if (metadata === void 0) throw new Error(`Skill '${name}' referenced but not available on this agent`);
-		try {
-			const loaded = await loadSkill(metadata, ctx.backend);
-			this.skillsLoaded.set(name, loaded);
-			return loaded;
-		} catch (err) {
-			this.skillsFailed.set(name, err);
-			throw err;
-		}
-	}
-	async resolveSpecifier(specifier) {
-		const parsed = parseSkillSpecifier(specifier);
-		if (parsed === void 0) return makeErrorSource(`Module not found: ${specifier}`);
-		let loaded;
-		try {
-			loaded = await this.ensureSkillLoaded(parsed.name);
-		} catch (err) {
-			return makeErrorSource(err.message ?? String(err));
-		}
-		if (parsed.rel === void 0) {
-			const source = loaded.files.get(loaded.entryRel);
-			if (source === void 0) return makeErrorSource(`Skill '${parsed.name}': entrypoint '${loaded.entryRel}' missing from bundle`);
-			return source;
+		const { subagentBridge } = this.options;
+		if (subagentBridge) {
+			this.subagentQueue = new PQueue({ concurrency: subagentBridge.maxConcurrency });
+			this.injectSubagentBridge(subagentBridge.dispatch);
 		}
-		const source = loaded.files.get(parsed.rel);
-		if (source === void 0) return makeErrorSource(`Skill '${parsed.name}': '${parsed.rel}' not found in bundle`);
-		return source;
-	}
-	/**
-	* Canonicalize an `import` specifier. Bare specifiers pass through;
-	* relative specifiers are resolved against the importing module's path.
-	* Traversal out of a skill's `@/skills/<name>/` namespace is rejected.
-	*/
-	normalizeSpecifier(base, requested) {
-		if (!(requested.startsWith("./") || requested.startsWith("../"))) return requested;
-		const parsed = parseSkillSpecifier(base);
-		const resolved = posixJoin(parsed !== void 0 && parsed.rel === void 0 ? base : posixDirname(base), requested);
-		const skillPrefix = matchSkillPrefix(base);
-		if (skillPrefix === void 0) return resolved;
-		if (!resolved.startsWith(`${skillPrefix}/`)) return `__resolve_error__:${requested} escapes ${skillPrefix}`;
-		return resolved;
-	}
-	/**
-	* Wire the QuickJS module loader and normalizer on this session's runtime.
-	*/
-	installModuleLoader() {
-		if (this.runtime === null) return;
-		this.runtime.setModuleLoader(async (specifier) => this.resolveSpecifier(specifier), (base, requested) => this.normalizeSpecifier(base, requested));
+		const sessionId = this.options.sessionId ?? "default";
+		const sessionIdHandle = context.newString(sessionId);
+		context.setProp(context.global, "__sessionId__", sessionIdHandle);
+		sessionIdHandle.dispose();
 	}
 	/**
 	* Initialise the per-eval PTC counter. Called at the top of every `eval()`.
@@ -715,14 +593,6 @@ var ReplSession = class ReplSession {
 		if (session) session.dispose();
 	}
 	/**
-	* Push the current skills metadata + backend into the session.
-	* Called by the middleware once per `eval` invocation, before eval runs.
-	* Pass `undefined` to clear the context (no skill imports will resolve).
-	*/
-	setSkillsContext(ctx) {
-		this.skillsContext = ctx;
-	}
-	/**
 	* Evaluate code in this session.
 	*
 	* Lazily starts the QuickJS runtime on the first call. Code is
@@ -747,7 +617,7 @@ var ReplSession = class ReplSession {
 			if (timeoutMs >= 0) runtime.setInterruptHandler(shouldInterruptAfterDeadline(Date.now() + timeoutMs));
 			else runtime.setInterruptHandler(() => false);
 			const transformed = transformForEval(code);
-			const result = await context.evalCodeAsync(transformed);
+			const result = await sharedEvalQueue.enqueue(() => context.evalCodeAsync(transformed));
 			if (result.error) {
 				const error = context.dump(result.error);
 				result.error.dispose();
@@ -882,8 +752,9 @@ var ReplSession = class ReplSession {
 					try {
 						this.consumePtcBudget(camelName);
 						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));
+						let text = extractToolText(await t.invoke(rawInput));
+						if (t.name === "read_file") text = stripLineNumbers(text);
+						const val = context.newString(text);
 						promise.resolve(val);
 						val.dispose();
 					} catch (e) {
@@ -902,11 +773,116 @@ var ReplSession = class ReplSession {
 		context.setProp(context.global, "tools", toolsNs);
 		toolsNs.dispose();
 	}
+	/**
+	* Install the `task` global on the QuickJS context.
+	*
+	* Registers the host function directly as `globalThis.task`,
+	* then freezes it via `evalCode`. Structured results (when
+	* responseSchema is provided) are marshaled into native QuickJS
+	* objects on the host side — no JS wrapper needed.
+	*/
+	/**
+	* Replace the active bridge dispatch with a fresh one.
+	*
+	* Call this before each eval so the dispatch closure carries
+	* the current invocation's config (tracing callbacks, run ID, etc.)
+	* rather than the stale config from session creation.
+	*/
+	updateBridgeDispatch(dispatch) {
+		if (this.bridgeDispatchRef) this.bridgeDispatchRef.current = dispatch;
+	}
+	injectSubagentBridge(dispatch) {
+		const context = this.context;
+		const queue = this.subagentQueue;
+		this.bridgeDispatchRef = { current: dispatch };
+		const ref = this.bridgeDispatchRef;
+		const hostFn = context.newFunction("task", (inputHandle) => {
+			const input = context.dump(inputHandle);
+			const promise = context.newPromise();
+			(async () => {
+				try {
+					if (input == null || typeof input !== "object" || Array.isArray(input)) throw new Error("task: expected an object argument");
+					const obj = { ...input };
+					if ("subagent_type" in obj) {
+						obj.subagentType ??= obj.subagent_type;
+						delete obj.subagent_type;
+					}
+					if ("response_schema" in obj) {
+						obj.responseSchema ??= obj.response_schema;
+						delete obj.response_schema;
+					}
+					const unknownKeys = Object.keys(obj).filter((k) => !ReplSession.SUBAGENT_ALLOWED_KEYS.has(k));
+					if (unknownKeys.length > 0) throw new Error(`task: unknown keys: ${unknownKeys.join(", ")}. Allowed: ${[...ReplSession.SUBAGENT_ALLOWED_KEYS].join(", ")}`);
+					const { description, subagentType, responseSchema } = obj;
+					if (typeof description !== "string" || description.length === 0) throw new Error("task: 'description' is required and must be a non-empty string");
+					if (typeof subagentType !== "string" || subagentType.length === 0) throw new Error("task: 'subagentType' is required and must be a non-empty string");
+					if (responseSchema !== void 0 && (responseSchema == null || typeof responseSchema !== "object" || Array.isArray(responseSchema))) throw new Error("task: 'responseSchema' must be a plain object (JSON Schema) when provided");
+					const result = await queue.add(() => ref.current({
+						description,
+						subagentType,
+						...responseSchema !== void 0 && { responseSchema }
+					}));
+					if (typeof result === "string") {
+						const val = context.newString(result);
+						promise.resolve(val);
+						val.dispose();
+					} else {
+						const jsonResult = context.evalCode(`(${JSON.stringify(result)})`);
+						if (jsonResult.error) {
+							const errDump = context.dump(jsonResult.error);
+							jsonResult.error.dispose();
+							throw new Error(`task: failed to marshal structured response: ${JSON.stringify(errDump)}`);
+						}
+						promise.resolve(jsonResult.value);
+						jsonResult.value.dispose();
+					}
+				} catch (e) {
+					const msg = e != null && typeof e.message === "string" ? e.message : String(e);
+					const err = context.newError(msg);
+					promise.reject(err);
+					err.dispose();
+				}
+				promise.settled.then(context.runtime.executePendingJobs);
+			})();
+			return promise.handle;
+		});
+		context.setProp(context.global, "task", hostFn);
+		hostFn.dispose();
+		context.evalCode("Object.freeze(globalThis.task);Object.defineProperty(globalThis, 'task', { value: globalThis.task, writable: false, configurable: false,}); undefined");
+	}
 };
 //#endregion
+//#region src/subagent-dispatch.ts
+const SCHEMA_MAX_BYTES = 4096;
+const SCHEMA_MAX_DEPTH = 5;
+const SCHEMA_MAX_PROPERTIES = 32;
+/**
+* Validate that a response schema does not exceed size, depth, or
+* property-count limits.
+*
+* @throws Error if any limit is exceeded.
+*/
+function validateResponseSchema(schema) {
+	const serialized = JSON.stringify(schema);
+	if (serialized.length > SCHEMA_MAX_BYTES) throw new Error(`responseSchema exceeds ${SCHEMA_MAX_BYTES} byte limit (${serialized.length} bytes)`);
+	function check(node, depth, propCount) {
+		if (depth > SCHEMA_MAX_DEPTH) throw new Error(`responseSchema exceeds maximum nesting depth of ${SCHEMA_MAX_DEPTH}`);
+		const props = node.properties;
+		if (props != null && typeof props === "object" && !Array.isArray(props)) {
+			const propObj = props;
+			propCount.value += Object.keys(propObj).length;
+			if (propCount.value > SCHEMA_MAX_PROPERTIES) throw new Error(`responseSchema exceeds maximum of ${SCHEMA_MAX_PROPERTIES} properties`);
+			for (const value of Object.values(propObj)) if (value != null && typeof value === "object" && !Array.isArray(value)) check(value, depth + 1, propCount);
+		}
+		const items = node.items;
+		if (items != null && typeof items === "object" && !Array.isArray(items)) check(items, depth + 1, propCount);
+	}
+	check(schema, 0, { value: 0 });
+}
+//#endregion
 //#region src/middleware.ts
 /**
-* REPL middleware for deepagents.
+* Code Interpreter middleware for deepagents.
 *
 * Provides an `eval` tool that runs JavaScript in a WASM-sandboxed QuickJS
 * interpreter. Supports:
@@ -914,6 +890,216 @@ var ReplSession = class ReplSession {
 * - Programmatic tool calling (PTC) — expose agent or custom tools inside the REPL
 */
 const DEFAULT_TOOL_NAME = "eval";
+/**
+* Render the subagent dispatch prompt section for the system message.
+* Ported from the Python `_SUBAGENT_SYSTEM_PROMPT_TEMPLATE`.
+*/
+function renderSubagentPrompt(toolName) {
+	return dedent`
+
+    ### Dispatching Subagents with \`task\`
+
+    \`task\` is your primitive for running configured subagents from inside the
+    JavaScript REPL. You orchestrate everything else - fan-out, filtering,
+    deduplication, multi-stage flow, and synthesis - in plain JavaScript.
+
+    #### The primitive
+
+    \`\`\`javascript
+    await task({
+      description,      // full autonomous task prompt
+      subagentType,     // configured subagent name
+      responseSchema,   // optional JSON Schema for structured output
+    }); // -> Promise<unknown>
+    \`\`\`
+
+    \`task\` runs a full agentic loop for the selected configured subagent. The
+    subagent can use whatever tools it was configured with, iterate, inspect
+    context, and return one final result. \`subagentType\` is required; use one of
+    the configured subagent names.
+
+    \`description\` is the only prompt the subagent receives for this dispatch. Make
+    it complete: include the goal, constraints, relevant context, what to inspect,
+    and the exact shape or level of detail you expect back. Each dispatch is
+    stateless from the caller's perspective; you cannot send follow-up messages to
+    the same subagent run.
+
+    \`responseSchema\` is optional. When provided, the resolved value is already a
+    typed JavaScript value matching the schema. Do not call \`JSON.parse\` unless the
+    subagent intentionally returned a JSON string. Dynamic schemas work for
+    declarative subagents; runnable-backed subagents reject dynamic schemas because
+    their runnable is already compiled.
+
+    #### Approval model
+
+    \`task\` dispatches from inside the already-running \`${toolName}\` call. It
+    does not route through the parent agent's \`ToolNode\`-managed \`task\` tool and
+    does not trigger parent-level \`interrupt_on\` / HITL approval for each dispatch.
+    Declarative subagents still honor approval middleware configured inside their
+    own spec. If you need approval before launching a subagent from the parent, use
+    the normal \`task\` tool outside JavaScript or ensure the \`${toolName}\` call
+    itself is approval-gated.
+
+    #### Mental model
+
+    Hold your work in JS: an array of items in, an array of results out. Merge each
+    dispatch result back onto its item. Multi-stage analysis means: run a pass,
+    filter or regroup the array in JS, then run another pass over the survivors.
+
+    Prefer one \`${toolName}\` call that performs the whole workflow. Splitting the
+    workflow across multiple \`${toolName}\` calls costs model turns and forces you to
+    re-establish state.
+
+    #### Fan out with bounded concurrency
+
+    Dispatch independent work in parallel with \`Promise.all\`, but in explicit
+    batches around 10 so you do not launch hundreds of subagents at once. The bridge
+    enforces a hard per-REPL cap of 32 concurrent subagent calls.
+
+    \`\`\`javascript
+    const batchSize = 10;
+    const reviewed = [];
+    for (let i = 0; i < items.length; i += batchSize) {
+      const batch = items.slice(i, i + batchSize);
+      reviewed.push(...(await Promise.all(batch.map(async (it) => {
+        const result = await task({
+          description: "Review " + it.file + " for SQL injection. Cite line numbers.",
+          subagentType: "reviewer",
+          responseSchema: {
+            type: "object",
+            properties: {
+              vulnerabilities: {
+                type: "array",
+                items: {
+                  type: "object",
+                  properties: {
+                    type: { type: "string" },
+                    line: { type: "number" },
+                    evidence: { type: "string" },
+                  },
+                  required: ["type", "line", "evidence"],
+                },
+              },
+            },
+            required: ["vulnerabilities"],
+          },
+        });
+        return { ...it, ...result };
+      }))));
+    }
+    \`\`\`
+
+    #### Use parent JS for cheap work; use subagents for agentic work
+
+    Use JavaScript in the parent REPL for deterministic orchestration: joining
+    arrays, deduping, sorting, filtering, grouping, batching, and merging results.
+    If the \`tools.*\` namespace is exposed, also use it to pre-read files or collect
+    shared data once, then pass only the relevant content to each subagent in
+    \`description\`.
+
+    Use \`task\` for work that benefits from an autonomous agentic loop: reading
+    or searching with the subagent's own tools, inspecting multiple files, following
+    leads, making judgment calls, or producing a final synthesized report.
+
+    #### Pre-read shared context in the parent when useful
+
+    If many subagents need the same source list or file content and \`tools.*\` is
+    available, gather that context once in the parent REPL before dispatching:
+
+    \`\`\`javascript
+    const files = (await tools.glob({ pattern: "src/**/*.ts" }))
+      .split("\\n")
+      .filter(Boolean);
+
+    const items = await Promise.all(files.map(async (file) => {
+      const content = await tools.readFile({ file_path: file });
+      return { file, content };
+    }));
+
+    const batchSize = 10;
+    const results = [];
+    for (let i = 0; i < items.length; i += batchSize) {
+      const batch = items.slice(i, i + batchSize);
+      results.push(...(await Promise.all(batch.map(async (it) => {
+        const finding = await task({
+          description:
+            "Review this file for auth bypasses. Return concrete findings only.\\n\\n" +
+            "File: " + it.file + "\\n\\n" +
+            it.content,
+          subagentType: "reviewer",
+          responseSchema: {
+            type: "object",
+            properties: {
+              findings: { type: "array", items: { type: "object" } },
+            },
+            required: ["findings"],
+          },
+        });
+        return { ...it, ...finding };
+      }))));
+    }
+    \`\`\`
+
+    #### Compose multiple stages
+
+    Filter the array in JS between passes. For example: first ask subagents for a
+    cheap classification, filter to the risky items, then dispatch deeper reviews
+    only for those items.
+
+    \`\`\`javascript
+    const tagged = [];
+    for (let i = 0; i < items.length; i += 10) {
+      const batch = items.slice(i, i + 10);
+      tagged.push(...(await Promise.all(batch.map(async (it) => {
+        const tag = await task({
+          description: "Classify " + it.file + " as handler, util, test, or config.",
+          subagentType: "reviewer",
+          responseSchema: {
+            type: "object",
+            properties: { kind: { type: "string" }, risky: { type: "boolean" } },
+            required: ["kind", "risky"],
+          },
+        });
+        return { ...it, ...tag };
+      }))));
+    }
+
+    const riskyHandlers = tagged.filter((it) => it.kind === "handler" && it.risky);
+    const deepReviews = [];
+    for (let i = 0; i < riskyHandlers.length; i += 10) {
+      const batch = riskyHandlers.slice(i, i + 10);
+      deepReviews.push(...(await Promise.all(batch.map(async (it) => {
+        const review = await task({
+          description: "Deep security review of " + it.file + ". Cite line numbers.",
+          subagentType: "reviewer",
+        });
+        return { ...it, review };
+      }))));
+    }
+    \`\`\`
+
+    #### Get results out without flooding your context
+
+    Keep large result sets in JS variables. Do not \`console.log\` the full result set.
+    If \`tools.writeFile\` is exposed, persist structured output from inside the eval:
+
+    \`\`\`javascript
+    await tools.writeFile({
+      file_path: "/results/subagent-output.json",
+      content: JSON.stringify(deepReviews),
+    });
+    \`\`\`
+
+    Otherwise return a compact summary or a small slice of the results, not the
+    entire intermediate dataset.
+
+    #### Across evals
+
+    Variables persist according to the interpreter persistence mode above, but
+    re-establish what you need in each eval. Doing the whole workflow in one
+    \`${toolName}\` call is usually simplest.
+  `;
+}
 function renderReplSystemPrompt(opts) {
 	return dedent`
     ### Interpreter
@@ -921,7 +1107,7 @@ function renderReplSystemPrompt(opts) {
     An \`${opts.toolName}\` tool is available. It runs JavaScript in a persistent REPL.
     - State (variables, functions) persists across tool calls within a single turn of conversation. They DO NOT persist across multiple turns.
     - Top-level \`await\` works; Promises resolve before the call returns.
-    - Sandboxed: no filesystem, no stdlib, no network, no real clock, no \`fetch\`, no \`require\`.
+    - Runtime sandbox: no built-in filesystem, network, stdlib, or wall-clock APIs (\`fetch\`, \`require\`, \`fs\`, \`process\`, real \`Date.now()\` are unavailable or stubbed). External side effects from inside the REPL are only reachable via the \`tools.*\` namespace when it is exposed (see below); without it, the REPL is pure computation.
     - Timeout: ${opts.timeout}s per call. Memory: ${opts.memoryLimitMb} MB total.
     - \`console.log\` output is captured and returned alongside the result.
   `;
@@ -978,34 +1164,11 @@ function resolveToolList(items, agentTools) {
 	});
 }
 /**
-* Pull `skillsMetadata` from the task input, resolve the backend, and push
-* both into the session. Short-circuits with a `SkillNotAvailable` error if
-* the source references skills the agent doesn't have.
-*/
-async function prepareSkillsForEval(session, skillsBackend, code) {
-	const taskInput = getCurrentTaskInput();
-	const metadata = taskInput?.skillsMetadata ?? [];
-	const referenced = scanSkillReferences(code);
-	if (referenced.size > 0) {
-		const known = new Set(metadata.map((m) => m.name));
-		const missing = [];
-		for (const name of referenced) if (!known.has(name)) missing.push(name);
-		if (missing.length > 0) {
-			session.setSkillsContext(void 0);
-			return formatSkillNotAvailable(missing);
-		}
-	}
-	const resolved = await resolveBackend(skillsBackend, { state: taskInput });
-	session.setSkillsContext({
-		metadata,
-		backend: resolved
-	});
-}
-/**
-* Create the REPL middleware.
+* Create the Code Interpreter middleware.
 */
-function createREPLMiddleware(options = {}) {
-	const { ptc, memoryLimitBytes = DEFAULT_MEMORY_LIMIT, maxStackSizeBytes = DEFAULT_MAX_STACK_SIZE, executionTimeoutMs = DEFAULT_EXECUTION_TIMEOUT, systemPrompt: customSystemPrompt = null, skillsBackend, maxPtcCalls = 256, maxResultChars = DEFAULT_MAX_RESULTS_CHARS, toolName = DEFAULT_TOOL_NAME, captureConsole = true } = options;
+function createCodeInterpreterMiddleware(options = {}) {
+	const { ptc, memoryLimitBytes = DEFAULT_MEMORY_LIMIT, maxStackSizeBytes = DEFAULT_MAX_STACK_SIZE, executionTimeoutMs = DEFAULT_EXECUTION_TIMEOUT, systemPrompt: customSystemPrompt = null, maxPtcCalls = 256, maxResultChars = DEFAULT_MAX_RESULTS_CHARS, toolName = DEFAULT_TOOL_NAME, captureConsole = true, subagents = true } = options;
+	const maxSubagentConcurrency = subagents ? 32 : 0;
 	if (maxPtcCalls !== null && maxPtcCalls !== void 0 && maxPtcCalls < 1) throw new Error("`maxPtcCalls` must be >= 1 or null");
 	const baseSystemPrompt = customSystemPrompt || renderReplSystemPrompt({
 		toolName,
@@ -1015,27 +1178,56 @@ function createREPLMiddleware(options = {}) {
 	const middlewareId = crypto.randomUUID();
 	let cachedPtcPrompt = null;
 	let ptcTools = [];
+	let taskTool = null;
 	function filterToolsForPtc(allTools) {
 		if (!ptc) return [];
 		return resolveToolList(ptc, allTools.filter((t) => t.name !== toolName));
 	}
+	function findTaskTool(tools) {
+		return tools.find((t) => t.name === "task") ?? null;
+	}
+	function createBridgeDispatch(subagentTaskTool, config) {
+		return async (input) => {
+			const hasSchema = input.responseSchema != null;
+			if (hasSchema) validateResponseSchema(input.responseSchema);
+			const toolConfig = {
+				...config,
+				configurable: {
+					...config.configurable,
+					...hasSchema && { [SUBAGENT_RESPONSE_FORMAT_CONFIG_KEY]: input.responseSchema }
+				}
+			};
+			const result = await subagentTaskTool.invoke({
+				description: input.description,
+				subagent_type: input.subagentType
+			}, toolConfig);
+			if (hasSchema && typeof result === "string") try {
+				return JSON.parse(result);
+			} catch {
+				return result;
+			}
+			return result;
+		};
+	}
 	return createMiddleware({
-		name: "REPLMiddleware",
+		name: "CodeInterpreterMiddleware",
 		tools: [tool(async (input, config) => {
-			const sessionKey = `${config.configurable?.thread_id || "__default__"}:${middlewareId}`;
+			const threadId = config.configurable?.thread_id || "__default__";
+			const sessionKey = `${threadId}:${middlewareId}`;
 			const session = ReplSession.getOrCreate(sessionKey, {
 				memoryLimitBytes,
 				maxStackSizeBytes,
 				maxPtcCalls,
 				tools: ptcTools,
-				skillsEnabled: skillsBackend !== void 0,
 				maxResultChars,
-				captureConsole
+				captureConsole,
+				sessionId: threadId,
+				subagentBridge: taskTool && maxSubagentConcurrency > 0 ? {
+					dispatch: createBridgeDispatch(taskTool, config),
+					maxConcurrency: maxSubagentConcurrency
+				} : void 0
 			});
-			if (skillsBackend !== void 0) {
-				const setupError = await prepareSkillsForEval(session, skillsBackend, input.code);
-				if (setupError !== void 0) return setupError;
-			}
+			if (taskTool && maxSubagentConcurrency > 0) session.updateBridgeDispatch(createBridgeDispatch(taskTool, config));
 			return formatReplResult(await session.eval(input.code, executionTimeoutMs));
 		}, {
 			name: toolName,
@@ -1043,15 +1235,17 @@ function createREPLMiddleware(options = {}) {
         Evaluate TypeScript/JavaScript code in a sandboxed REPL. State persists across calls.
         Use console.log() for output. Returns the result of the last expression.
         If file or other tools are available, call them via the tools namespace: await tools.readFile({ path }).
-        If skills are configured, dynamically import them: await import("@/skills/<name>").
       `,
 			metadata: { ls_code_input_language: "javascript" },
 			schema: z.object({ code: z.string().describe("TypeScript/JavaScript code to evaluate in the sandboxed REPL") })
 		})],
 		wrapModelCall: async (request, handler) => {
-			ptcTools = filterToolsForPtc(request.tools || []);
+			const agentTools = request.tools || [];
+			ptcTools = filterToolsForPtc(agentTools);
+			if (!taskTool && maxSubagentConcurrency > 0) taskTool = findTaskTool(agentTools);
 			if (ptcTools.length > 0 && !cachedPtcPrompt) cachedPtcPrompt = await generatePtcPrompt(ptcTools);
-			const systemMessage = request.systemMessage.concat(baseSystemPrompt).concat(cachedPtcPrompt || "");
+			const subagentPrompt = taskTool && maxSubagentConcurrency > 0 ? renderSubagentPrompt(toolName) : "";
+			const systemMessage = request.systemMessage.concat(baseSystemPrompt).concat(subagentPrompt).concat(cachedPtcPrompt || "");
 			return handler({
 				...request,
 				systemMessage
@@ -1064,6 +1258,6 @@ function createREPLMiddleware(options = {}) {
 	});
 }
 //#endregion
-export { DEFAULT_EXECUTION_TIMEOUT, DEFAULT_MAX_PTC_CALLS, DEFAULT_MAX_STACK_SIZE, DEFAULT_MEMORY_LIMIT, MAX_SKILL_BUNDLE_BYTES, PTCCallBudgetExceededError, ReplSession, SKILL_MODULE_EXTENSIONS, createREPLMiddleware, formatReplResult, formatSkillNotAvailable, loadSkill, scanSkillReferences, stripTypeSyntax, toCamelCase, transformForEval };
+export { DEFAULT_EXECUTION_TIMEOUT, DEFAULT_MAX_PTC_CALLS, DEFAULT_MAX_STACK_SIZE, DEFAULT_MEMORY_LIMIT, PTCCallBudgetExceededError, ReplSession, createCodeInterpreterMiddleware, formatReplResult, stripTypeSyntax, toCamelCase, transformForEval, validateResponseSchema };
 
 //# sourceMappingURL=index.js.map