@langchain/quickjs 0.4.0 → 0.5.1

package/dist/index.js

@@ -1,17 +1,155 @@
 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 { isCommand } from "@langchain/langgraph";
+import { BaseMessage } from "@langchain/core/messages";
 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/coerce.ts
+/**
+* Coercion of tool / subagent return values for the QuickJS bridge.
+*
+* The deepagents `task` tool resolves to a LangGraph `Command` whose payload
+* carries the subagent's final message(s) under `update.messages`; some tools
+* return a `ToolMessage` or a list of messages. The interpreter bridges need
+* the underlying output, not the envelope, so this unwraps those shapes to the
+* content the model actually cares about.
+*/
+/**
+* Return the trailing message content from a `Command`'s `update.messages`,
+* scanning from the end for the last message that actually has content. Returns
+* the command unchanged when it has no message-shaped payload.
+*/
+function extractCommandContent(command) {
+	const update = command.update;
+	const messages = update !== null && typeof update === "object" ? update.messages : void 0;
+	if (Array.isArray(messages)) for (let i = messages.length - 1; i >= 0; i--) {
+		const message = messages[i];
+		if (BaseMessage.isInstance(message) && message.content != null) return message.content;
+	}
+	return command;
+}
+/**
+* Unwrap a LangChain `Command` / `ToolMessage` / message-list envelope to the
+* underlying content. Non-envelope values (strings, content-block arrays, plain
+* objects) are returned unchanged.
+*
+* @param value The raw value returned by a tool or subagent dispatch.
+* @returns The unwrapped content, or `value` itself when it isn't an envelope.
+*/
+function unwrapToolEnvelope(value) {
+	if (typeof value === "string") return value;
+	if (isCommand(value)) {
+		const inner = extractCommandContent(value);
+		return inner === value ? value : unwrapToolEnvelope(inner);
+	}
+	if (BaseMessage.isInstance(value)) return unwrapToolEnvelope(value.content);
+	if (Array.isArray(value)) {
+		for (let i = value.length - 1; i >= 0; i--) {
+			const entry = value[i];
+			if (BaseMessage.isInstance(entry)) return unwrapToolEnvelope(entry.content);
+			if (isCommand(entry)) {
+				const inner = extractCommandContent(entry);
+				if (inner !== entry) return unwrapToolEnvelope(inner);
+			}
+		}
+		return value;
+	}
+	return value;
+}
+//#endregion
 //#region src/transform.ts
 /**
 * AST-based code transform pipeline for the REPL.
@@ -87,7 +225,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 +281,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 +351,6 @@ 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})`);
-}
-/**
-* 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.
-*
-* Used as a pre-eval scan so the middleware can surface `SkillNotAvailable`
-* before evaluation starts. Dynamic imports with computed specifiers are
-* not detected.
-*/
-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;
-	}
-};
-//#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/eval-queue.ts
 /**
 * Serializes async operations on a shared WASM module.
@@ -483,6 +407,7 @@ 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");
 /**
 * Process-global eval queue. Serializes all evalCodeAsync calls across
@@ -514,59 +439,47 @@ function getSharedModule() {
 	})();
 	return sharedModulePromise;
 }
-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.
-*/
-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
-	};
-}
-/**
-* Return the `@/skills/<name>` prefix for the skill that owns `base`, or `undefined`.
-*/
-function matchSkillPrefix(base) {
-	const parsed = parseSkillSpecifier(base);
-	if (parsed === void 0) return;
-	return `@/skills/${parsed.name}`;
-}
 /**
-* 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) {
+	result = unwrapToolEnvelope(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.
@@ -628,11 +541,16 @@ 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 = /* @__PURE__ */ 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
@@ -650,7 +568,7 @@ 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 { 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);
@@ -660,97 +578,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;
-		}
-	}
-	/**
-	* Pre-load all skills referenced in source code into the in-memory
-	* cache. Must be called before `evalCodeAsync` so the module loader
-	* can resolve synchronously. An async loader would cause asyncify
-	* suspensions on each import, which is incompatible with the shared
-	* WASM module used by all sessions.
-	*/
-	async preloadReferencedSkills(code) {
-		const refs = scanSkillReferences(code);
-		for (const name of refs) {
-			if (this.skillsLoaded.has(name) || this.skillsFailed.has(name)) continue;
-			try {
-				await this.ensureSkillLoaded(name);
-			} catch (err) {
-				if (!this.skillsFailed.has(name)) this.skillsFailed.set(name, err);
-			}
-		}
-	}
-	/**
-	* Resolve a module specifier to source code. Strictly synchronous —
-	* only reads from the in-memory skill cache populated by
-	* `preloadReferencedSkills`. Returns error source (not a thrown
-	* exception) for missing or failed skills so QuickJS reports the
-	* error inside the VM.
-	*/
-	resolveSpecifier(specifier) {
-		const parsed = parseSkillSpecifier(specifier);
-		if (parsed === void 0) return makeErrorSource(`Module not found: ${specifier}`);
-		const cachedError = this.skillsFailed.get(parsed.name);
-		if (cachedError !== void 0) return makeErrorSource(cachedError.message ?? String(cachedError));
-		const loaded = this.skillsLoaded.get(parsed.name);
-		if (loaded === void 0) return makeErrorSource(`Skill '${parsed.name}' was not preloaded. Ensure the import specifier is a static string literal (dynamic specifiers like \`import("@/skills/" + name)\` are not supported).`);
-		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);
 		}
