effect-agent 0.1.0-beta.85 → 0.1.0-beta.87

package/dist/capabilities/CodeMode.mjs

@@ -0,0 +1,522 @@
+import { t as __exportAll } from "../rolldown-runtime-D7D4PA-g.mjs";
+import { n as utf8ByteLength } from "../utf8-DchGZRBd.mjs";
+import { r as IncludesCatalogDocumentation, t as AdditionalToolCatalog } from "../ToolExposure-C93U1sPu.mjs";
+import { t as CurrentToolCatalog } from "../ToolExposure-9uF_Yo0T.mjs";
+import { ToolExecutionClass } from "../engine/DurableStep.mjs";
+import { ProgrammaticCallRecord, ToolBroker } from "../engine/ToolBroker.mjs";
+import { NetworkDisabled } from "../sandbox/Sandbox.mjs";
+import { CodeExecutionHost, CodeExecutionLimits, CodeExecutionNamespace, CodeExecutionRequest, CodeExecutor, JsIdentifier } from "../sandbox/CodeExecutor.mjs";
+import { Tool, Toolkit } from "effect/unstable/ai";
+import { Cause, Context, Duration, Effect, Exit, Option, Schema } from "effect";
+//#region src/capabilities/CodeMode.ts
+var CodeMode_exports = /* @__PURE__ */ __exportAll({
+	CodeModeDescriptionError: () => CodeModeDescriptionError,
+	CodeModeFailure: () => CodeModeFailure,
+	CodeModeParameters: () => CodeModeParameters,
+	CodeModePassReport: () => CodeModePassReport,
+	CodeModeSuccess: () => CodeModeSuccess,
+	make: () => make
+});
+/**
+* Code Mode (D-035, ADR-0017; capability spec §9.1): one native Effect AI
+* Tool whose input is bounded JavaScript source, executed in one isolated
+* `CodeExecutor` pass that may call an explicit construction-time allowlist
+* of existing Tools through typed sandbox globals and the engine-owned
+* `ToolBroker`. The builder follows the Delegation pattern: an explicit
+* record of selected Tools plus namespace mapping fixed at construction,
+* returning an ordinary Tool and a handler Layer, with no ambient registry
+* (CAP-014). Deployment class `E` only.
+*/
+const maxFailureTextLength = 4096;
+const BoundedFailureText = Schema.String.check(Schema.isMaxLength(maxFailureTextLength));
+const BoundedErrorTag = Schema.NonEmptyString.check(Schema.isMaxLength(256));
+const BoundedLogLine = Schema.String.check(Schema.isMaxLength(16384));
+const BoundedLogs = Schema.Array(BoundedLogLine).check(Schema.isMaxLength(4096));
+const BoundedCode = Schema.NonEmptyString.check(Schema.isMaxLength(524288));
+/** A pass-local report, available to the host even when the caller interrupts execution. */
+const CodeModePassReport = Schema.Struct({
+	status: Schema.Literals([
+		"completed",
+		"failed",
+		"interrupted",
+		"defect"
+	]),
+	calls: Schema.Array(ProgrammaticCallRecord)
+});
+const encodedJsonByteLength = (value) => {
+	try {
+		const encoded = JSON.stringify(value);
+		return encoded === void 0 ? void 0 : utf8ByteLength(encoded);
+	} catch {
+		return;
+	}
+};
+/** Model-decoded Code Mode parameters: one async function expression. */
+const CodeModeParameters = Schema.Struct({ code: BoundedCode });
+/**
+* The bounded model-visible success: the program's JSON result plus captured
+* logs, both already passed through the aggregate egress budget (CAP-016).
+*/
+var CodeModeSuccess = class extends Schema.Class("@effect-agent/capabilities/CodeModeSuccess")({
+	result: Schema.Json,
+	logs: BoundedLogs
+}) {};
+/**
+* The bounded model-visible failure envelope. `failureMode: "return"` turns
+* it into a failed Tool result, so a model can correct a failing program
+* without a blind retry; it carries the same bounded log capture as success
+* plus the bounded thrown value where one exists, all inside the same
+* aggregate egress budget (CAP-016).
+*/
+var CodeModeFailure = class extends Schema.TaggedError()("CodeModeFailure", {
+	errorTag: BoundedErrorTag,
+	message: BoundedFailureText,
+	logs: BoundedLogs,
+	thrown: Schema.optionalKey(Schema.Json),
+	/** Invocation-ordered evidence that fits the egress budget. This is not a replay plan. */
+	calls: Schema.optionalKey(Schema.Array(ProgrammaticCallRecord)),
+	omittedCalls: Schema.optionalKey(Schema.Natural)
+}) {};
+/** A selective documentation request is invalid or cannot fit its declared byte budget. */
+var CodeModeDescriptionError = class extends Schema.TaggedError()("CodeModeDescriptionError", {
+	reason: Schema.Literals([
+		"invalid-selection",
+		"unknown-method",
+		"invalid-bound",
+		"limit-exceeded"
+	]),
+	message: BoundedFailureText
+}) {};
+const DescriptionMethods = Schema.Array(Schema.NonEmptyString.check(Schema.isMaxLength(257))).check(Schema.isMinLength(1), Schema.isMaxLength(64), Schema.isUnique());
+const DescriptionByteLimit = Schema.Int.check(Schema.isBetween({
+	minimum: 1,
+	maximum: 262144
+}));
+const defaultLimits = CodeExecutionLimits.make({
+	maxSourceBytes: 262144,
+	maxWallTime: Duration.seconds(30),
+	maxLogBytes: 262144,
+	maxResultBytes: 1048576,
+	maxHostCalls: 64,
+	maxHostCallArgumentBytes: 262144,
+	maxHostCallResultBytes: 1048576
+});
+const defaultMaxEgressBytes = 65536;
+const MAX_RENDER_DEPTH = 24;
+const isJsonSchemaRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const renderJsonSchemaType = (schema, defs, depth, indent) => {
+	if (depth > MAX_RENDER_DEPTH) throw new Error("Code Mode declaration rendering exceeded its depth bound");
+	if (!isJsonSchemaRecord(schema)) throw new Error(`Code Mode cannot render the JSON schema fragment ${JSON.stringify(schema)}`);
+	const reference = schema.$ref;
+	if (typeof reference === "string") {
+		const match = /^#\/\$defs\/(.+)$/.exec(reference);
+		const key = match === null ? void 0 : match[1].replaceAll("~1", "/").replaceAll("~0", "~");
+		const resolved = key === void 0 ? void 0 : defs[key];
+		if (resolved === void 0) throw new Error(`Code Mode cannot resolve the JSON schema reference ${reference}`);
+		return renderJsonSchemaType(resolved, defs, depth + 1, indent);
+	}
+	if (Array.isArray(schema.enum)) return schema.enum.map((value) => JSON.stringify(value)).join(" | ");
+	if ("const" in schema) return JSON.stringify(schema.const);
+	const union = schema.anyOf ?? schema.oneOf;
+	if (Array.isArray(union)) return union.map((member) => renderJsonSchemaType(member, defs, depth + 1, indent)).join(" | ");
+	const type = schema.type;
+	if (Array.isArray(type)) return type.map((member) => renderJsonSchemaType({
+		...schema,
+		type: member
+	}, defs, depth + 1, indent)).join(" | ");
+	switch (type) {
+		case "string": return "string";
+		case "number":
+		case "integer": return "number";
+		case "boolean": return "boolean";
+		case "null": return "null";
+		case "array":
+			if (!("items" in schema)) throw new Error("Code Mode cannot render an array schema without items");
+			return `ReadonlyArray<${renderJsonSchemaType(schema.items, defs, depth + 1, indent)}>`;
+		case "object":
+		case void 0:
+			if (isJsonSchemaRecord(schema.properties)) {
+				const required = Array.isArray(schema.required) ? schema.required : [];
+				const inner = `${indent}  `;
+				const fields = Object.entries(schema.properties).map(([key, property]) => {
+					const optional = required.includes(key) ? "" : "?";
+					const rendered = /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key) ? key : JSON.stringify(key);
+					return `${inner}readonly ${rendered}${optional}: ${renderJsonSchemaType(property, defs, depth + 1, inner)};`;
+				});
+				return fields.length === 0 ? "{}" : `{\n${fields.join("\n")}\n${indent}}`;
+			}
+			if (isJsonSchemaRecord(schema.additionalProperties)) return `Record<string, ${renderJsonSchemaType(schema.additionalProperties, defs, depth + 1, indent)}>`;
+			if (type === "object" && !("properties" in schema) && !("additionalProperties" in schema)) return "Record<string, unknown>";
+	}
+	throw new Error(`Code Mode cannot render the JSON schema fragment ${JSON.stringify(schema).slice(0, 200)}; fix or simplify the Tool's Schema`);
+};
+const renderTopLevel = (jsonSchema, indent) => {
+	const defs = isJsonSchemaRecord(jsonSchema) && isJsonSchemaRecord(jsonSchema.$defs) ? jsonSchema.$defs : {};
+	return renderJsonSchemaType(jsonSchema, defs, 0, indent);
+};
+const decodeIdentifier = Schema.decodeUnknownOption(JsIdentifier);
+const renderDeclarations = (methods) => {
+	const namespaces = /* @__PURE__ */ new Map();
+	for (const method of methods) {
+		const existing = namespaces.get(method.namespace) ?? [];
+		existing.push(method);
+		namespaces.set(method.namespace, existing);
+	}
+	return [...namespaces.entries()].map(([namespace, members]) => {
+		return `declare const ${namespace}: {\n${members.map((member) => {
+			const parameters = renderTopLevel(Tool.getJsonSchema(member.tool), "  ");
+			const success = renderTopLevel(Tool.getJsonSchemaFromSchema(member.tool.successSchema), "  ");
+			const safeDescription = member.tool.description?.replaceAll("*/", "*\\/").replaceAll(/\s*\n\s*/g, " ");
+			return `${safeDescription === void 0 ? "" : `  /** ${safeDescription} */\n`}  ${member.method}(input: ${parameters}): Promise<${success}>;`;
+		}).join("\n")}\n};`;
+	}).join("\n\n");
+};
+const truncationMarker = "… logs truncated by the egress budget";
+const MAX_EGRESS_LOG_LINE_CHARACTERS = 16e3;
+/**
+* Budget charge of one log line as it actually crosses to the model: the
+* JSON-encoded string (quotes, escapes) plus one array separator. Charging
+* raw UTF-8 would undercount model-visible bytes for escape-heavy content.
+*/
+const encodedLogLineBytes = (line) => {
+	try {
+		return utf8ByteLength(JSON.stringify(line)) + 1;
+	} catch {
+		return Number.MAX_SAFE_INTEGER;
+	}
+};
+const budgetedLogs = (logs, remainingBytes) => {
+	const kept = [];
+	let used = 0;
+	let truncated = false;
+	for (const raw of logs) {
+		const line = raw.length > MAX_EGRESS_LOG_LINE_CHARACTERS ? `${raw.slice(0, 15999)}…` : raw;
+		const bytes = encodedLogLineBytes(line);
+		if (kept.length >= 4096 || used + bytes > remainingBytes) {
+			truncated = true;
+			break;
+		}
+		kept.push(line);
+		used += bytes;
+	}
+	if (truncated) {
+		const markerBytes = encodedLogLineBytes(truncationMarker);
+		while (kept.length > 0 && used + markerBytes > remainingBytes) used -= encodedLogLineBytes(kept.pop() ?? "");
+		if (markerBytes <= remainingBytes) kept.push(truncationMarker);
+	}
+	return kept;
+};
+const boundedMessage = (message) => message.slice(0, maxFailureTextLength);
+const executionFailureMessage = (error) => {
+	switch (error._tag) {
+		case "CodeExecutionTimeoutError": return `The program exceeded its ${Duration.format(error.maxWallTime)} ${error.kind} budget`;
+		case "CodeOutputLimitError": return `The ${error.surface} limit of ${error.limit} bytes was exceeded (${error.observed} bytes observed)`;
+		case "CodeHostCallLimitError": return `The pass exceeded its executor cap of ${error.limit} host calls`;
+		default: return error.message;
+	}
+};
+/** UTF-8-aware truncation so a message can never exceed the aggregate budget. */
+const truncateToUtf8Bytes = (value, maxBytes) => {
+	if (utf8ByteLength(value) <= maxBytes) return value;
+	let output = "";
+	let used = 0;
+	for (const character of value) {
+		const bytes = utf8ByteLength(character);
+		if (used + bytes + 3 > maxBytes) break;
+		output += character;
+		used += bytes;
+	}
+	return `${output}…`;
+};
+const make = (name, options) => {
+	const limits = options.limits ?? defaultLimits;
+	const maxEgressBytes = options.maxEgressBytes ?? defaultMaxEgressBytes;
+	if (!Number.isSafeInteger(maxEgressBytes) || maxEgressBytes < 256 || maxEgressBytes > 4194304) throw new Error(`Code Mode maxEgressBytes must be an integer between 256 and 4194304; received ${String(maxEgressBytes)}`);
+	const methods = [];
+	const toolsByName = /* @__PURE__ */ new Map();
+	const methodToTool = /* @__PURE__ */ new Map();
+	for (const [namespace, namespaceMethods] of Object.entries(options.tools)) {
+		if (Option.isNone(decodeIdentifier(namespace))) throw new Error(`Code Mode namespace ${namespace} is not a valid JavaScript identifier`);
+		const entries = Object.entries(namespaceMethods);
+		if (entries.length === 0) throw new Error(`Code Mode namespace ${namespace} declares no methods`);
+		for (const [method, tool] of entries) {
+			if (Option.isNone(decodeIdentifier(method))) throw new Error(`Code Mode method ${namespace}.${method} is not a valid JavaScript identifier`);
+			const approval = tool.needsApproval;
+			if (approval !== void 0 && approval !== false) throw new Error(`Code Mode rejects Tool ${tool.name} (${namespace}.${method}): approval-requiring Tools cannot be invoked programmatically in the ephemeral slice`);
+			const existing = toolsByName.get(tool.name);
+			if (existing !== void 0 && existing !== tool) throw new Error(`Code Mode selected two different Tools named ${tool.name}; Tool names must identify one Tool`);
+			toolsByName.set(tool.name, tool);
+			methodToTool.set(`${namespace}.${method}`, tool.name);
+			methods.push({
+				namespace,
+				method,
+				tool
+			});
+		}
+	}
+	if (methods.length === 0) throw new Error("Code Mode requires at least one allowlisted Tool");
+	const declarations = renderDeclarations(methods);
+	const methodsByPath = new Map(methods.map((method) => [`${method.namespace}.${method.method}`, method]));
+	const describe = Effect.fn("CodeMode.describe")(function* (selected, options) {
+		const paths = yield* Schema.decodeEffect(DescriptionMethods)(selected).pipe(Effect.mapError(() => CodeModeDescriptionError.make({
+			reason: "invalid-selection",
+			message: "Select between 1 and 64 unique namespace.method names, each at most 257 characters"
+		})));
+		const maxBytes = yield* Schema.decodeEffect(DescriptionByteLimit)(options?.maxBytes ?? 16384).pipe(Effect.mapError(() => CodeModeDescriptionError.make({
+			reason: "invalid-bound",
+			message: "The documentation byte limit must be an integer between 1 and 262144"
+		})));
+		const selectedMethods = [];
+		for (const path of paths) {
+			const method = methodsByPath.get(path);
+			if (method === void 0) return yield* CodeModeDescriptionError.make({
+				reason: "unknown-method",
+				message: "The selection contains a method outside this Code Mode allowlist"
+			});
+			selectedMethods.push(method);
+		}
+		const documentation = renderDeclarations(selectedMethods);
+		if (utf8ByteLength(documentation) > maxBytes) return yield* CodeModeDescriptionError.make({
+			reason: "limit-exceeded",
+			message: `The selected declarations exceed the ${maxBytes}-byte documentation limit; select fewer methods or raise the limit`
+		});
+		return documentation;
+	});
+	const namespaces = [...new Set(methods.map((method) => method.namespace))].map((namespace) => CodeExecutionNamespace.make({
+		name: namespace,
+		methods: methods.filter((method) => method.namespace === namespace).map((method) => method.method)
+	}));
+	const description = [
+		options.description,
+		"",
+		"The `code` argument must be one JavaScript async function expression; the sandbox invokes it exactly once with no arguments. It runs isolated with no ambient network, filesystem, environment, or secrets. Return one JSON value. `console.log` output is captured within a bounded budget and returned alongside the result.",
+		"Namespace methods return Promises. An expected Tool failure rejects with a JSON envelope carrying a stable `_tag`; catch it to branch. Use Promise.all for independent calls; the host bounds concurrency. Await every call you need. Writes may complete before a failure: inspect call outcomes and never blindly retry a program.",
+		...options.includeDeclarations === false ? [] : [
+			"",
+			"Sandbox globals:",
+			"```ts",
+			declarations,
+			"```"
+		]
+	].join("\n");
+	const tool = Tool.make(name, {
+		description,
+		parameters: CodeModeParameters,
+		success: CodeModeSuccess,
+		failure: CodeModeFailure,
+		failureMode: "return"
+	}).annotate(Tool.Readonly, false).annotate(ToolExecutionClass, "uncertain").annotate(IncludesCatalogDocumentation, options.includeDeclarations !== false).annotate(AdditionalToolCatalog, Object.freeze(methods.map((method) => Object.freeze({ ...method })))).addDependency(ToolBroker);
+	const outerToolkit = Toolkit.make(tool);
+	/**
+	* The nested namespace record collapses into one Toolkit keyed by exact
+	* Tool names. The assertion restores the name-keyed record type TypeScript
+	* cannot compute from `Map` iteration; construction above guarantees the
+	* name uniqueness the type states.
+	*/
+	const selectedToolkit = Toolkit.make(...toolsByName.values());
+	const executionRequest = (code, visibleNamespaces) => CodeExecutionRequest.make({
+		language: "javascript",
+		source: code,
+		namespaces: visibleNamespaces,
+		network: NetworkDisabled.make({}),
+		limits
+	});
+	const routeHostCall = (pass, hostCall, visiblePaths) => Effect.gen(function* () {
+		const path = `${hostCall.namespace}.${hostCall.method}`;
+		const toolName = visiblePaths === void 0 || visiblePaths.has(path) ? methodToTool.get(path) : void 0;
+		if (toolName === void 0) return {
+			_tag: "CodeHostCallFailure",
+			error: {
+				_tag: "UnknownCodeModeMethod",
+				message: "The requested method is not available in this pass"
+			}
+		};
+		const outcome = yield* pass.invoke({
+			toolName,
+			encodedArguments: hostCall.argument
+		});
+		switch (outcome._tag) {
+			case "ProgrammaticCallSuccess": {
+				const value = decodeBrokerJson(outcome.encodedResult);
+				return Option.isSome(value) ? {
+					_tag: "CodeHostCallSuccess",
+					value: value.value
+				} : {
+					_tag: "CodeHostCallFailure",
+					error: brokerProtocolEnvelope
+				};
+			}
+			case "ProgrammaticCallFailure": {
+				const value = decodeBrokerJson(outcome.encodedResult);
+				return {
+					_tag: "CodeHostCallFailure",
+					error: Option.isSome(value) ? value.value : brokerProtocolEnvelope
+				};
+			}
+			case "ProgrammaticCallError": return {
+				_tag: "CodeHostCallFailure",
+				error: {
+					_tag: outcome.errorTag,
+					message: outcome.message
+				}
+			};
+		}
+	});
+	const build = Effect.gen(function* () {
+		const captured = yield* Effect.context();
+		const redactionServices = yield* Effect.context();
+		const configuredRedactor = options.redactEgress;
+		const redact = configuredRedactor === void 0 ? void 0 : (egress) => Effect.scoped(configuredRedactor(egress)).pipe(Effect.updateContext((current) => Context.merge(current, redactionServices)));
+		const withHandler = yield* selectedToolkit;
+		const executor = yield* CodeExecutor;
+		const successEgress = (execution) => Effect.gen(function* () {
+			let egress = {
+				result: execution.value,
+				logs: execution.logs
+			};
+			if (redact !== void 0) egress = yield* redact(egress);
+			const resultBytes = encodedJsonByteLength(egress.result);
+			if (resultBytes === void 0 || resultBytes > maxEgressBytes) return yield* CodeModeFailure.make({
+				errorTag: "CodeModeEgressExceeded",
+				message: `The program result of ${resultBytes ?? "unencodable"} bytes exceeds the ${maxEgressBytes}-byte model-visible egress budget; return a smaller value`,
+				logs: budgetedLogs(egress.logs, Math.max(0, maxEgressBytes - 256))
+			});
+			return CodeModeSuccess.make({
+				result: egress.result,
+				logs: budgetedLogs(egress.logs, maxEgressBytes - resultBytes)
+			});
+		});
+		/**
+		* The failure half of the aggregate egress policy (CAP-016): the configured
+		* redaction pass covers failure logs and thrown values exactly like success
+		* egress — a program cannot leak by logging and then throwing — and the
+		* message itself is bounded by the budget, not only by its own schema cap.
+		*/
+		const failureEgress = (error) => Effect.gen(function* () {
+			if (error._tag === "ToolBrokerUnavailableError" || error._tag === "ToolBrokerConfigurationError") return CodeModeFailure.make({
+				errorTag: error._tag,
+				message: truncateToUtf8Bytes(boundedMessage(error.message), maxEgressBytes),
+				logs: []
+			});
+			let logs = "logs" in error ? error.logs : [];
+			let candidateThrown = error._tag === "CodeProgramFailedError" ? error.thrown : void 0;
+			if (redact !== void 0) {
+				const redacted = yield* redact({
+					result: candidateThrown ?? null,
+					logs
+				});
+				logs = redacted.logs;
+				candidateThrown = candidateThrown === void 0 ? void 0 : redacted.result;
+			}
+			const message = truncateToUtf8Bytes(boundedMessage(executionFailureMessage(error)), maxEgressBytes);
+			const messageBytes = utf8ByteLength(message);
+			const candidateBytes = candidateThrown === void 0 ? void 0 : encodedJsonByteLength(candidateThrown);
+			const includeThrown = candidateThrown !== void 0 && candidateBytes !== void 0 && messageBytes + candidateBytes <= maxEgressBytes;
+			const remaining = Math.max(0, maxEgressBytes - messageBytes - (includeThrown ? candidateBytes ?? 0 : 0));
+			return CodeModeFailure.make({
+				errorTag: error._tag,
+				message,
+				logs: budgetedLogs(logs, remaining),
+				...includeThrown ? { thrown: candidateThrown } : {}
+			});
+		});
+		const invoke = Effect.fn(`CodeMode.${name}`)(function* (parameters) {
+			const broker = yield* ToolBroker;
+			const catalogue = yield* Effect.serviceOption(CurrentToolCatalog);
+			const visiblePaths = Option.isNone(catalogue) ? void 0 : new Set(catalogue.value.entries.flatMap((entry) => entry.kind === "code-mode" && entry.nativeToolName === name && methodsByPath.get(`${entry.namespace}.${entry.method}`)?.tool.name === entry.tool.name ? [`${entry.namespace}.${entry.method}`] : []));
+			const visibleNamespaces = visiblePaths === void 0 ? namespaces : namespaces.flatMap((namespace) => {
+				const allowed = namespace.methods.filter((method) => visiblePaths.has(`${namespace.name}.${method}`));
+				return allowed.length === 0 ? [] : [CodeExecutionNamespace.make({
+					name: namespace.name,
+					methods: allowed
+				})];
+			});
+			let calls = [];
+			return yield* Effect.gen(function* () {
+				const pass = yield* broker.openPass(withHandler, {
+					maxResultBytes: limits.maxHostCallResultBytes,
+					concurrency: limits.maxHostCallConcurrency ?? 4
+				});
+				const host = CodeExecutionHost.of({ call: (hostCall) => routeHostCall(pass, hostCall, visiblePaths) });
+				return yield* executor.execute(executionRequest(parameters.code, visibleNamespaces)).pipe(Effect.provideService(CodeExecutionHost, host), Effect.scoped, Effect.onExit((exit) => Effect.gen(function* () {
+					calls = yield* pass.snapshot;
+					if (options.onPassExit !== void 0) yield* Effect.scoped(options.onPassExit({
+						status: Exit.isSuccess(exit) ? "completed" : Cause.hasInterrupts(exit.cause) ? "interrupted" : Cause.hasDies(exit.cause) ? "defect" : "failed",
+						calls
+					})).pipe(Effect.provideContext(redactionServices));
+				})));
+			}).pipe(Effect.scoped, Effect.provideService(ToolBroker, broker), Effect.provideContext(captured)).pipe(Effect.catch((error) => failureEgress(error).pipe(Effect.flatMap(Effect.fail))), Effect.flatMap(successEgress), Effect.mapError((failure) => {
+				if (calls.length === 0) return failure;
+				const complete = CodeModeFailure.make({
+					errorTag: failure.errorTag,
+					message: failure.message,
+					logs: failure.logs,
+					...failure.thrown === void 0 ? {} : { thrown: failure.thrown },
+					calls,
+					omittedCalls: 0
+				});
+				if ((encodedJsonByteLength(complete) ?? Infinity) <= maxEgressBytes) return complete;
+				const base = {
+					errorTag: failure.errorTag,
+					message: truncateToUtf8Bytes(failure.message, Math.min(256, maxEgressBytes / 4)),
+					logs: []
+				};
+				const kept = [];
+				for (const call of calls) {
+					const candidate = CodeModeFailure.make({
+						...base,
+						calls: [...kept, call],
+						omittedCalls: calls.length - kept.length - 1
+					});
+					if ((encodedJsonByteLength(candidate) ?? Infinity) > maxEgressBytes) break;
+					kept.push(call);
+				}
+				return CodeModeFailure.make({
+					...base,
+					calls: kept,
+					omittedCalls: calls.length - kept.length
+				});
+			}));
+		});
+		return { [name]: invoke };
+	});
+	/**
+	* TypeScript cannot unify the two spellings of the singleton Tool record
+	* (`CodeModeTools<Name>` versus the toolkit's name-remapped form) over a
+	* generic `Name`, nor reduce the deferred `Exclude` when `toLayer`
+	* subtracts what `build` consumed; the assertions pin the layer to its
+	* documented requirement surface and never bypass validation.
+	*/
+	const handlers = outerToolkit.toLayer(build);
+	return Object.freeze({
+		name,
+		description,
+		declarations,
+		describe,
+		namespaces,
+		limits,
+		maxEgressBytes,
+		tool,
+		handlers
+	});
+};
+/**
+* Fail-closed JSON boundary for broker outcomes: hostile values can throw
+* from trap getters during decode, and a value outside the JSON surface must
+* become a typed failure envelope — never a fabricated success.
+*/
+const decodeBrokerJson = (value) => {
+	try {
+		return Schema.decodeUnknownOption(Schema.Json)(value);
+	} catch {
+		return Option.none();
+	}
+};
+const brokerProtocolEnvelope = {
+	_tag: "CodeModeProtocolError",
+	message: "The broker returned a value outside the JSON surface"
+};
+//#endregion
+export { CodeModeDescriptionError, CodeModeFailure, CodeModeParameters, CodeModePassReport, CodeModeSuccess, make, CodeMode_exports as t };
+
+//# sourceMappingURL=CodeMode.mjs.map

