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

package/dist/sandbox/CodeExecutor.d.mts

@@ -0,0 +1,194 @@
+import { n as NetworkDisabled, p as SandboxImplementation, t as NetworkAllowlist } from "../Sandbox-CEsDWBLq.mjs";
+import { Context, Duration, Effect, Schema, Scope } from "effect";
+declare namespace CodeExecutor_d_exports {
+  export { CodeExecutionError, CodeExecutionHost, CodeExecutionLimits, CodeExecutionNamespace, CodeExecutionProtocolError, CodeExecutionRequest, CodeExecutionResourceUse, CodeExecutionResult, CodeExecutionTimeoutError, CodeExecutor, CodeExecutorExecute, CodeExecutorStartError, CodeExecutorTerminatedError, CodeExecutorUnsupportedError, CodeHostCall, CodeHostCallFailure, CodeHostCallLimitError, CodeHostCallResult, CodeHostCallSuccess, CodeOutputLimitError, CodeProgramFailedError, CodeSourceError, JsIdentifier };
+}
+/** A JavaScript identifier safe to bind as a sandbox global or method name. */
+declare const JsIdentifier: Schema.refine<string, Schema.NonEmptyString>;
+type JsIdentifier = typeof JsIdentifier.Type;
+declare const CodeExecutionNamespace_base: Schema.Class<CodeExecutionNamespace, Schema.Struct<{
+  readonly name: Schema.refine<string, Schema.NonEmptyString>;
+  readonly methods: Schema.$Array<Schema.refine<string, Schema.NonEmptyString>>;
+}>, {}>;
+/** One callable namespace exposed to the generated program as a typed global. */
+declare class CodeExecutionNamespace extends CodeExecutionNamespace_base {}
+declare const CodeExecutionLimits_base: Schema.Class<CodeExecutionLimits, Schema.Struct<{
+  readonly maxSourceBytes: Schema.Int;
+  readonly maxWallTime: Schema.refine<Duration.Duration, Schema.Duration>;
+  readonly cpuMillis: Schema.optionalKey<Schema.Int>;
+  readonly maxLogBytes: Schema.Int;
+  readonly maxResultBytes: Schema.Int;
+  readonly maxHostCalls: Schema.Natural;
+  /** Maximum active host calls per pass; defaults to four. Excess calls wait in Scope. */
+  readonly maxHostCallConcurrency: Schema.optionalKey<Schema.Int>;
+  readonly maxHostCallArgumentBytes: Schema.Int;
+  readonly maxHostCallResultBytes: Schema.Int;
+}>, {}>;
+/**
+ * Limits an executor must either enforce or reject (CAP-015). Byte bounds are
+ * measured on UTF-8 encoded JSON at the sandbox boundary.
+ */
+declare class CodeExecutionLimits extends CodeExecutionLimits_base {}
+declare const CodeExecutionRequest_base: Schema.Class<CodeExecutionRequest, Schema.Struct<{
+  readonly language: Schema.Literals<readonly ["javascript"]>;
+  readonly source: Schema.String;
+  readonly namespaces: Schema.$Array<typeof CodeExecutionNamespace>;
+  readonly network: Schema.Union<readonly [typeof NetworkDisabled, typeof NetworkAllowlist]>;
+  readonly limits: typeof CodeExecutionLimits;
+}>, {}>;
+/**
+ * One isolated execution pass over bounded generated JavaScript. The source
+ * must be a single expression evaluating to one async function; the executor
+ * harness invokes it exactly once with no arguments (ADR-0017 decision 5).
+ */
+declare class CodeExecutionRequest extends CodeExecutionRequest_base {}
+declare const CodeHostCall_base: Schema.Class<CodeHostCall, Schema.Struct<{
+  readonly namespace: Schema.refine<string, Schema.NonEmptyString>;
+  readonly method: Schema.refine<string, Schema.NonEmptyString>;
+  readonly argument: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+}>, {}>;
+/** One host invocation from generated code. Data only: the broker owns identity. */
+declare class CodeHostCall extends CodeHostCall_base {}
+declare const CodeHostCallSuccess_base: Schema.Class<CodeHostCallSuccess, Schema.TaggedStruct<"CodeHostCallSuccess", {
+  readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+}>, {}>;
+/** A host call settled with the encoded Tool success value. */
+declare class CodeHostCallSuccess extends CodeHostCallSuccess_base {}
+declare const CodeHostCallFailure_base: Schema.Class<CodeHostCallFailure, Schema.TaggedStruct<"CodeHostCallFailure", {
+  readonly error: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+}>, {}>;
+/**
+ * A host call settled with a Schema-encoded typed failure envelope. Inside the
+ * generated program the call's Promise rejects with the envelope value, so a
+ * program can catch and branch on expected failures.
+ */
+declare class CodeHostCallFailure extends CodeHostCallFailure_base {}
+/** Outcome of one host call as data; transport failures stay executor errors. */
+declare const CodeHostCallResult: Schema.Union<readonly [typeof CodeHostCallSuccess, typeof CodeHostCallFailure]>;
+type CodeHostCallResult = typeof CodeHostCallResult.Type;
+declare const CodeExecutionHost_base: Context.ServiceClass<CodeExecutionHost, "@effect-agent/sandbox/CodeExecutionHost", {
+  readonly call: (call: CodeHostCall) => Effect.Effect<CodeHostCallResult>;
+}>;
+/**
+ * The per-pass host capability: the only authority generated code has over the
+ * host. It is provided at the pass edge by the capability layer, its live
+ * bindings are scoped resources, and it is never persisted (ADR-0017
+ * decision 2). Broker-level failures return as `CodeHostCallFailure` data;
+ * an unexpected host defect remains a defect.
+ */
+declare class CodeExecutionHost extends CodeExecutionHost_base {}
+declare const CodeExecutionResourceUse_base: Schema.Class<CodeExecutionResourceUse, Schema.Struct<{
+  readonly wallTime: Schema.refine<Duration.Duration, Schema.Duration>;
+  readonly hostCalls: Schema.Natural;
+  readonly logBytes: Schema.Natural;
+  readonly resultBytes: Schema.Natural;
+  readonly cpuMillis: Schema.optionalKey<Schema.Natural>;
+}>, {}>;
+/** Accounting one executor observed for one pass. */
+declare class CodeExecutionResourceUse extends CodeExecutionResourceUse_base {}
+declare const CodeExecutionResult_base: Schema.Class<CodeExecutionResult, Schema.Struct<{
+  readonly implementation: typeof SandboxImplementation;
+  readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+  readonly logs: Schema.$Array<Schema.String>;
+  readonly resourceUse: typeof CodeExecutionResourceUse;
+}>, {}>;
+/**
+ * The bounded outcome of one successful pass. `value` and `logs` are the raw
+ * executor capture; the aggregate model-visible egress budget and redaction
+ * pass are owned by the Code Mode capability, not the executor (CAP-016).
+ */
+declare class CodeExecutionResult extends CodeExecutionResult_base {}
+declare const CodeSourceError_base: Schema.Class<CodeSourceError, Schema.TaggedStruct<"CodeSourceError", {
+  readonly implementation: typeof SandboxImplementation;
+  readonly reason: Schema.Literals<readonly ["invalid", "oversized", "not-a-function"]>;
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** The source is not one async function expression the executor can run. */
+declare class CodeSourceError extends CodeSourceError_base {}
+declare const CodeExecutorUnsupportedError_base: Schema.Class<CodeExecutorUnsupportedError, Schema.TaggedStruct<"CodeExecutorUnsupportedError", {
+  readonly implementation: typeof SandboxImplementation;
+  readonly feature: Schema.Literals<readonly ["language", "network", "cpu-limit", "namespaces", "wall-clock", "host-calls"]>;
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** The executor cannot honestly enforce one requested feature, limit, or policy. */
+declare class CodeExecutorUnsupportedError extends CodeExecutorUnsupportedError_base {}
+declare const CodeExecutorStartError_base: Schema.Class<CodeExecutorStartError, Schema.TaggedStruct<"CodeExecutorStartError", {
+  readonly implementation: typeof SandboxImplementation;
+  readonly message: Schema.String;
+  readonly cause: Schema.optionalKey<Schema.Defect>;
+}>, import("effect/Cause").YieldableError>;
+/** The executor could not start the isolated pass. */
+declare class CodeExecutorStartError extends CodeExecutorStartError_base {}
+declare const CodeExecutionTimeoutError_base: Schema.Class<CodeExecutionTimeoutError, Schema.TaggedStruct<"CodeExecutionTimeoutError", {
+  readonly implementation: typeof SandboxImplementation;
+  readonly kind: Schema.Literals<readonly ["cpu", "wall-clock"]>;
+  readonly maxWallTime: Schema.refine<Duration.Duration, Schema.Duration>;
+  readonly logs: Schema.$Array<Schema.String>;
+}>, import("effect/Cause").YieldableError>;
+/** The pass exceeded its CPU or wall-clock budget and was terminated. */
+declare class CodeExecutionTimeoutError extends CodeExecutionTimeoutError_base {}
+declare const CodeOutputLimitError_base: Schema.Class<CodeOutputLimitError, Schema.TaggedStruct<"CodeOutputLimitError", {
+  readonly implementation: typeof SandboxImplementation;
+  readonly surface: Schema.Literals<readonly ["logs", "result", "host-call-argument", "host-call-result"]>;
+  readonly limit: Schema.Int;
+  readonly observed: Schema.Natural;
+  readonly logs: Schema.$Array<Schema.String>;
+}>, import("effect/Cause").YieldableError>;
+/** A bounded surface (logs, result, or a per-call byte bound) was exceeded. */
+declare class CodeOutputLimitError extends CodeOutputLimitError_base {}
+declare const CodeHostCallLimitError_base: Schema.Class<CodeHostCallLimitError, Schema.TaggedStruct<"CodeHostCallLimitError", {
+  readonly implementation: typeof SandboxImplementation;
+  readonly limit: Schema.Natural;
+  readonly logs: Schema.$Array<Schema.String>;
+}>, import("effect/Cause").YieldableError>;
+/** The pass issued more host calls than its executor-owned cap allows. */
+declare class CodeHostCallLimitError extends CodeHostCallLimitError_base {}
+declare const CodeProgramFailedError_base: Schema.Class<CodeProgramFailedError, Schema.TaggedStruct<"CodeProgramFailedError", {
+  readonly implementation: typeof SandboxImplementation;
+  readonly reason: Schema.Literals<readonly ["threw", "rejected", "non-json-result"]>;
+  readonly thrown: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+  readonly message: Schema.String;
+  readonly logs: Schema.$Array<Schema.String>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * The generated program finished by failing: it threw, its promise rejected,
+ * or it returned a value that is not JSON. The bounded thrown value and log
+ * capture flow back so a model can correct the program without a blind retry.
+ */
+declare class CodeProgramFailedError extends CodeProgramFailedError_base {}
+declare const CodeExecutionProtocolError_base: Schema.Class<CodeExecutionProtocolError, Schema.TaggedStruct<"CodeExecutionProtocolError", {
+  readonly implementation: typeof SandboxImplementation;
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** The executor or its transport produced a value outside the protocol Schemas. */
+declare class CodeExecutionProtocolError extends CodeExecutionProtocolError_base {}
+declare const CodeExecutorTerminatedError_base: Schema.Class<CodeExecutorTerminatedError, Schema.TaggedStruct<"CodeExecutorTerminatedError", {
+  readonly implementation: typeof SandboxImplementation;
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * The pass was terminated externally — isolate eviction or a platform kill —
+ * with no terminal program result. No result is fabricated.
+ */
+declare class CodeExecutorTerminatedError extends CodeExecutorTerminatedError_base {}
+/** Expected Code Mode execution failures. Interruption stays an Effect interruption. */
+declare const CodeExecutionError: Schema.Union<readonly [typeof CodeSourceError, typeof CodeExecutorUnsupportedError, typeof CodeExecutorStartError, typeof CodeExecutionTimeoutError, typeof CodeOutputLimitError, typeof CodeHostCallLimitError, typeof CodeProgramFailedError, typeof CodeExecutionProtocolError, typeof CodeExecutorTerminatedError]>;
+type CodeExecutionError = typeof CodeExecutionError.Type;
+declare const CodeExecutor_base: Context.ServiceClass<CodeExecutor, "@effect-agent/sandbox/CodeExecutor", {
+  readonly execute: (request: CodeExecutionRequest) => Effect.Effect<CodeExecutionResult, CodeExecutionError, Scope.Scope | CodeExecutionHost>;
+}>;
+/**
+ * Callback-capable isolated execution port for Code Mode (ADR-0017), a sibling
+ * of the command-shaped `Sandbox` service. One `execute` is one stateless pass:
+ * the executor owns no approval, Tool, replay, or Thread semantics, holds
+ * every pass resource in the given Scope, and reaches the host only through the
+ * `CodeExecutionHost` service in its requirement channel. Implementations must
+ * identify their isolation posture honestly; an `unisolated` executor is never
+ * a security boundary (CAP-010, CAP-015).
+ */
+declare class CodeExecutor extends CodeExecutor_base {}
+/** Type helper for implementations that preserve the public CodeExecutor contract. */
+type CodeExecutorExecute = (request: CodeExecutionRequest) => Effect.Effect<CodeExecutionResult, CodeExecutionError, Scope.Scope | CodeExecutionHost>;
+//#endregion
+export { CodeExecutionError, CodeExecutionHost, CodeExecutionLimits, CodeExecutionNamespace, CodeExecutionProtocolError, CodeExecutionRequest, CodeExecutionResourceUse, CodeExecutionResult, CodeExecutionTimeoutError, CodeExecutor, CodeExecutorExecute, CodeExecutorStartError, CodeExecutorTerminatedError, CodeExecutorUnsupportedError, CodeHostCall, CodeHostCallFailure, CodeHostCallLimitError, CodeHostCallResult, CodeHostCallSuccess, CodeOutputLimitError, CodeProgramFailedError, CodeSourceError, JsIdentifier, CodeExecutor_d_exports as t };
+//# sourceMappingURL=CodeExecutor.d.mts.map

package/dist/sandbox/CodeExecutor.mjs

@@ -0,0 +1,278 @@
+import { t as __exportAll } from "../rolldown-runtime-D7D4PA-g.mjs";
+import { SANDBOX_DIAGNOSTIC_MAX_LENGTH, SandboxImplementation, SandboxNetworkPolicy } from "./Sandbox.mjs";
+import { Context, Duration, Schema } from "effect";
+//#region src/sandbox/CodeExecutor.ts
+var CodeExecutor_exports = /* @__PURE__ */ __exportAll({
+	CodeExecutionError: () => CodeExecutionError,
+	CodeExecutionHost: () => CodeExecutionHost,
+	CodeExecutionLimits: () => CodeExecutionLimits,
+	CodeExecutionNamespace: () => CodeExecutionNamespace,
+	CodeExecutionProtocolError: () => CodeExecutionProtocolError,
+	CodeExecutionRequest: () => CodeExecutionRequest,
+	CodeExecutionResourceUse: () => CodeExecutionResourceUse,
+	CodeExecutionResult: () => CodeExecutionResult,
+	CodeExecutionTimeoutError: () => CodeExecutionTimeoutError,
+	CodeExecutor: () => CodeExecutor,
+	CodeExecutorStartError: () => CodeExecutorStartError,
+	CodeExecutorTerminatedError: () => CodeExecutorTerminatedError,
+	CodeExecutorUnsupportedError: () => CodeExecutorUnsupportedError,
+	CodeHostCall: () => CodeHostCall,
+	CodeHostCallFailure: () => CodeHostCallFailure,
+	CodeHostCallLimitError: () => CodeHostCallLimitError,
+	CodeHostCallResult: () => CodeHostCallResult,
+	CodeHostCallSuccess: () => CodeHostCallSuccess,
+	CodeOutputLimitError: () => CodeOutputLimitError,
+	CodeProgramFailedError: () => CodeProgramFailedError,
+	CodeSourceError: () => CodeSourceError,
+	JsIdentifier: () => JsIdentifier
+});
+const BoundedLogLine = Schema.String.check(Schema.isMaxLength(16384));
+const BoundedMessage = Schema.String.check(Schema.isMaxLength(SANDBOX_DIAGNOSTIC_MAX_LENGTH));
+const BoundedLogs = Schema.Array(BoundedLogLine).check(Schema.isMaxLength(4096));
+const BoundedSourceText = Schema.String.check(Schema.isMaxLength(4194304));
+const PositiveInt = Schema.Int.check(Schema.isGreaterThan(0));
+const FinitePositiveDuration = Schema.Duration.pipe(Schema.refine((duration) => Duration.isFinite(duration) && Duration.isPositive(duration), { expected: "a finite positive duration" }));
+const FiniteNonNegativeDuration = Schema.Duration.pipe(Schema.refine((duration) => Duration.isFinite(duration) && !Duration.isNegative(duration), { expected: "a finite non-negative duration" }));
+/**
+* ECMAScript reserved words are rejected up front: a namespace or method that
+* needs one would make every harness that binds identifiers fail at runtime
+* instead of failing closed at the Schema boundary.
+*/
+const reservedIdentifiers = /* @__PURE__ */ new Set([
+	"arguments",
+	"await",
+	"break",
+	"case",
+	"catch",
+	"class",
+	"const",
+	"continue",
+	"debugger",
+	"default",
+	"delete",
+	"do",
+	"else",
+	"enum",
+	"eval",
+	"export",
+	"extends",
+	"false",
+	"finally",
+	"for",
+	"function",
+	"if",
+	"implements",
+	"import",
+	"in",
+	"instanceof",
+	"interface",
+	"let",
+	"new",
+	"null",
+	"package",
+	"private",
+	"protected",
+	"public",
+	"return",
+	"static",
+	"super",
+	"switch",
+	"this",
+	"throw",
+	"true",
+	"try",
+	"typeof",
+	"var",
+	"void",
+	"while",
+	"with",
+	"yield"
+]);
+/** A JavaScript identifier safe to bind as a sandbox global or method name. */
+const JsIdentifier = Schema.NonEmptyString.check(Schema.isMaxLength(128), Schema.isPattern(/^[A-Za-z_$][A-Za-z0-9_$]*$/)).pipe(Schema.refine((value) => !reservedIdentifiers.has(value), { expected: "a JavaScript identifier that is not a reserved word" }));
+/** One callable namespace exposed to the generated program as a typed global. */
+var CodeExecutionNamespace = class extends Schema.Class("CodeExecutionNamespace")({
+	name: JsIdentifier,
+	methods: Schema.Array(JsIdentifier).check(Schema.isMaxLength(64), Schema.isMinLength(1))
+}) {};
+/**
+* Limits an executor must either enforce or reject (CAP-015). Byte bounds are
+* measured on UTF-8 encoded JSON at the sandbox boundary.
+*/
+var CodeExecutionLimits = class extends Schema.Class("CodeExecutionLimits")({
+	maxSourceBytes: PositiveInt.check(Schema.isLessThanOrEqualTo(4194304)),
+	maxWallTime: FinitePositiveDuration,
+	cpuMillis: Schema.optionalKey(PositiveInt.check(Schema.isLessThanOrEqualTo(3e5))),
+	maxLogBytes: PositiveInt.check(Schema.isLessThanOrEqualTo(1048576)),
+	maxResultBytes: PositiveInt.check(Schema.isLessThanOrEqualTo(4194304)),
+	maxHostCalls: Schema.Natural.check(Schema.isLessThanOrEqualTo(1e4)),
+	/** Maximum active host calls per pass; defaults to four. Excess calls wait in Scope. */
+	maxHostCallConcurrency: Schema.optionalKey(PositiveInt.check(Schema.isLessThanOrEqualTo(64))),
+	maxHostCallArgumentBytes: PositiveInt.check(Schema.isLessThanOrEqualTo(1048576)),
+	maxHostCallResultBytes: PositiveInt.check(Schema.isLessThanOrEqualTo(4194304))
+}) {};
+/**
+* One isolated execution pass over bounded generated JavaScript. The source
+* must be a single expression evaluating to one async function; the executor
+* harness invokes it exactly once with no arguments (ADR-0017 decision 5).
+*/
+var CodeExecutionRequest = class extends Schema.Class("CodeExecutionRequest")({
+	language: Schema.Literals(["javascript"]),
+	source: BoundedSourceText,
+	namespaces: Schema.Array(CodeExecutionNamespace).check(Schema.isMaxLength(32)),
+	network: SandboxNetworkPolicy,
+	limits: CodeExecutionLimits
+}) {};
+/** One host invocation from generated code. Data only: the broker owns identity. */
+var CodeHostCall = class extends Schema.Class("CodeHostCall")({
+	namespace: JsIdentifier,
+	method: JsIdentifier,
+	argument: Schema.Json
+}) {};
+/** A host call settled with the encoded Tool success value. */
+var CodeHostCallSuccess = class extends Schema.TaggedClass()("CodeHostCallSuccess", { value: Schema.Json }) {};
+/**
+* A host call settled with a Schema-encoded typed failure envelope. Inside the
+* generated program the call's Promise rejects with the envelope value, so a
+* program can catch and branch on expected failures.
+*/
+var CodeHostCallFailure = class extends Schema.TaggedClass()("CodeHostCallFailure", { error: Schema.Json }) {};
+/** Outcome of one host call as data; transport failures stay executor errors. */
+const CodeHostCallResult = Schema.Union([CodeHostCallSuccess, CodeHostCallFailure]);
+/**
+* The per-pass host capability: the only authority generated code has over the
+* host. It is provided at the pass edge by the capability layer, its live
+* bindings are scoped resources, and it is never persisted (ADR-0017
+* decision 2). Broker-level failures return as `CodeHostCallFailure` data;
+* an unexpected host defect remains a defect.
+*/
+var CodeExecutionHost = class extends Context.Service()("@effect-agent/sandbox/CodeExecutionHost") {};
+/** Accounting one executor observed for one pass. */
+var CodeExecutionResourceUse = class extends Schema.Class("CodeExecutionResourceUse")({
+	wallTime: FiniteNonNegativeDuration,
+	hostCalls: Schema.Natural,
+	logBytes: Schema.Natural,
+	resultBytes: Schema.Natural,
+	cpuMillis: Schema.optionalKey(Schema.Natural)
+}) {};
+/**
+* The bounded outcome of one successful pass. `value` and `logs` are the raw
+* executor capture; the aggregate model-visible egress budget and redaction
+* pass are owned by the Code Mode capability, not the executor (CAP-016).
+*/
+var CodeExecutionResult = class extends Schema.Class("CodeExecutionResult")({
+	implementation: SandboxImplementation,
+	value: Schema.Json,
+	logs: BoundedLogs,
+	resourceUse: CodeExecutionResourceUse
+}) {};
+/** The source is not one async function expression the executor can run. */
+var CodeSourceError = class extends Schema.TaggedError()("CodeSourceError", {
+	implementation: SandboxImplementation,
+	reason: Schema.Literals([
+		"invalid",
+		"oversized",
+		"not-a-function"
+	]),
+	message: BoundedMessage
+}) {};
+/** The executor cannot honestly enforce one requested feature, limit, or policy. */
+var CodeExecutorUnsupportedError = class extends Schema.TaggedError()("CodeExecutorUnsupportedError", {
+	implementation: SandboxImplementation,
+	feature: Schema.Literals([
+		"language",
+		"network",
+		"cpu-limit",
+		"namespaces",
+		"wall-clock",
+		"host-calls"
+	]),
+	message: BoundedMessage
+}) {};
+/** The executor could not start the isolated pass. */
+var CodeExecutorStartError = class extends Schema.TaggedError()("CodeExecutorStartError", {
+	implementation: SandboxImplementation,
+	message: BoundedMessage,
+	cause: Schema.optionalKey(Schema.Defect())
+}) {};
+/** The pass exceeded its CPU or wall-clock budget and was terminated. */
+var CodeExecutionTimeoutError = class extends Schema.TaggedError()("CodeExecutionTimeoutError", {
+	implementation: SandboxImplementation,
+	kind: Schema.Literals(["cpu", "wall-clock"]),
+	maxWallTime: FinitePositiveDuration,
+	logs: BoundedLogs
+}) {};
+/** A bounded surface (logs, result, or a per-call byte bound) was exceeded. */
+var CodeOutputLimitError = class extends Schema.TaggedError()("CodeOutputLimitError", {
+	implementation: SandboxImplementation,
+	surface: Schema.Literals([
+		"logs",
+		"result",
+		"host-call-argument",
+		"host-call-result"
+	]),
+	limit: PositiveInt,
+	observed: Schema.Natural,
+	logs: BoundedLogs
+}) {};
+/** The pass issued more host calls than its executor-owned cap allows. */
+var CodeHostCallLimitError = class extends Schema.TaggedError()("CodeHostCallLimitError", {
+	implementation: SandboxImplementation,
+	limit: Schema.Natural,
+	logs: BoundedLogs
+}) {};
+/**
+* The generated program finished by failing: it threw, its promise rejected,
+* or it returned a value that is not JSON. The bounded thrown value and log
+* capture flow back so a model can correct the program without a blind retry.
+*/
+var CodeProgramFailedError = class extends Schema.TaggedError()("CodeProgramFailedError", {
+	implementation: SandboxImplementation,
+	reason: Schema.Literals([
+		"threw",
+		"rejected",
+		"non-json-result"
+	]),
+	thrown: Schema.Json,
+	message: BoundedMessage,
+	logs: BoundedLogs
+}) {};
+/** The executor or its transport produced a value outside the protocol Schemas. */
+var CodeExecutionProtocolError = class extends Schema.TaggedError()("CodeExecutionProtocolError", {
+	implementation: SandboxImplementation,
+	message: BoundedMessage
+}) {};
+/**
+* The pass was terminated externally — isolate eviction or a platform kill —
+* with no terminal program result. No result is fabricated.
+*/
+var CodeExecutorTerminatedError = class extends Schema.TaggedError()("CodeExecutorTerminatedError", {
+	implementation: SandboxImplementation,
+	message: BoundedMessage
+}) {};
+/** Expected Code Mode execution failures. Interruption stays an Effect interruption. */
+const CodeExecutionError = Schema.Union([
+	CodeSourceError,
+	CodeExecutorUnsupportedError,
+	CodeExecutorStartError,
+	CodeExecutionTimeoutError,
+	CodeOutputLimitError,
+	CodeHostCallLimitError,
+	CodeProgramFailedError,
+	CodeExecutionProtocolError,
+	CodeExecutorTerminatedError
+]);
+/**
+* Callback-capable isolated execution port for Code Mode (ADR-0017), a sibling
+* of the command-shaped `Sandbox` service. One `execute` is one stateless pass:
+* the executor owns no approval, Tool, replay, or Thread semantics, holds
+* every pass resource in the given Scope, and reaches the host only through the
+* `CodeExecutionHost` service in its requirement channel. Implementations must
+* identify their isolation posture honestly; an `unisolated` executor is never
+* a security boundary (CAP-010, CAP-015).
+*/
+var CodeExecutor = class extends Context.Service()("@effect-agent/sandbox/CodeExecutor") {};
+//#endregion
+export { CodeExecutionError, CodeExecutionHost, CodeExecutionLimits, CodeExecutionNamespace, CodeExecutionProtocolError, CodeExecutionRequest, CodeExecutionResourceUse, CodeExecutionResult, CodeExecutionTimeoutError, CodeExecutor, CodeExecutorStartError, CodeExecutorTerminatedError, CodeExecutorUnsupportedError, CodeHostCall, CodeHostCallFailure, CodeHostCallLimitError, CodeHostCallResult, CodeHostCallSuccess, CodeOutputLimitError, CodeProgramFailedError, CodeSourceError, JsIdentifier, CodeExecutor_exports as t };
+
+//# sourceMappingURL=CodeExecutor.mjs.map

package/dist/sandbox/CodeExecutor.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"CodeExecutor.mjs","names":[],"sources":["../../src/sandbox/CodeExecutor.ts"],"sourcesContent":["import { Context, Duration, Schema, type Effect, type Scope } from \"effect\";\n\nimport {\n  SANDBOX_DIAGNOSTIC_MAX_LENGTH,\n  SandboxImplementation,\n  SandboxNetworkPolicy,\n} from \"./Sandbox.ts\";\n\n// Schema `isMaxLength` counts UTF-16 string elements: these caps are\n// transport sanity bounds, not byte budgets. The authoritative byte budgets\n// are the `CodeExecutionLimits` fields, which every adapter enforces on the\n// UTF-8 encoded values (CAP-015); a multibyte payload therefore hits its\n// configured byte limit well before any of these element-count caps.\nconst BoundedLogLine = Schema.String.check(Schema.isMaxLength(16 * 1024));\nconst BoundedMessage = Schema.String.check(Schema.isMaxLength(SANDBOX_DIAGNOSTIC_MAX_LENGTH));\nconst BoundedLogs = Schema.Array(BoundedLogLine).check(Schema.isMaxLength(4_096));\nconst BoundedSourceText = Schema.String.check(Schema.isMaxLength(4 * 1024 * 1024));\nconst PositiveInt = Schema.Int.check(Schema.isGreaterThan(0));\n\nconst FinitePositiveDuration = Schema.Duration.pipe(\n  Schema.refine(\n    (duration): duration is Duration.Duration =>\n      Duration.isFinite(duration) && Duration.isPositive(duration),\n    { expected: \"a finite positive duration\" },\n  ),\n);\n\nconst FiniteNonNegativeDuration = Schema.Duration.pipe(\n  Schema.refine(\n    (duration): duration is Duration.Duration =>\n      Duration.isFinite(duration) && !Duration.isNegative(duration),\n    { expected: \"a finite non-negative duration\" },\n  ),\n);\n\n/**\n * ECMAScript reserved words are rejected up front: a namespace or method that\n * needs one would make every harness that binds identifiers fail at runtime\n * instead of failing closed at the Schema boundary.\n */\nconst reservedIdentifiers = new Set([\n  \"arguments\",\n  \"await\",\n  \"break\",\n  \"case\",\n  \"catch\",\n  \"class\",\n  \"const\",\n  \"continue\",\n  \"debugger\",\n  \"default\",\n  \"delete\",\n  \"do\",\n  \"else\",\n  \"enum\",\n  \"eval\",\n  \"export\",\n  \"extends\",\n  \"false\",\n  \"finally\",\n  \"for\",\n  \"function\",\n  \"if\",\n  \"implements\",\n  \"import\",\n  \"in\",\n  \"instanceof\",\n  \"interface\",\n  \"let\",\n  \"new\",\n  \"null\",\n  \"package\",\n  \"private\",\n  \"protected\",\n  \"public\",\n  \"return\",\n  \"static\",\n  \"super\",\n  \"switch\",\n  \"this\",\n  \"throw\",\n  \"true\",\n  \"try\",\n  \"typeof\",\n  \"var\",\n  \"void\",\n  \"while\",\n  \"with\",\n  \"yield\",\n]);\n\n/** A JavaScript identifier safe to bind as a sandbox global or method name. */\nexport const JsIdentifier = Schema.NonEmptyString.check(\n  Schema.isMaxLength(128),\n  Schema.isPattern(/^[A-Za-z_$][A-Za-z0-9_$]*$/),\n).pipe(\n  Schema.refine((value): value is string => !reservedIdentifiers.has(value), {\n    expected: \"a JavaScript identifier that is not a reserved word\",\n  }),\n);\n\nexport type JsIdentifier = typeof JsIdentifier.Type;\n\n/** One callable namespace exposed to the generated program as a typed global. */\nexport class CodeExecutionNamespace extends Schema.Class<CodeExecutionNamespace>(\n  \"CodeExecutionNamespace\",\n)({\n  name: JsIdentifier,\n  methods: Schema.Array(JsIdentifier).check(Schema.isMaxLength(64), Schema.isMinLength(1)),\n}) {}\n\n/**\n * Limits an executor must either enforce or reject (CAP-015). Byte bounds are\n * measured on UTF-8 encoded JSON at the sandbox boundary.\n */\nexport class CodeExecutionLimits extends Schema.Class<CodeExecutionLimits>(\"CodeExecutionLimits\")({\n  maxSourceBytes: PositiveInt.check(Schema.isLessThanOrEqualTo(4 * 1024 * 1024)),\n  maxWallTime: FinitePositiveDuration,\n  cpuMillis: Schema.optionalKey(PositiveInt.check(Schema.isLessThanOrEqualTo(5 * 60 * 1000))),\n  maxLogBytes: PositiveInt.check(Schema.isLessThanOrEqualTo(1024 * 1024)),\n  maxResultBytes: PositiveInt.check(Schema.isLessThanOrEqualTo(4 * 1024 * 1024)),\n  maxHostCalls: Schema.Natural.check(Schema.isLessThanOrEqualTo(10_000)),\n  /** Maximum active host calls per pass; defaults to four. Excess calls wait in Scope. */\n  maxHostCallConcurrency: Schema.optionalKey(PositiveInt.check(Schema.isLessThanOrEqualTo(64))),\n  maxHostCallArgumentBytes: PositiveInt.check(Schema.isLessThanOrEqualTo(1024 * 1024)),\n  maxHostCallResultBytes: PositiveInt.check(Schema.isLessThanOrEqualTo(4 * 1024 * 1024)),\n}) {}\n\n/**\n * One isolated execution pass over bounded generated JavaScript. The source\n * must be a single expression evaluating to one async function; the executor\n * harness invokes it exactly once with no arguments (ADR-0017 decision 5).\n */\nexport class CodeExecutionRequest extends Schema.Class<CodeExecutionRequest>(\n  \"CodeExecutionRequest\",\n)({\n  language: Schema.Literals([\"javascript\"]),\n  source: BoundedSourceText,\n  namespaces: Schema.Array(CodeExecutionNamespace).check(Schema.isMaxLength(32)),\n  network: SandboxNetworkPolicy,\n  limits: CodeExecutionLimits,\n}) {}\n\n/** One host invocation from generated code. Data only: the broker owns identity. */\nexport class CodeHostCall extends Schema.Class<CodeHostCall>(\"CodeHostCall\")({\n  namespace: JsIdentifier,\n  method: JsIdentifier,\n  argument: Schema.Json,\n}) {}\n\n/** A host call settled with the encoded Tool success value. */\nexport class CodeHostCallSuccess extends Schema.TaggedClass<CodeHostCallSuccess>()(\n  \"CodeHostCallSuccess\",\n  {\n    value: Schema.Json,\n  },\n) {}\n\n/**\n * A host call settled with a Schema-encoded typed failure envelope. Inside the\n * generated program the call's Promise rejects with the envelope value, so a\n * program can catch and branch on expected failures.\n */\nexport class CodeHostCallFailure extends Schema.TaggedClass<CodeHostCallFailure>()(\n  \"CodeHostCallFailure\",\n  {\n    error: Schema.Json,\n  },\n) {}\n\n/** Outcome of one host call as data; transport failures stay executor errors. */\nexport const CodeHostCallResult = Schema.Union([CodeHostCallSuccess, CodeHostCallFailure]);\nexport type CodeHostCallResult = typeof CodeHostCallResult.Type;\n\n/**\n * The per-pass host capability: the only authority generated code has over the\n * host. It is provided at the pass edge by the capability layer, its live\n * bindings are scoped resources, and it is never persisted (ADR-0017\n * decision 2). Broker-level failures return as `CodeHostCallFailure` data;\n * an unexpected host defect remains a defect.\n */\nexport class CodeExecutionHost extends Context.Service<\n  CodeExecutionHost,\n  {\n    readonly call: (call: CodeHostCall) => Effect.Effect<CodeHostCallResult>;\n  }\n>()(\"@effect-agent/sandbox/CodeExecutionHost\") {}\n\n/** Accounting one executor observed for one pass. */\nexport class CodeExecutionResourceUse extends Schema.Class<CodeExecutionResourceUse>(\n  \"CodeExecutionResourceUse\",\n)({\n  wallTime: FiniteNonNegativeDuration,\n  hostCalls: Schema.Natural,\n  logBytes: Schema.Natural,\n  resultBytes: Schema.Natural,\n  cpuMillis: Schema.optionalKey(Schema.Natural),\n}) {}\n\n/**\n * The bounded outcome of one successful pass. `value` and `logs` are the raw\n * executor capture; the aggregate model-visible egress budget and redaction\n * pass are owned by the Code Mode capability, not the executor (CAP-016).\n */\nexport class CodeExecutionResult extends Schema.Class<CodeExecutionResult>(\"CodeExecutionResult\")({\n  implementation: SandboxImplementation,\n  value: Schema.Json,\n  logs: BoundedLogs,\n  resourceUse: CodeExecutionResourceUse,\n}) {}\n\n/** The source is not one async function expression the executor can run. */\nexport class CodeSourceError extends Schema.TaggedError<CodeSourceError>()(\"CodeSourceError\", {\n  implementation: SandboxImplementation,\n  reason: Schema.Literals([\"invalid\", \"oversized\", \"not-a-function\"]),\n  message: BoundedMessage,\n}) {}\n\n/** The executor cannot honestly enforce one requested feature, limit, or policy. */\nexport class CodeExecutorUnsupportedError extends Schema.TaggedError<CodeExecutorUnsupportedError>()(\n  \"CodeExecutorUnsupportedError\",\n  {\n    implementation: SandboxImplementation,\n    feature: Schema.Literals([\n      \"language\",\n      \"network\",\n      \"cpu-limit\",\n      \"namespaces\",\n      \"wall-clock\",\n      \"host-calls\",\n    ]),\n    message: BoundedMessage,\n  },\n) {}\n\n/** The executor could not start the isolated pass. */\nexport class CodeExecutorStartError extends Schema.TaggedError<CodeExecutorStartError>()(\n  \"CodeExecutorStartError\",\n  {\n    implementation: SandboxImplementation,\n    message: BoundedMessage,\n    cause: Schema.optionalKey(Schema.Defect()),\n  },\n) {}\n\n/** The pass exceeded its CPU or wall-clock budget and was terminated. */\nexport class CodeExecutionTimeoutError extends Schema.TaggedError<CodeExecutionTimeoutError>()(\n  \"CodeExecutionTimeoutError\",\n  {\n    implementation: SandboxImplementation,\n    kind: Schema.Literals([\"cpu\", \"wall-clock\"]),\n    maxWallTime: FinitePositiveDuration,\n    logs: BoundedLogs,\n  },\n) {}\n\n/** A bounded surface (logs, result, or a per-call byte bound) was exceeded. */\nexport class CodeOutputLimitError extends Schema.TaggedError<CodeOutputLimitError>()(\n  \"CodeOutputLimitError\",\n  {\n    implementation: SandboxImplementation,\n    surface: Schema.Literals([\"logs\", \"result\", \"host-call-argument\", \"host-call-result\"]),\n    limit: PositiveInt,\n    observed: Schema.Natural,\n    logs: BoundedLogs,\n  },\n) {}\n\n/** The pass issued more host calls than its executor-owned cap allows. */\nexport class CodeHostCallLimitError extends Schema.TaggedError<CodeHostCallLimitError>()(\n  \"CodeHostCallLimitError\",\n  {\n    implementation: SandboxImplementation,\n    limit: Schema.Natural,\n    logs: BoundedLogs,\n  },\n) {}\n\n/**\n * The generated program finished by failing: it threw, its promise rejected,\n * or it returned a value that is not JSON. The bounded thrown value and log\n * capture flow back so a model can correct the program without a blind retry.\n */\nexport class CodeProgramFailedError extends Schema.TaggedError<CodeProgramFailedError>()(\n  \"CodeProgramFailedError\",\n  {\n    implementation: SandboxImplementation,\n    reason: Schema.Literals([\"threw\", \"rejected\", \"non-json-result\"]),\n    thrown: Schema.Json,\n    message: BoundedMessage,\n    logs: BoundedLogs,\n  },\n) {}\n\n/** The executor or its transport produced a value outside the protocol Schemas. */\nexport class CodeExecutionProtocolError extends Schema.TaggedError<CodeExecutionProtocolError>()(\n  \"CodeExecutionProtocolError\",\n  {\n    implementation: SandboxImplementation,\n    message: BoundedMessage,\n  },\n) {}\n\n/**\n * The pass was terminated externally — isolate eviction or a platform kill —\n * with no terminal program result. No result is fabricated.\n */\nexport class CodeExecutorTerminatedError extends Schema.TaggedError<CodeExecutorTerminatedError>()(\n  \"CodeExecutorTerminatedError\",\n  {\n    implementation: SandboxImplementation,\n    message: BoundedMessage,\n  },\n) {}\n\n/** Expected Code Mode execution failures. Interruption stays an Effect interruption. */\nexport const CodeExecutionError = Schema.Union([\n  CodeSourceError,\n  CodeExecutorUnsupportedError,\n  CodeExecutorStartError,\n  CodeExecutionTimeoutError,\n  CodeOutputLimitError,\n  CodeHostCallLimitError,\n  CodeProgramFailedError,\n  CodeExecutionProtocolError,\n  CodeExecutorTerminatedError,\n]);\n\nexport type CodeExecutionError = typeof CodeExecutionError.Type;\n\n/**\n * Callback-capable isolated execution port for Code Mode (ADR-0017), a sibling\n * of the command-shaped `Sandbox` service. One `execute` is one stateless pass:\n * the executor owns no approval, Tool, replay, or Thread semantics, holds\n * every pass resource in the given Scope, and reaches the host only through the\n * `CodeExecutionHost` service in its requirement channel. Implementations must\n * identify their isolation posture honestly; an `unisolated` executor is never\n * a security boundary (CAP-010, CAP-015).\n */\nexport class CodeExecutor extends Context.Service<\n  CodeExecutor,\n  {\n    readonly execute: (\n      request: CodeExecutionRequest,\n    ) => Effect.Effect<CodeExecutionResult, CodeExecutionError, Scope.Scope | CodeExecutionHost>;\n  }\n>()(\"@effect-agent/sandbox/CodeExecutor\") {}\n\n/** Type helper for implementations that preserve the public CodeExecutor contract. */\nexport type CodeExecutorExecute = (\n  request: CodeExecutionRequest,\n) => Effect.Effect<CodeExecutionResult, CodeExecutionError, Scope.Scope | CodeExecutionHost>;\n"],"mappings":"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"}