-		let source = loaded.files.get(parsed.rel);
-		if (source === void 0 && parsed.rel.endsWith(".js")) source = loaded.files.get(parsed.rel.slice(0, -3) + ".ts");
-		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.
-	*
-	* The loader is strictly synchronous — it reads from the in-memory skill
-	* cache populated by `preloadReferencedSkills`. This is critical: an async
-	* module loader causes asyncify suspensions on each import, and disposing
-	* a runtime after multi-file imports corrupts the shared module's asyncify
-	* state, silently breaking the loader for all subsequent sessions.
-	*/
-	installModuleLoader() {
-		if (this.runtime === null) return;
-		this.runtime.setModuleLoader((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()`.
@@ -813,14 +649,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
@@ -833,7 +661,6 @@ var ReplSession = class ReplSession {
 		await this.ensureStarted();
 		const runtime = this.runtime;
 		const context = this.context;
-		await this.preloadReferencedSkills(code);
 		const drainLogs = () => {
 			const [raw, dropped] = this.consoleBuffer.drain();
 			return {
@@ -981,8 +808,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) {
@@ -1001,8 +829,113 @@ 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
 /**
 * Code Interpreter middleware for deepagents.
@@ -1013,14 +946,242 @@ 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. Your job here is to DISTRIBUTE work, not to do it yourself:
+    write JavaScript that fans work out to subagents and assembles their results.
+    You handle the orchestration - 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: the goal, the constraints, what to inspect, and the exact shape
+    or level of detail you expect back. Give context as locators — file paths and
+    symbol names — not as pasted file contents. If you already read a file while
+    exploring, still pass its path and let the subagent read it; do not paste back
+    what you read. Each dispatch is stateless from the caller's perspective; you
+    cannot send follow-up messages to the same subagent run.
+
+    \`responseSchema\` is optional, but set it on any dispatch whose result feeds
+    later code. A deterministic, typed shape is what lets you compose the next
+    stage reliably — index it, sort it, compare fields, branch on it, merge it —
+    instead of parsing free-form text. This is what makes a whole workflow
+    composable as one script. 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.
+
+    You can run the whole workflow in one \`${toolName}\` call or split it across
+    several — both are fine. A single end-to-end script (generate, compare, pick a
+    winner; or review every item, then synthesize) is clean when you can write it
+    in one go; splitting is also fine when you want to inspect results between
+    stages. Either way, don't redo work across calls — reuse what is already in
+    scope (see "Reuse what earlier evals left in scope" below).
+
+    #### 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 files = ["/src/a.ts", "/src/b.ts", "/src/c.ts"]; // found while exploring
+    const batchSize = 10;
+    const reviewed = [];
+    for (let i = 0; i < files.length; i += batchSize) {
+      const batch = files.slice(i, i + batchSize);
+      reviewed.push(...(await Promise.all(batch.map(async (file) => {
+        const result = await task({
+          description: "Read " + file + " and review it 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 { file, ...result };
+      }))));
+    }
+    \`\`\`
+
+    #### Explore with your own tools first, then distribute
+
+    You already have your normal tools for reading, listing, globbing, and
+    grepping files. Use them to explore and understand the task BEFORE you write
+    the orchestration script. These are ordinary tool calls, separate from the
+    \`${toolName}\` tool: read the data file, list or glob the directory, grep for
+    what matters, then decide how to split the work.
+
+    Never write \`${toolName}\` code that spawns a subagent just to read or parse a
+    file or list a directory. That is a deterministic step you do yourself with a
+    direct tool call; spending a whole agent loop on it is wasteful.
+
+    Once you understand the shape of the work, you have creative freedom in how
+    you split it:
+
+    - One dispatch per file or per record, when the items are already separate.
+    - Chunk a large input yourself — read it, split it, optionally write a small
+      input file per chunk — and dispatch one subagent per chunk.
+    - A cheap classification pass first, then deeper dispatches only for the items
+      that warrant them.
+
+    Then write JavaScript in the \`${toolName}\` tool that distributes the heavy,
+    agentic work to subagents with \`task()\`: analyzing file contents, exploring a
+    codebase, making judgment calls, rewriting code, or synthesizing a report.
+
+    Hand each subagent a locator, not a payload. Subagents have their own file
+    tools, so for anything that lives in a file — a file to review, rewrite, or
+    audit — pass the path and let the subagent read it. Do NOT read a whole file
+    just to paste its contents into the description; that bloats every dispatch
+    and duplicates the file across them. Reserve inline content for small or
+    derived data that has no path of its own: a single parsed record, or a chunk
+    you split out of a larger input (write the chunk to its own file and pass that
+    path if it is large). Assemble the results in JS.
+
+    #### 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 = await Promise.all(files.map((file) =>
+      task({
+        description: "Read " + file + " and classify it as handler, util, " +
+          "test, or config.",
+        subagentType: "reviewer",
+        responseSchema: {
+          type: "object",
+          properties: { kind: { type: "string" }, risky: { type: "boolean" } },
+          required: ["kind", "risky"],
+        },
+      }).then((tag) => ({ file, ...tag }))
+    ));
+
+    const riskyHandlers = tagged.filter((it) => it.kind === "handler" && it.risky);
+    const deepReviews = await Promise.all(riskyHandlers.map((it) =>
+      task({
+        description: "Deep security review of " + it.file + ". Cite line numbers.",
+        subagentType: "reviewer",
+      }).then((review) => ({ ...it, review }))
+    ));
+    \`\`\`
+
+    #### Return results via the last expression, not \`console.log\`
+
+    The value of the last expression in an \`${toolName}\` call (or a resolved
+    top-level \`await\`) is returned to you as the result. Make that final
+    expression the variable holding your result and read it from there.
+    \`console.log\` is only for incidental debugging: its output is capped and
+    truncated, while the returned value is not, so never \`console.log\` your
+    actual results.
+
+    Keep large intermediate sets in JS variables and return only a compact
+    summary or a small slice, not the entire dataset. To persist full output,
+    have a subagent write it, or write it with your own file tool outside the
+    \`${toolName}\` call.
+
+    #### Reuse what earlier evals left in scope
+
+    The REPL is persistent within a turn: every top-level variable, function, and
+    class you declare is kept and is available in your next \`${toolName}\` call
+    (each is hoisted to global scope). So if a later step needs something an
+    earlier eval produced or bound, **reference that variable by name** — do not
+    write a new literal that re-types data a previous eval already returned or
+    computed.
+
+    If you catch yourself pasting a big array or object of values you produced in
+    an earlier call, that is the tell: the variable is still in scope, so use it.
+    Re-typing prior results as a fresh literal wastes tokens and drifts from what
+    actually ran.
+
+    \`\`\`javascript
+    // An earlier eval bound this:
+    //   const auditResults = await Promise.all(files.map(/* ...audit... */));
+
+    // A later eval — reference it; do NOT paste the findings back in as a literal:
+    const findings = auditResults.flatMap((r) =>
+      r.findings.map((f) => ({ ...f, file: r.file }))
+    );
+    const verified = await Promise.all(findings.map((f) =>
+      task({ description: "Verify this finding: " + f.evidence, subagentType: "verifier" })
+        .then((v) => ({ ...f, ...v }))
+    ));
+    \`\`\`
+
+    #### When the user asks for a "workflow"
+
+    If the user's request mentions running a "workflow" (or otherwise uses the
+    word "workflow"), fan the work out to subagents rather than doing it all
+    yourself. Explore with your own tools first as needed, then write JavaScript
+    in the \`${toolName}\` tool that dispatches subagents with \`task()\` and
+    assembles their results. The point is to distribute the heavy work in
+    parallel, not to grind through it one tool call at a time.
+  `;
+}
 function renderReplSystemPrompt(opts) {
+	const sideEffects = opts.hasPtc ? " External side effects from inside the REPL are reachable only via the `tools.*` namespace documented below." : " The REPL is pure computation; do any filesystem or other I/O with your normal tools, outside this tool.";
 	return dedent`
     ### Interpreter
 
     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).${sideEffects}
     - Timeout: ${opts.timeout}s per call. Memory: ${opts.memoryLimitMb} MB total.
     - \`console.log\` output is captured and returned alongside the result.
   `;
@@ -1077,64 +1238,65 @@ 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 Code Interpreter middleware.
 */
 function createCodeInterpreterMiddleware(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;
+	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,
-		timeout: executionTimeoutMs / 1e3,
-		memoryLimitMb: Math.floor(memoryLimitBytes / (1024 * 1024))
-	});
 	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 content = unwrapToolEnvelope(await subagentTaskTool.invoke({
+				description: input.description,
+				subagent_type: input.subagentType
+			}, toolConfig));
+			if (hasSchema && typeof content === "string") try {
+				return JSON.parse(content);
+			} catch {
+				return content;
+			}
+			return content;
+		};
+	}
 	return createMiddleware({
 		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,
@@ -1142,15 +1304,23 @@ function createCodeInterpreterMiddleware(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 baseSystemPrompt = customSystemPrompt || renderReplSystemPrompt({
+				toolName,
+				timeout: executionTimeoutMs / 1e3,
+				memoryLimitMb: Math.floor(memoryLimitBytes / (1024 * 1024)),
+				hasPtc: ptcTools.length > 0
+			});
+			const subagentPrompt = taskTool && maxSubagentConcurrency > 0 ? renderSubagentPrompt(toolName) : "";
+			const systemMessage = request.systemMessage.concat(baseSystemPrompt).concat(subagentPrompt).concat(cachedPtcPrompt || "");
 			return handler({
 				...request,
 				systemMessage
@@ -1163,6 +1333,6 @@ function createCodeInterpreterMiddleware(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, createCodeInterpreterMiddleware, 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