package/dist/capabilities/CodeMode.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"CodeMode.mjs","names":["ToolExecutionClassAnnotation"],"sources":["../../src/capabilities/CodeMode.ts"],"sourcesContent":["import {\n  type Layer,\n  Cause,\n  Context,\n  Duration,\n  Effect,\n  Exit,\n  Option,\n  Schema,\n  type Scope,\n} from \"effect\";\nimport { Tool, Toolkit } from \"effect/unstable/ai\";\n\nimport { utf8ByteLength } from \"../core/internal/utf8.ts\";\nimport { AdditionalToolCatalog, IncludesCatalogDocumentation } from \"../core/ToolExposure.ts\";\nimport {\n  type ToolBrokerConfigurationError,\n  type ToolBrokerUnavailableError,\n  ToolBroker,\n  type ProgrammaticCallOutcome,\n  type ToolBrokerPass,\n  ProgrammaticCallRecord,\n} from \"../engine/ToolBroker.ts\";\nimport { CurrentToolCatalog } from \"../engine/ToolExposure.ts\";\nimport {\n  type CodeExecutionError,\n  CodeExecutionHost,\n  CodeExecutionLimits,\n  CodeExecutionNamespace,\n  CodeExecutionRequest,\n  CodeExecutor,\n  JsIdentifier,\n  type CodeExecutionResult,\n  type CodeHostCall,\n  type CodeHostCallResult,\n} from \"../sandbox/CodeExecutor.ts\";\nimport { NetworkDisabled } from \"../sandbox/Sandbox.ts\";\n\n/**\n * Code Mode (D-035, ADR-0017; capability spec §9.1): one native Effect AI\n * Tool whose input is bounded JavaScript source, executed in one isolated\n * `CodeExecutor` pass that may call an explicit construction-time allowlist\n * of existing Tools through typed sandbox globals and the engine-owned\n * `ToolBroker`. The builder follows the Delegation pattern: an explicit\n * record of selected Tools plus namespace mapping fixed at construction,\n * returning an ordinary Tool and a handler Layer, with no ambient registry\n * (CAP-014). Deployment class `E` only.\n */\n\nconst maxFailureTextLength = 4 * 1024;\nconst BoundedFailureText = Schema.String.check(Schema.isMaxLength(maxFailureTextLength));\nconst BoundedErrorTag = Schema.NonEmptyString.check(Schema.isMaxLength(256));\nconst BoundedLogLine = Schema.String.check(Schema.isMaxLength(16 * 1024));\nconst BoundedLogs = Schema.Array(BoundedLogLine).check(Schema.isMaxLength(4_096));\nconst BoundedCode = Schema.NonEmptyString.check(Schema.isMaxLength(512 * 1024));\n\n/** A pass-local report, available to the host even when the caller interrupts execution. */\nexport const CodeModePassReport = Schema.Struct({\n  status: Schema.Literals([\"completed\", \"failed\", \"interrupted\", \"defect\"]),\n  calls: Schema.Array(ProgrammaticCallRecord),\n});\n\nexport type CodeModePassReport = typeof CodeModePassReport.Type;\n\nconst encodedJsonByteLength = (value: unknown): number | undefined => {\n  try {\n    const encoded = JSON.stringify(value);\n\n    return encoded === undefined ? undefined : utf8ByteLength(encoded);\n  } catch {\n    return undefined;\n  }\n};\n\n/** Model-decoded Code Mode parameters: one async function expression. */\nexport const CodeModeParameters = Schema.Struct({\n  code: BoundedCode,\n});\n\n/**\n * The bounded model-visible success: the program's JSON result plus captured\n * logs, both already passed through the aggregate egress budget (CAP-016).\n */\nexport class CodeModeSuccess extends Schema.Class<CodeModeSuccess>(\n  \"@effect-agent/capabilities/CodeModeSuccess\",\n)({\n  result: Schema.Json,\n  logs: BoundedLogs,\n}) {}\n\n/**\n * The bounded model-visible failure envelope. `failureMode: \"return\"` turns\n * it into a failed Tool result, so a model can correct a failing program\n * without a blind retry; it carries the same bounded log capture as success\n * plus the bounded thrown value where one exists, all inside the same\n * aggregate egress budget (CAP-016).\n */\nexport class CodeModeFailure extends Schema.TaggedError<CodeModeFailure>()(\"CodeModeFailure\", {\n  errorTag: BoundedErrorTag,\n  message: BoundedFailureText,\n  logs: BoundedLogs,\n  thrown: Schema.optionalKey(Schema.Json),\n  /** Invocation-ordered evidence that fits the egress budget. This is not a replay plan. */\n  calls: Schema.optionalKey(Schema.Array(ProgrammaticCallRecord)),\n  omittedCalls: Schema.optionalKey(Schema.Natural),\n}) {}\n\n/** A selective documentation request is invalid or cannot fit its declared byte budget. */\nexport class CodeModeDescriptionError extends Schema.TaggedError<CodeModeDescriptionError>()(\n  \"CodeModeDescriptionError\",\n  {\n    reason: Schema.Literals([\n      \"invalid-selection\",\n      \"unknown-method\",\n      \"invalid-bound\",\n      \"limit-exceeded\",\n    ]),\n    message: BoundedFailureText,\n  },\n) {}\n\nconst DescriptionMethods = Schema.Array(Schema.NonEmptyString.check(Schema.isMaxLength(257))).check(\n  Schema.isMinLength(1),\n  Schema.isMaxLength(64),\n  Schema.isUnique(),\n);\n\nconst DescriptionByteLimit = Schema.Int.check(\n  Schema.isBetween({ minimum: 1, maximum: 256 * 1024 }),\n);\n\n/** The namespace-record shape accepted by `CodeMode.make`. */\nexport type CodeModeNamespaces = Record<string, Record<string, Tool.Any>>;\n\n/**\n * Union of every Tool selected across all namespaces, computed distributively\n * per namespace: indexing the namespace union with the INTERSECTION of method\n * keys would erase every Tool once two namespaces have disjoint methods.\n */\nexport type CodeModeSelectedTool<Namespaces extends CodeModeNamespaces> = {\n  [Namespace in keyof Namespaces]: Namespaces[Namespace][keyof Namespaces[Namespace]];\n}[keyof Namespaces];\n\n/** The selected Tools re-keyed by their own Tool names. */\nexport type CodeModeSelectedRecord<Namespaces extends CodeModeNamespaces> = {\n  readonly [T in CodeModeSelectedTool<Namespaces> as T[\"name\"]]: T;\n};\n\n/**\n * The native Effect AI Tool created by `CodeMode.make` (CAP-014). Its only\n * per-call dependency is the engine-provided `ToolBroker`; the `CodeExecutor`\n * and every selected handler and redaction service are construction requirements of the handler\n * Layer instead, so they stay visible in the composed `R`.\n */\nexport type CodeModeTool<Name extends string> = Tool.Tool<\n  Name,\n  {\n    readonly parameters: typeof CodeModeParameters;\n    readonly success: typeof CodeModeSuccess;\n    readonly failure: typeof CodeModeFailure;\n    readonly failureMode: \"return\";\n  },\n  ToolBroker\n>;\n\n/** Singleton Tool record provided by one Code Mode handler Layer. */\nexport type CodeModeTools<Name extends string> = {\n  readonly [Key in Name]: CodeModeTool<Name>;\n};\n\n/** Construction requirements of the Code Mode handler Layer. */\nexport type CodeModeLayerRequirements<\n  Namespaces extends CodeModeNamespaces,\n  RedactionRequirements = never,\n> =\n  | CodeExecutor\n  | Exclude<RedactionRequirements, Scope.Scope>\n  | Tool.HandlersFor<CodeModeSelectedRecord<Namespaces>>\n  | Tool.HandlerServices<CodeModeSelectedTool<Namespaces>>;\n\nexport interface CodeModeOptions<\n  Namespaces extends CodeModeNamespaces,\n  RedactionRequirements = never,\n> {\n  /** Model-visible description; the builder appends the sandbox contract. */\n  readonly description: string;\n  /** Include all sandbox declarations in the model-facing description. Defaults to true. */\n  readonly includeDeclarations?: boolean | undefined;\n  /**\n   * Explicit allowlist: namespace name → method name → native Effect AI\n   * Tool. Reads and mutations are allowed; calls requiring additional approval fail closed.\n   */\n  readonly tools: Namespaces;\n  /** Executor limits for one pass; a bounded default applies when omitted. */\n  readonly limits?: CodeExecutionLimits | undefined;\n  /**\n   * Aggregate model-visible egress budget in UTF-8 bytes across the final\n   * result, captured logs, and any thrown value (CAP-016). Default 65536.\n   */\n  readonly maxEgressBytes?: number | undefined;\n  /**\n   * Host-only ephemeral report after executor resources and invocation fibers close, including\n   * failure, defect, and interruption. It contains no arguments/results and is never a checkpoint.\n   * Keep this total callback bounded; its services are captured with the handler Layer.\n   */\n  readonly onPassExit?:\n    | ((report: CodeModePassReport) => Effect.Effect<void, never, RedactionRequirements>)\n    | undefined;\n  /**\n   * Optional aggregate redaction pass applied to the model-visible egress\n   * before the byte budget. Its services are acquired with the handler Layer;\n   * temporary resources close with each redaction invocation.\n   * It must be total; a defect stays a defect.\n   */\n  readonly redactEgress?:\n    | ((egress: {\n        readonly result: Schema.Json;\n        readonly logs: ReadonlyArray<string>;\n      }) => Effect.Effect<\n        {\n          readonly result: Schema.Json;\n          readonly logs: ReadonlyArray<string>;\n        },\n        never,\n        RedactionRequirements\n      >)\n    | undefined;\n}\n\n/**\n * An immutable Code Mode definition: one model-facing Tool over an explicit\n * allowlist, plus the handler Layer that runs generated programs through the\n * `CodeExecutor` port and the engine-owned broker. It owns no acquired\n * resources.\n */\nexport interface CodeModeDefinition<\n  Name extends string,\n  Namespaces extends CodeModeNamespaces,\n  RedactionRequirements = never,\n> {\n  readonly name: Name;\n  /** The assembled model-facing description, optionally including all declarations. */\n  readonly description: string;\n  /** Rendered TypeScript declarations of the sandbox globals (documentation only). */\n  readonly declarations: string;\n  /**\n   * Render complete encoded-schema declarations for 1–64 unique, exact namespace.method names.\n   * The UTF-8 byte limit defaults to 16384 and must be an integer from 1 through 262144.\n   * Oversized documentation fails rather than truncating a declaration. This host operation\n   * does not authorize a model to see the selected methods; filter selections by current\n   * visibility and inherited grants before returning its output to a model.\n   */\n  readonly describe: (\n    methods: ReadonlyArray<string>,\n    options?: { readonly maxBytes?: number | undefined },\n  ) => Effect.Effect<string, CodeModeDescriptionError>;\n  /** The executor-facing namespace catalog derived from the allowlist. */\n  readonly namespaces: ReadonlyArray<CodeExecutionNamespace>;\n  readonly limits: CodeExecutionLimits;\n  readonly maxEgressBytes: number;\n  /** The ordinary Effect AI Tool to include in the model-facing Toolkit. */\n  readonly tool: CodeModeTool<Name>;\n  /** Handler Layer; selected handler requirements stay visible in `R`. */\n  readonly handlers: Layer.Layer<\n    Tool.HandlersFor<CodeModeTools<Name>>,\n    never,\n    CodeModeLayerRequirements<Namespaces, RedactionRequirements>\n  >;\n}\n\nconst defaultLimits = CodeExecutionLimits.make({\n  maxSourceBytes: 256 * 1024,\n  maxWallTime: Duration.seconds(30),\n  maxLogBytes: 256 * 1024,\n  maxResultBytes: 1024 * 1024,\n  maxHostCalls: 64,\n  maxHostCallArgumentBytes: 256 * 1024,\n  maxHostCallResultBytes: 1024 * 1024,\n});\n\nconst defaultMaxEgressBytes = 64 * 1024;\n\n// ---------------------------------------------------------------------------\n// Declaration rendering (capability spec §9.1): the encoded side of each\n// Schema — the JSON that actually crosses the sandbox boundary — rendered as\n// TypeScript documentation via the same JSON-schema derivation Effect AI\n// applies to Tool parameters. A schema the renderer cannot express fails Tool\n// construction closed rather than degrading to `unknown`.\n// ---------------------------------------------------------------------------\n\nconst MAX_RENDER_DEPTH = 24;\n\nconst isJsonSchemaRecord = (value: unknown): value is Record<string, unknown> =>\n  typeof value === \"object\" && value !== null && !Array.isArray(value);\n\nconst renderJsonSchemaType = (\n  schema: unknown,\n  defs: Record<string, unknown>,\n  depth: number,\n  indent: string,\n): string => {\n  if (depth > MAX_RENDER_DEPTH) {\n    throw new Error(\"Code Mode declaration rendering exceeded its depth bound\");\n  }\n  if (!isJsonSchemaRecord(schema)) {\n    throw new Error(`Code Mode cannot render the JSON schema fragment ${JSON.stringify(schema)}`);\n  }\n  const reference = schema.$ref;\n\n  if (typeof reference === \"string\") {\n    const match = /^#\\/\\$defs\\/(.+)$/.exec(reference);\n    // JSON-pointer tokens escape `/` as `~1` and `~` as `~0`.\n    const key = match === null ? undefined : match[1].replaceAll(\"~1\", \"/\").replaceAll(\"~0\", \"~\");\n    const resolved = key === undefined ? undefined : defs[key];\n\n    if (resolved === undefined) {\n      throw new Error(`Code Mode cannot resolve the JSON schema reference ${reference}`);\n    }\n\n    return renderJsonSchemaType(resolved, defs, depth + 1, indent);\n  }\n  if (Array.isArray(schema.enum)) {\n    return schema.enum.map((value) => JSON.stringify(value)).join(\" | \");\n  }\n  if (\"const\" in schema) {\n    return JSON.stringify(schema.const);\n  }\n  const union = schema.anyOf ?? schema.oneOf;\n\n  if (Array.isArray(union)) {\n    return union.map((member) => renderJsonSchemaType(member, defs, depth + 1, indent)).join(\" | \");\n  }\n  const type = schema.type;\n\n  if (Array.isArray(type)) {\n    return type\n      .map((member) => renderJsonSchemaType({ ...schema, type: member }, defs, depth + 1, indent))\n      .join(\" | \");\n  }\n  switch (type) {\n    case \"string\": {\n      return \"string\";\n    }\n    case \"number\":\n    case \"integer\": {\n      return \"number\";\n    }\n    case \"boolean\": {\n      return \"boolean\";\n    }\n    case \"null\": {\n      return \"null\";\n    }\n    case \"array\": {\n      if (!(\"items\" in schema)) {\n        throw new Error(\"Code Mode cannot render an array schema without items\");\n      }\n\n      return `ReadonlyArray<${renderJsonSchemaType(schema.items, defs, depth + 1, indent)}>`;\n    }\n    case \"object\":\n    case undefined: {\n      if (isJsonSchemaRecord(schema.properties)) {\n        const required = Array.isArray(schema.required) ? schema.required : [];\n        const inner = `${indent}  `;\n\n        const fields = Object.entries(schema.properties).map(([key, property]) => {\n          const optional = required.includes(key) ? \"\" : \"?\";\n          // A JSON property name need not be a TypeScript identifier.\n          const rendered = /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key) ? key : JSON.stringify(key);\n\n          return `${inner}readonly ${rendered}${optional}: ${renderJsonSchemaType(property, defs, depth + 1, inner)};`;\n        });\n\n        return fields.length === 0 ? \"{}\" : `{\\n${fields.join(\"\\n\")}\\n${indent}}`;\n      }\n      if (isJsonSchemaRecord(schema.additionalProperties)) {\n        return `Record<string, ${renderJsonSchemaType(schema.additionalProperties, defs, depth + 1, indent)}>`;\n      }\n      // A bare `{ \"type\": \"object\" }` states \"any JSON object\" (Schema.Json's\n      // object member derives to exactly this); rendering it as an\n      // unconstrained record is faithful, not a deriver degradation.\n      if (type === \"object\" && !(\"properties\" in schema) && !(\"additionalProperties\" in schema)) {\n        return \"Record<string, unknown>\";\n      }\n      break;\n    }\n    default: {\n      break;\n    }\n  }\n  throw new Error(\n    `Code Mode cannot render the JSON schema fragment ${JSON.stringify(schema).slice(0, 200)}; fix or simplify the Tool's Schema`,\n  );\n};\n\nconst renderTopLevel = (jsonSchema: unknown, indent: string): string => {\n  const defs =\n    isJsonSchemaRecord(jsonSchema) && isJsonSchemaRecord(jsonSchema.$defs)\n      ? jsonSchema.$defs\n      : ({} as Record<string, unknown>);\n\n  return renderJsonSchemaType(jsonSchema, defs, 0, indent);\n};\n\nconst decodeIdentifier = Schema.decodeUnknownOption(JsIdentifier);\n\ninterface ResolvedMethod {\n  readonly namespace: string;\n  readonly method: string;\n  readonly tool: Tool.Any;\n}\n\nconst renderDeclarations = (methods: ReadonlyArray<ResolvedMethod>): string => {\n  const namespaces = new Map<string, Array<ResolvedMethod>>();\n\n  for (const method of methods) {\n    const existing = namespaces.get(method.namespace) ?? [];\n\n    existing.push(method);\n    namespaces.set(method.namespace, existing);\n  }\n\n  const blocks = [...namespaces.entries()].map(([namespace, members]) => {\n    const lines = members.map((member) => {\n      const parameters = renderTopLevel(Tool.getJsonSchema(member.tool), \"  \");\n      const success = renderTopLevel(Tool.getJsonSchemaFromSchema(member.tool.successSchema), \"  \");\n\n      // A description is arbitrary text: newlines and comment terminators\n      // must not be able to break out of the documentation comment.\n      const safeDescription = member.tool.description\n        ?.replaceAll(\"*/\", \"*\\\\/\")\n        .replaceAll(/\\s*\\n\\s*/g, \" \");\n\n      const description = safeDescription === undefined ? \"\" : `  /** ${safeDescription} */\\n`;\n\n      return `${description}  ${member.method}(input: ${parameters}): Promise<${success}>;`;\n    });\n\n    return `declare const ${namespace}: {\\n${lines.join(\"\\n\")}\\n};`;\n  });\n\n  return blocks.join(\"\\n\\n\");\n};\n\n// ---------------------------------------------------------------------------\n// Aggregate model-visible egress (CAP-016): the final result, captured logs,\n// and any thrown value share one byte budget. Logs are truncated line-by-line\n// with an explicit marker; a result that alone exceeds the budget is a typed\n// failure rather than silent truncation.\n// ---------------------------------------------------------------------------\n\nconst truncationMarker = \"… logs truncated by the egress budget\";\nconst MAX_EGRESS_LOG_LINE_CHARACTERS = 16_000;\n\n/**\n * Budget charge of one log line as it actually crosses to the model: the\n * JSON-encoded string (quotes, escapes) plus one array separator. Charging\n * raw UTF-8 would undercount model-visible bytes for escape-heavy content.\n */\nconst encodedLogLineBytes = (line: string): number => {\n  try {\n    return utf8ByteLength(JSON.stringify(line)) + 1;\n  } catch {\n    return Number.MAX_SAFE_INTEGER;\n  }\n};\n\nconst budgetedLogs = (\n  logs: ReadonlyArray<string>,\n  remainingBytes: number,\n): ReadonlyArray<string> => {\n  const kept: Array<string> = [];\n  let used = 0;\n  let truncated = false;\n\n  for (const raw of logs) {\n    // Per-line cap keeps every kept line inside the BoundedLogLine schema.\n    const line =\n      raw.length > MAX_EGRESS_LOG_LINE_CHARACTERS\n        ? `${raw.slice(0, MAX_EGRESS_LOG_LINE_CHARACTERS - 1)}…`\n        : raw;\n\n    const bytes = encodedLogLineBytes(line);\n\n    if (kept.length >= 4_096 || used + bytes > remainingBytes) {\n      truncated = true;\n      break;\n    }\n    kept.push(line);\n    used += bytes;\n  }\n  if (truncated) {\n    // Truncation is never silent: drop kept lines from the end until the\n    // marker itself fits inside the budget.\n    const markerBytes = encodedLogLineBytes(truncationMarker);\n\n    while (kept.length > 0 && used + markerBytes > remainingBytes) {\n      used -= encodedLogLineBytes(kept.pop() ?? \"\");\n    }\n    if (markerBytes <= remainingBytes) {\n      kept.push(truncationMarker);\n    }\n  }\n\n  return kept;\n};\n\nconst boundedMessage = (message: string): string => message.slice(0, maxFailureTextLength);\n\nconst executionFailureMessage = (error: CodeExecutionError): string => {\n  switch (error._tag) {\n    case \"CodeExecutionTimeoutError\": {\n      return `The program exceeded its ${Duration.format(error.maxWallTime)} ${error.kind} budget`;\n    }\n    case \"CodeOutputLimitError\": {\n      return `The ${error.surface} limit of ${error.limit} bytes was exceeded (${error.observed} bytes observed)`;\n    }\n    case \"CodeHostCallLimitError\": {\n      return `The pass exceeded its executor cap of ${error.limit} host calls`;\n    }\n    default: {\n      return error.message;\n    }\n  }\n};\n\n/** UTF-8-aware truncation so a message can never exceed the aggregate budget. */\nconst truncateToUtf8Bytes = (value: string, maxBytes: number): string => {\n  if (utf8ByteLength(value) <= maxBytes) {\n    return value;\n  }\n  let output = \"\";\n  let used = 0;\n\n  for (const character of value) {\n    const bytes = utf8ByteLength(character);\n\n    if (used + bytes + 3 > maxBytes) {\n      break;\n    }\n    output += character;\n    used += bytes;\n  }\n\n  return `${output}…`;\n};\n\ntype EgressRedactor<Requirements = never> = NonNullable<\n  CodeModeOptions<CodeModeNamespaces, Requirements>[\"redactEgress\"]\n>;\n\n// ---------------------------------------------------------------------------\n// Builder\n// ---------------------------------------------------------------------------\n\nconst make = <\n  const Name extends string,\n  Namespaces extends CodeModeNamespaces,\n  RedactionRequirements = never,\n>(\n  name: Name,\n  options: CodeModeOptions<Namespaces, RedactionRequirements>,\n): CodeModeDefinition<Name, Namespaces, RedactionRequirements> => {\n  const limits = options.limits ?? defaultLimits;\n  const maxEgressBytes = options.maxEgressBytes ?? defaultMaxEgressBytes;\n\n  // Fail closed on an invalid egress bound: NaN would make every size\n  // comparison false and Infinity would remove the bound entirely.\n  if (\n    !Number.isSafeInteger(maxEgressBytes) ||\n    maxEgressBytes < 256 ||\n    maxEgressBytes > 4 * 1024 * 1024\n  ) {\n    throw new Error(\n      `Code Mode maxEgressBytes must be an integer between 256 and ${4 * 1024 * 1024}; received ${String(maxEgressBytes)}`,\n    );\n  }\n\n  // Construction-time fail-closed validation (CAP-014).\n  const methods: Array<ResolvedMethod> = [];\n  const toolsByName = new Map<string, Tool.Any>();\n  const methodToTool = new Map<string, string>();\n\n  for (const [namespace, namespaceMethods] of Object.entries(options.tools)) {\n    if (Option.isNone(decodeIdentifier(namespace))) {\n      throw new Error(`Code Mode namespace ${namespace} is not a valid JavaScript identifier`);\n    }\n    const entries = Object.entries(namespaceMethods);\n\n    if (entries.length === 0) {\n      throw new Error(`Code Mode namespace ${namespace} declares no methods`);\n    }\n    for (const [method, tool] of entries) {\n      if (Option.isNone(decodeIdentifier(method))) {\n        throw new Error(\n          `Code Mode method ${namespace}.${method} is not a valid JavaScript identifier`,\n        );\n      }\n      const approval = tool.needsApproval;\n\n      if (approval !== undefined && approval !== false) {\n        throw new Error(\n          `Code Mode rejects Tool ${tool.name} (${namespace}.${method}): approval-requiring Tools cannot be invoked programmatically in the ephemeral slice`,\n        );\n      }\n      const existing = toolsByName.get(tool.name);\n\n      if (existing !== undefined && existing !== tool) {\n        throw new Error(\n          `Code Mode selected two different Tools named ${tool.name}; Tool names must identify one Tool`,\n        );\n      }\n      toolsByName.set(tool.name, tool);\n      methodToTool.set(`${namespace}.${method}`, tool.name);\n      methods.push({ namespace, method, tool });\n    }\n  }\n  if (methods.length === 0) {\n    throw new Error(\"Code Mode requires at least one allowlisted Tool\");\n  }\n\n  // Declarations derive from the encoded Schemas and fail construction closed\n  // on anything the renderer cannot express.\n  const declarations = renderDeclarations(methods);\n\n  const methodsByPath = new Map(\n    methods.map((method) => [`${method.namespace}.${method.method}`, method]),\n  );\n\n  const describe = Effect.fn(\"CodeMode.describe\")(function* (\n    selected: ReadonlyArray<string>,\n    options?: { readonly maxBytes?: number | undefined },\n  ) {\n    const paths = yield* Schema.decodeEffect(DescriptionMethods)(selected).pipe(\n      Effect.mapError(() =>\n        CodeModeDescriptionError.make({\n          reason: \"invalid-selection\",\n          message:\n            \"Select between 1 and 64 unique namespace.method names, each at most 257 characters\",\n        }),\n      ),\n    );\n\n    const maxBytes = yield* Schema.decodeEffect(DescriptionByteLimit)(\n      options?.maxBytes ?? 16 * 1024,\n    ).pipe(\n      Effect.mapError(() =>\n        CodeModeDescriptionError.make({\n          reason: \"invalid-bound\",\n          message: \"The documentation byte limit must be an integer between 1 and 262144\",\n        }),\n      ),\n    );\n\n    const selectedMethods: Array<ResolvedMethod> = [];\n\n    for (const path of paths) {\n      const method = methodsByPath.get(path);\n\n      if (method === undefined) {\n        return yield* CodeModeDescriptionError.make({\n          reason: \"unknown-method\",\n          message: \"The selection contains a method outside this Code Mode allowlist\",\n        });\n      }\n      selectedMethods.push(method);\n    }\n\n    const documentation = renderDeclarations(selectedMethods);\n\n    if (utf8ByteLength(documentation) > maxBytes) {\n      return yield* CodeModeDescriptionError.make({\n        reason: \"limit-exceeded\",\n        message: `The selected declarations exceed the ${maxBytes}-byte documentation limit; select fewer methods or raise the limit`,\n      });\n    }\n\n    return documentation;\n  });\n\n  const namespaces = [...new Set(methods.map((method) => method.namespace))].map((namespace) =>\n    CodeExecutionNamespace.make({\n      name: namespace,\n      methods: methods\n        .filter((method) => method.namespace === namespace)\n        .map((method) => method.method),\n    }),\n  );\n\n  const description = [\n    options.description,\n    \"\",\n    \"The `code` argument must be one JavaScript async function expression; the sandbox invokes it exactly once with no arguments. It runs isolated with no ambient network, filesystem, environment, or secrets. Return one JSON value. `console.log` output is captured within a bounded budget and returned alongside the result.\",\n    \"Namespace methods return Promises. An expected Tool failure rejects with a JSON envelope carrying a stable `_tag`; catch it to branch. Use Promise.all for independent calls; the host bounds concurrency. Await every call you need. Writes may complete before a failure: inspect call outcomes and never blindly retry a program.\",\n    ...(options.includeDeclarations === false\n      ? []\n      : [\"\", \"Sandbox globals:\", \"```ts\", declarations, \"```\"]),\n  ].join(\"\\n\");\n\n  const tool = Tool.make(name, {\n    description,\n    parameters: CodeModeParameters,\n    success: CodeModeSuccess,\n    failure: CodeModeFailure,\n    failureMode: \"return\",\n  })\n    .annotate(Tool.Readonly, false)\n    .annotate(ToolExecutionClassAnnotation, \"uncertain\")\n    .annotate(IncludesCatalogDocumentation, options.includeDeclarations !== false)\n    .annotate(\n      AdditionalToolCatalog,\n      Object.freeze(methods.map((method) => Object.freeze({ ...method }))),\n    )\n    .addDependency(ToolBroker) as CodeModeTool<Name>;\n\n  const outerToolkit = Toolkit.make(tool);\n\n  /**\n   * The nested namespace record collapses into one Toolkit keyed by exact\n   * Tool names. The assertion restores the name-keyed record type TypeScript\n   * cannot compute from `Map` iteration; construction above guarantees the\n   * name uniqueness the type states.\n   */\n  const selectedToolkit = Toolkit.make(...toolsByName.values()) as unknown as Toolkit.Toolkit<\n    CodeModeSelectedRecord<Namespaces>\n  >;\n\n  const executionRequest = (\n    code: string,\n    visibleNamespaces: ReadonlyArray<CodeExecutionNamespace>,\n  ): CodeExecutionRequest =>\n    CodeExecutionRequest.make({\n      language: \"javascript\",\n      source: code,\n      namespaces: visibleNamespaces,\n      network: NetworkDisabled.make({}),\n      limits,\n    });\n\n  const routeHostCall = (\n    pass: ToolBrokerPass,\n    hostCall: CodeHostCall,\n    visiblePaths: ReadonlySet<string> | undefined,\n  ): Effect.Effect<CodeHostCallResult> =>\n    Effect.gen(function* () {\n      const path = `${hostCall.namespace}.${hostCall.method}`;\n\n      const toolName =\n        visiblePaths === undefined || visiblePaths.has(path) ? methodToTool.get(path) : undefined;\n\n      if (toolName === undefined) {\n        return {\n          _tag: \"CodeHostCallFailure\",\n          error: {\n            _tag: \"UnknownCodeModeMethod\",\n            message: \"The requested method is not available in this pass\",\n          },\n        } as const;\n      }\n\n      const outcome: ProgrammaticCallOutcome = yield* pass.invoke({\n        toolName,\n        encodedArguments: hostCall.argument,\n      });\n\n      switch (outcome._tag) {\n        case \"ProgrammaticCallSuccess\": {\n          const value = decodeBrokerJson(outcome.encodedResult);\n\n          return Option.isSome(value)\n            ? ({ _tag: \"CodeHostCallSuccess\", value: value.value } as const)\n            : ({ _tag: \"CodeHostCallFailure\", error: brokerProtocolEnvelope } as const);\n        }\n        case \"ProgrammaticCallFailure\": {\n          const value = decodeBrokerJson(outcome.encodedResult);\n\n          return {\n            _tag: \"CodeHostCallFailure\",\n            error: Option.isSome(value) ? value.value : brokerProtocolEnvelope,\n          } as const;\n        }\n        case \"ProgrammaticCallError\": {\n          return {\n            _tag: \"CodeHostCallFailure\",\n            error: { _tag: outcome.errorTag, message: outcome.message },\n          } as const;\n        }\n      }\n    });\n\n  const build = Effect.gen(function* () {\n    const captured = yield* Effect.context<never>();\n    const redactionServices = yield* Effect.context<Exclude<RedactionRequirements, Scope.Scope>>();\n    const configuredRedactor = options.redactEgress;\n\n    const redact: EgressRedactor | undefined =\n      configuredRedactor === undefined\n        ? undefined\n        : (egress) =>\n            Effect.scoped(configuredRedactor(egress)).pipe(\n              // Merge invocation-local services before opening the redaction Scope.\n              // The inner Scope shadows any Scope retained in the construction context.\n              Effect.updateContext((current: Context.Context<never>) =>\n                Context.merge(current, redactionServices),\n              ),\n            );\n\n    const withHandler = yield* selectedToolkit;\n    const executor = yield* CodeExecutor;\n\n    const successEgress = (\n      execution: CodeExecutionResult,\n    ): Effect.Effect<CodeModeSuccess, CodeModeFailure> =>\n      Effect.gen(function* () {\n        let egress: { readonly result: Schema.Json; readonly logs: ReadonlyArray<string> } = {\n          result: execution.value,\n          logs: execution.logs,\n        };\n\n        if (redact !== undefined) {\n          egress = yield* redact(egress);\n        }\n        const resultBytes = encodedJsonByteLength(egress.result);\n\n        if (resultBytes === undefined || resultBytes > maxEgressBytes) {\n          return yield* CodeModeFailure.make({\n            errorTag: \"CodeModeEgressExceeded\",\n            message: `The program result of ${resultBytes ?? \"unencodable\"} bytes exceeds the ${maxEgressBytes}-byte model-visible egress budget; return a smaller value`,\n            logs: budgetedLogs(egress.logs, Math.max(0, maxEgressBytes - 256)),\n          });\n        }\n\n        return CodeModeSuccess.make({\n          result: egress.result,\n          logs: budgetedLogs(egress.logs, maxEgressBytes - resultBytes),\n        });\n      });\n\n    /**\n     * The failure half of the aggregate egress policy (CAP-016): the configured\n     * redaction pass covers failure logs and thrown values exactly like success\n     * egress — a program cannot leak by logging and then throwing — and the\n     * message itself is bounded by the budget, not only by its own schema cap.\n     */\n    const failureEgress = (\n      error: CodeExecutionError | ToolBrokerUnavailableError | ToolBrokerConfigurationError,\n    ): Effect.Effect<CodeModeFailure> =>\n      Effect.gen(function* () {\n        if (\n          error._tag === \"ToolBrokerUnavailableError\" ||\n          error._tag === \"ToolBrokerConfigurationError\"\n        ) {\n          return CodeModeFailure.make({\n            errorTag: error._tag,\n            message: truncateToUtf8Bytes(boundedMessage(error.message), maxEgressBytes),\n            logs: [],\n          });\n        }\n        let logs: ReadonlyArray<string> = \"logs\" in error ? error.logs : [];\n        let candidateThrown = error._tag === \"CodeProgramFailedError\" ? error.thrown : undefined;\n\n        if (redact !== undefined) {\n          const redacted = yield* redact({ result: candidateThrown ?? null, logs });\n\n          logs = redacted.logs;\n          candidateThrown = candidateThrown === undefined ? undefined : redacted.result;\n        }\n\n        const message = truncateToUtf8Bytes(\n          boundedMessage(executionFailureMessage(error)),\n          maxEgressBytes,\n        );\n\n        const messageBytes = utf8ByteLength(message);\n\n        // `thrown` is included only when it fits TOGETHER with the message inside\n        // the aggregate budget, and it reduces the log allowance only when it is\n        // actually included.\n        const candidateBytes =\n          candidateThrown === undefined ? undefined : encodedJsonByteLength(candidateThrown);\n\n        const includeThrown =\n          candidateThrown !== undefined &&\n          candidateBytes !== undefined &&\n          messageBytes + candidateBytes <= maxEgressBytes;\n\n        const remaining = Math.max(\n          0,\n          maxEgressBytes - messageBytes - (includeThrown ? (candidateBytes ?? 0) : 0),\n        );\n\n        return CodeModeFailure.make({\n          errorTag: error._tag,\n          message,\n          logs: budgetedLogs(logs, remaining),\n          ...(includeThrown ? { thrown: candidateThrown } : {}),\n        });\n      });\n\n    const invoke = Effect.fn(`CodeMode.${name}`)(function* (parameters: { readonly code: string }) {\n      const broker = yield* ToolBroker;\n      // Resolve invocation authority before restoring captured construction services. A Layer\n      // built under an older Run must not restore that Run's catalogue or hidden method names.\n      const catalogue = yield* Effect.serviceOption(CurrentToolCatalog);\n\n      const visiblePaths = Option.isNone(catalogue)\n        ? undefined\n        : new Set(\n            catalogue.value.entries.flatMap((entry) =>\n              entry.kind === \"code-mode\" &&\n              entry.nativeToolName === name &&\n              methodsByPath.get(`${entry.namespace}.${entry.method}`)?.tool.name === entry.tool.name\n                ? [`${entry.namespace}.${entry.method}`]\n                : [],\n            ),\n          );\n\n      const visibleNamespaces =\n        visiblePaths === undefined\n          ? namespaces\n          : namespaces.flatMap((namespace) => {\n              const allowed = namespace.methods.filter((method) =>\n                visiblePaths.has(`${namespace.name}.${method}`),\n              );\n\n              return allowed.length === 0\n                ? []\n                : [CodeExecutionNamespace.make({ name: namespace.name, methods: allowed })];\n            });\n\n      let calls: ReadonlyArray<ProgrammaticCallRecord> = [];\n\n      const execution = Effect.gen(function* () {\n        const pass = yield* broker.openPass(withHandler, {\n          maxResultBytes: limits.maxHostCallResultBytes,\n          concurrency: limits.maxHostCallConcurrency ?? 4,\n        });\n\n        const host = CodeExecutionHost.of({\n          call: (hostCall) => routeHostCall(pass, hostCall, visiblePaths),\n        });\n\n        return yield* executor.execute(executionRequest(parameters.code, visibleNamespaces)).pipe(\n          Effect.provideService(CodeExecutionHost, host),\n          Effect.scoped,\n          Effect.onExit((exit) =>\n            Effect.gen(function* () {\n              calls = yield* pass.snapshot;\n              if (options.onPassExit !== undefined) {\n                yield* Effect.scoped(\n                  options.onPassExit({\n                    status: Exit.isSuccess(exit)\n                      ? \"completed\"\n                      : Cause.hasInterrupts(exit.cause)\n                        ? \"interrupted\"\n                        : Cause.hasDies(exit.cause)\n                          ? \"defect\"\n                          : \"failed\",\n                    calls,\n                  }),\n                ).pipe(Effect.provideContext(redactionServices));\n              }\n            }),\n          ),\n        );\n      }).pipe(\n        Effect.scoped,\n        // The live engine broker is re-provided innermost so a Layer built\n        // inside another Run can never shadow it; the captured construction\n        // context supplies the selected handlers' services (same idiom as\n        // Subagent.layer). TypeScript cannot reduce the deferred Exclude\n        // over the generic namespace record, so the same private-assertion\n        // contract as the engine's provideHookServices pins the identity\n        // that providing the captured Context leaves no requirements; it\n        // never bypasses validation.\n        Effect.provideService(ToolBroker, broker),\n        Effect.provideContext(captured),\n      ) as Effect.Effect<\n        CodeExecutionResult,\n        CodeExecutionError | ToolBrokerUnavailableError | ToolBrokerConfigurationError\n      >;\n\n      return yield* execution.pipe(\n        Effect.catch((error) => failureEgress(error).pipe(Effect.flatMap(Effect.fail))),\n        Effect.flatMap(successEgress),\n        Effect.mapError((failure) => {\n          if (calls.length === 0) return failure;\n\n          const complete = CodeModeFailure.make({\n            errorTag: failure.errorTag,\n            message: failure.message,\n            logs: failure.logs,\n            ...(failure.thrown === undefined ? {} : { thrown: failure.thrown }),\n            calls,\n            omittedCalls: 0,\n          });\n\n          if ((encodedJsonByteLength(complete) ?? Infinity) <= maxEgressBytes) return complete;\n\n          // Evidence takes priority over logs and thrown values. Never silently omit calls.\n          const base = {\n            errorTag: failure.errorTag,\n            message: truncateToUtf8Bytes(failure.message, Math.min(256, maxEgressBytes / 4)),\n            logs: [],\n          };\n\n          const kept: Array<ProgrammaticCallRecord> = [];\n\n          for (const call of calls) {\n            const candidate = CodeModeFailure.make({\n              ...base,\n              calls: [...kept, call],\n              omittedCalls: calls.length - kept.length - 1,\n            });\n\n            if ((encodedJsonByteLength(candidate) ?? Infinity) > maxEgressBytes) break;\n            kept.push(call);\n          }\n\n          return CodeModeFailure.make({\n            ...base,\n            calls: kept,\n            omittedCalls: calls.length - kept.length,\n          });\n        }),\n      );\n    });\n\n    return { [name]: invoke } as unknown as Toolkit.HandlersFrom<CodeModeTools<Name>>;\n  });\n\n  /**\n   * TypeScript cannot unify the two spellings of the singleton Tool record\n   * (`CodeModeTools<Name>` versus the toolkit's name-remapped form) over a\n   * generic `Name`, nor reduce the deferred `Exclude` when `toLayer`\n   * subtracts what `build` consumed; the assertions pin the layer to its\n   * documented requirement surface and never bypass validation.\n   */\n  const handlers = outerToolkit.toLayer(\n    build as unknown as Effect.Effect<\n      Toolkit.HandlersFrom<Toolkit.ToolsByName<readonly [CodeModeTool<Name>]>>,\n      never,\n      | CodeExecutor\n      | Tool.HandlersFor<CodeModeSelectedRecord<Namespaces>>\n      | Exclude<RedactionRequirements, Scope.Scope>\n    >,\n  ) as unknown as Layer.Layer<\n    Tool.HandlersFor<CodeModeTools<Name>>,\n    never,\n    CodeModeLayerRequirements<Namespaces, RedactionRequirements>\n  >;\n\n  return Object.freeze({\n    name,\n    description,\n    declarations,\n    describe,\n    namespaces,\n    limits,\n    maxEgressBytes,\n    tool,\n    handlers,\n  });\n};\n\n/**\n * Fail-closed JSON boundary for broker outcomes: hostile values can throw\n * from trap getters during decode, and a value outside the JSON surface must\n * become a typed failure envelope — never a fabricated success.\n */\nconst decodeBrokerJson = (value: unknown): Option.Option<Schema.Json> => {\n  try {\n    return Schema.decodeUnknownOption(Schema.Json)(value);\n  } catch {\n    return Option.none();\n  }\n};\n\nconst brokerProtocolEnvelope: Schema.Json = {\n  _tag: \"CodeModeProtocolError\",\n  message: \"The broker returned a value outside the JSON surface\",\n};\n\n// The engine annotation is imported under a local alias to keep the builder\n// readable next to Effect AI's own `Tool.Readonly` annotation.\nimport { ToolExecutionClass as ToolExecutionClassAnnotation } from \"../engine/DurableStep.ts\";\n\n/** Code Mode builder namespace (capability spec §9.1). */\nexport { make };\n"],"mappings":"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"}