effect-agent 0.1.0-beta.11 → 0.1.0-beta.111

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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"}

package/dist/sandbox/InteractiveBrowser.d.mts

@@ -0,0 +1,257 @@
+import { p as SandboxImplementation } from "../Sandbox-CEsDWBLq.mjs";
+import { s as PageScreenshotResult } from "../PageScreenshot-BpgZKAxl.mjs";
+import { Context, Effect, Schema, Scope } from "effect";
+declare namespace InteractiveBrowser_d_exports {
+  export { BrowserActionResult, BrowserClickRequest, BrowserExpectedTarget, BrowserExpectedTargetState, BrowserFileSelectionResult, BrowserFillRequest, BrowserHandle, BrowserNavigateRequest, BrowserNavigationResult, BrowserReadTextRequest, BrowserScreenshotRequest, BrowserScrollRequest, BrowserSelectFileRequest, BrowserTextResult, InteractiveBrowser, InteractiveBrowserActionError, InteractiveBrowserBusyError, InteractiveBrowserCapacityError, InteractiveBrowserError, InteractiveBrowserExpiredError, InteractiveBrowserFailureEvidence, InteractiveBrowserHost, InteractiveBrowserLimitError, InteractiveBrowserNetworkPolicy, InteractiveBrowserPolicy, InteractiveBrowserPolicyDeniedError, InteractiveBrowserProtocolError, InteractiveBrowserTargetUrl, InteractiveBrowserUnsupportedError };
+}
+/** Absolute, bounded HTTP(S) navigation URL without embedded credentials. */
+export declare const InteractiveBrowserTargetUrl: Schema.NonEmptyString;
+export type InteractiveBrowserTargetUrl = typeof InteractiveBrowserTargetUrl.Type;
+/** Canonical HTTPS host authority, optionally carrying a non-default port. */
+export declare const InteractiveBrowserHost: Schema.NonEmptyString;
+export type InteractiveBrowserHost = typeof InteractiveBrowserHost.Type;
+/**
+ * ExactHosts retains the page-request URL allowlist, not a public-network boundary.
+ * PublicWeb requires connection-time public-address enforcement for all session
+ * traffic, including human navigation. Adapters that cannot enforce it must fail
+ * with InteractiveBrowserUnsupportedError before acquiring a browser.
+ * Unrestricted explicitly opts out of URL/host and private-network containment.
+ */
+export declare const InteractiveBrowserNetworkPolicy: Schema.Union<readonly [Schema.TaggedStruct<"ExactHosts", {
+  readonly allowedHosts: Schema.$Array<Schema.NonEmptyString>;
+}>, Schema.TaggedStruct<"PublicWeb", {}>, Schema.TaggedStruct<"Unrestricted", {}>]>;
+export type InteractiveBrowserNetworkPolicy = typeof InteractiveBrowserNetworkPolicy.Type;
+declare const InteractiveBrowserPolicy_base: Schema.Class<InteractiveBrowserPolicy, Schema.Struct<{
+  readonly network: Schema.Union<readonly [Schema.TaggedStruct<"ExactHosts", {
+    readonly allowedHosts: Schema.$Array<Schema.NonEmptyString>;
+  }>, Schema.TaggedStruct<"PublicWeb", {}>, Schema.TaggedStruct<"Unrestricted", {}>]>;
+  readonly maxActions: Schema.Int;
+  readonly maxElapsedMillis: Schema.Int;
+  readonly maxReturnedBytes: Schema.Int;
+}>, {}>;
+/** Finite per-pass budgets. The elapsed ceiling is one hour; provider idle limits may be shorter. */
+export declare class InteractiveBrowserPolicy extends InteractiveBrowserPolicy_base {}
+declare const BrowserNavigateRequest_base: Schema.Class<BrowserNavigateRequest, Schema.Struct<{
+  readonly url: Schema.NonEmptyString;
+}>, {}>;
+export declare class BrowserNavigateRequest extends BrowserNavigateRequest_base {}
+declare const BrowserReadTextRequest_base: Schema.Class<BrowserReadTextRequest, Schema.Struct<{
+  readonly selector: Schema.optionalKey<Schema.NonEmptyString>;
+}>, {}>;
+export declare class BrowserReadTextRequest extends BrowserReadTextRequest_base {}
+/** Observed control state, without an input value. Absence is part of the snapshot. */
+export declare const BrowserExpectedTargetState: Schema.Struct<{
+  readonly kind: Schema.String;
+  readonly inputType: Schema.optionalKey<Schema.String>;
+  readonly label: Schema.optionalKey<Schema.String>;
+  readonly checked: Schema.optionalKey<Schema.Boolean>;
+  readonly selected: Schema.optionalKey<Schema.Boolean>;
+  readonly disabled: Schema.optionalKey<Schema.Boolean>;
+  readonly required: Schema.optionalKey<Schema.Boolean>;
+  readonly valid: Schema.optionalKey<Schema.Boolean>;
+  readonly formValid: Schema.optionalKey<Schema.Boolean>;
+}>;
+export type BrowserExpectedTargetState = typeof BrowserExpectedTargetState.Type;
+/** Exact observed document/node identity. A replacement node is refused before input dispatch. */
+export declare const BrowserExpectedTarget: Schema.Struct<{
+  readonly documentId: Schema.NonEmptyString;
+  readonly nodeId: Schema.NonEmptyString;
+  readonly state: Schema.optionalKey<Schema.Struct<{
+    readonly kind: Schema.String;
+    readonly inputType: Schema.optionalKey<Schema.String>;
+    readonly label: Schema.optionalKey<Schema.String>;
+    readonly checked: Schema.optionalKey<Schema.Boolean>;
+    readonly selected: Schema.optionalKey<Schema.Boolean>;
+    readonly disabled: Schema.optionalKey<Schema.Boolean>;
+    readonly required: Schema.optionalKey<Schema.Boolean>;
+    readonly valid: Schema.optionalKey<Schema.Boolean>;
+    readonly formValid: Schema.optionalKey<Schema.Boolean>;
+  }>>;
+  readonly scopeSelector: Schema.optionalKey<Schema.NonEmptyString>;
+}>;
+export type BrowserExpectedTarget = typeof BrowserExpectedTarget.Type;
+declare const BrowserFillRequest_base: Schema.Class<BrowserFillRequest, Schema.Struct<{
+  readonly selector: Schema.NonEmptyString;
+  readonly value: Schema.String;
+  readonly expectedTarget: Schema.optionalKey<Schema.Struct<{
+    readonly documentId: Schema.NonEmptyString;
+    readonly nodeId: Schema.NonEmptyString;
+    readonly state: Schema.optionalKey<Schema.Struct<{
+      readonly kind: Schema.String;
+      readonly inputType: Schema.optionalKey<Schema.String>;
+      readonly label: Schema.optionalKey<Schema.String>;
+      readonly checked: Schema.optionalKey<Schema.Boolean>;
+      readonly selected: Schema.optionalKey<Schema.Boolean>;
+      readonly disabled: Schema.optionalKey<Schema.Boolean>;
+      readonly required: Schema.optionalKey<Schema.Boolean>;
+      readonly valid: Schema.optionalKey<Schema.Boolean>;
+      readonly formValid: Schema.optionalKey<Schema.Boolean>;
+    }>>;
+    readonly scopeSelector: Schema.optionalKey<Schema.NonEmptyString>;
+  }>>;
+}>, {}>;
+export declare class BrowserFillRequest extends BrowserFillRequest_base {}
+declare const BrowserClickRequest_base: Schema.Class<BrowserClickRequest, Schema.Struct<{
+  readonly selector: Schema.NonEmptyString;
+  readonly expectedTarget: Schema.optionalKey<Schema.Struct<{
+    readonly documentId: Schema.NonEmptyString;
+    readonly nodeId: Schema.NonEmptyString;
+    readonly state: Schema.optionalKey<Schema.Struct<{
+      readonly kind: Schema.String;
+      readonly inputType: Schema.optionalKey<Schema.String>;
+      readonly label: Schema.optionalKey<Schema.String>;
+      readonly checked: Schema.optionalKey<Schema.Boolean>;
+      readonly selected: Schema.optionalKey<Schema.Boolean>;
+      readonly disabled: Schema.optionalKey<Schema.Boolean>;
+      readonly required: Schema.optionalKey<Schema.Boolean>;
+      readonly valid: Schema.optionalKey<Schema.Boolean>;
+      readonly formValid: Schema.optionalKey<Schema.Boolean>;
+    }>>;
+    readonly scopeSelector: Schema.optionalKey<Schema.NonEmptyString>;
+  }>>;
+}>, {}>;
+export declare class BrowserClickRequest extends BrowserClickRequest_base {}
+declare const BrowserSelectFileRequest_base: Schema.Class<BrowserSelectFileRequest, Schema.Struct<{
+  readonly selector: Schema.NonEmptyString;
+  readonly target: Schema.Literals<readonly ["input", "chooser"]>;
+  readonly fileName: Schema.NonEmptyString;
+  readonly mediaType: Schema.NonEmptyString;
+  readonly bytes: Schema.Uint8Array;
+}>, {}>;
+/** Caller-owned bytes; no host filesystem paths or model-supplied script crosses this port. */
+export declare class BrowserSelectFileRequest extends BrowserSelectFileRequest_base {}
+declare const BrowserFileSelectionResult_base: Schema.Class<BrowserFileSelectionResult, Schema.Struct<{
+  readonly url: Schema.NonEmptyString;
+  readonly fileName: Schema.NonEmptyString;
+  readonly mediaType: Schema.NonEmptyString;
+  readonly size: Schema.Int;
+}>, {}>;
+/** Confirms selection in the input. It does not confirm a website received or submitted the file. */
+export declare class BrowserFileSelectionResult extends BrowserFileSelectionResult_base {}
+declare const BrowserScreenshotRequest_base: Schema.Class<BrowserScreenshotRequest, Schema.Struct<{
+  readonly fullPage: Schema.Boolean;
+}>, {}>;
+/** Capture the current page without navigating or opening another browser. */
+export declare class BrowserScreenshotRequest extends BrowserScreenshotRequest_base {}
+declare const BrowserScrollRequest_base: Schema.Class<BrowserScrollRequest, Schema.Struct<{
+  readonly deltaX: Schema.Int;
+  readonly deltaY: Schema.Int;
+}>, {}>;
+/** Scroll the current viewport by signed CSS pixel deltas. */
+export declare class BrowserScrollRequest extends BrowserScrollRequest_base {}
+declare const BrowserNavigationResult_base: Schema.Class<BrowserNavigationResult, Schema.Struct<{
+  readonly url: Schema.NonEmptyString;
+}>, {}>;
+export declare class BrowserNavigationResult extends BrowserNavigationResult_base {}
+declare const BrowserTextResult_base: Schema.Class<BrowserTextResult, Schema.Struct<{
+  readonly text: Schema.String;
+}>, {}>;
+export declare class BrowserTextResult extends BrowserTextResult_base {}
+declare const BrowserActionResult_base: Schema.Class<BrowserActionResult, Schema.Struct<{
+  readonly url: Schema.NonEmptyString;
+}>, {}>;
+/** Post-action URL observation; no provider session state crosses this boundary. */
+export declare class BrowserActionResult extends BrowserActionResult_base {}
+/** Safe execution evidence, independent of provider messages and application receipts.
+ * completed proves SDK input completion, never website acceptance or durable settlement.
+ */
+export declare const InteractiveBrowserFailureEvidence: Schema.Struct<{
+  readonly stage: Schema.Literals<readonly ["preparation", "input", "observation"]>;
+  readonly dispatch: Schema.Literals<readonly ["not-dispatched", "completed", "unknown", "running"]>;
+  readonly session: Schema.Literals<readonly ["attached", "disconnected", "lost"]>;
+}>;
+export type InteractiveBrowserFailureEvidence = typeof InteractiveBrowserFailureEvidence.Type;
+declare const InteractiveBrowserPolicyDeniedError_base: Schema.Class<InteractiveBrowserPolicyDeniedError, Schema.TaggedStruct<"InteractiveBrowserPolicyDeniedError", {
+  readonly implementation: typeof SandboxImplementation;
+  readonly message: Schema.String;
+  readonly evidence: Schema.optionalKey<Schema.Struct<{
+    readonly stage: Schema.Literals<readonly ["preparation", "input", "observation"]>;
+    readonly dispatch: Schema.Literals<readonly ["not-dispatched", "completed", "unknown", "running"]>;
+    readonly session: Schema.Literals<readonly ["attached", "disconnected", "lost"]>;
+  }>>;
+}>, import("effect/Cause").YieldableError>;
+export declare class InteractiveBrowserPolicyDeniedError extends InteractiveBrowserPolicyDeniedError_base {}
+declare const InteractiveBrowserBusyError_base: Schema.Class<InteractiveBrowserBusyError, Schema.TaggedStruct<"InteractiveBrowserBusyError", {
+  readonly implementation: typeof SandboxImplementation;
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class InteractiveBrowserBusyError extends InteractiveBrowserBusyError_base {}
+declare const InteractiveBrowserCapacityError_base: Schema.Class<InteractiveBrowserCapacityError, Schema.TaggedStruct<"InteractiveBrowserCapacityError", {
+  readonly implementation: typeof SandboxImplementation;
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class InteractiveBrowserCapacityError extends InteractiveBrowserCapacityError_base {}
+declare const InteractiveBrowserExpiredError_base: Schema.Class<InteractiveBrowserExpiredError, Schema.TaggedStruct<"InteractiveBrowserExpiredError", {
+  readonly implementation: typeof SandboxImplementation;
+  readonly message: Schema.String;
+  readonly evidence: Schema.optionalKey<Schema.Struct<{
+    readonly stage: Schema.Literals<readonly ["preparation", "input", "observation"]>;
+    readonly dispatch: Schema.Literals<readonly ["not-dispatched", "completed", "unknown", "running"]>;
+    readonly session: Schema.Literals<readonly ["attached", "disconnected", "lost"]>;
+  }>>;
+}>, import("effect/Cause").YieldableError>;
+export declare class InteractiveBrowserExpiredError extends InteractiveBrowserExpiredError_base {}
+declare const InteractiveBrowserActionError_base: Schema.Class<InteractiveBrowserActionError, Schema.TaggedStruct<"InteractiveBrowserActionError", {
+  readonly implementation: typeof SandboxImplementation;
+  readonly operation: Schema.Literals<readonly ["navigate", "read-text", "fill", "click", "select-file", "screenshot", "scroll", "close"]>;
+  readonly message: Schema.String;
+  readonly evidence: Schema.optionalKey<Schema.Struct<{
+    readonly stage: Schema.Literals<readonly ["preparation", "input", "observation"]>;
+    readonly dispatch: Schema.Literals<readonly ["not-dispatched", "completed", "unknown", "running"]>;
+    readonly session: Schema.Literals<readonly ["attached", "disconnected", "lost"]>;
+  }>>;
+  readonly cause: Schema.optionalKey<Schema.Defect>;
+}>, import("effect/Cause").YieldableError>;
+export declare class InteractiveBrowserActionError extends InteractiveBrowserActionError_base {}
+declare const InteractiveBrowserProtocolError_base: Schema.Class<InteractiveBrowserProtocolError, Schema.TaggedStruct<"InteractiveBrowserProtocolError", {
+  readonly implementation: typeof SandboxImplementation;
+  readonly message: Schema.String;
+  readonly evidence: Schema.optionalKey<Schema.Struct<{
+    readonly stage: Schema.Literals<readonly ["preparation", "input", "observation"]>;
+    readonly dispatch: Schema.Literals<readonly ["not-dispatched", "completed", "unknown", "running"]>;
+    readonly session: Schema.Literals<readonly ["attached", "disconnected", "lost"]>;
+  }>>;
+  readonly cause: Schema.optionalKey<Schema.Defect>;
+}>, import("effect/Cause").YieldableError>;
+export declare class InteractiveBrowserProtocolError extends InteractiveBrowserProtocolError_base {}
+declare const InteractiveBrowserLimitError_base: Schema.Class<InteractiveBrowserLimitError, Schema.TaggedStruct<"InteractiveBrowserLimitError", {
+  readonly implementation: typeof SandboxImplementation;
+  readonly evidence: Schema.optionalKey<Schema.Struct<{
+    readonly stage: Schema.Literals<readonly ["preparation", "input", "observation"]>;
+    readonly dispatch: Schema.Literals<readonly ["not-dispatched", "completed", "unknown", "running"]>;
+    readonly session: Schema.Literals<readonly ["attached", "disconnected", "lost"]>;
+  }>>;
+  readonly limit: Schema.Literals<readonly ["actions", "elapsed", "returned-bytes"]>;
+  readonly maximum: Schema.Int;
+  readonly observed: Schema.Natural;
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class InteractiveBrowserLimitError extends InteractiveBrowserLimitError_base {}
+declare const InteractiveBrowserUnsupportedError_base: Schema.Class<InteractiveBrowserUnsupportedError, Schema.TaggedStruct<"InteractiveBrowserUnsupportedError", {
+  readonly implementation: typeof SandboxImplementation;
+  readonly feature: Schema.Literals<readonly ["navigation", "read-text", "fill", "click", "select-file", "screenshot", "scroll", "policy"]>;
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class InteractiveBrowserUnsupportedError extends InteractiveBrowserUnsupportedError_base {}
+export declare const InteractiveBrowserError: Schema.Union<readonly [typeof InteractiveBrowserPolicyDeniedError, typeof InteractiveBrowserBusyError, typeof InteractiveBrowserCapacityError, typeof InteractiveBrowserExpiredError, typeof InteractiveBrowserActionError, typeof InteractiveBrowserProtocolError, typeof InteractiveBrowserLimitError, typeof InteractiveBrowserUnsupportedError]>;
+export type InteractiveBrowserError = typeof InteractiveBrowserError.Type;
+/** A live handle is intentionally not a Schema value and cannot cross persistence/transport boundaries. */
+export interface BrowserHandle {
+  readonly navigate: (request: BrowserNavigateRequest) => Effect.Effect<BrowserNavigationResult, InteractiveBrowserError>;
+  readonly readText: (request: BrowserReadTextRequest) => Effect.Effect<BrowserTextResult, InteractiveBrowserError>;
+  readonly fill: (request: BrowserFillRequest) => Effect.Effect<BrowserActionResult, InteractiveBrowserError>;
+  readonly click: (request: BrowserClickRequest) => Effect.Effect<BrowserActionResult, InteractiveBrowserError>;
+  readonly selectFile: (request: BrowserSelectFileRequest) => Effect.Effect<BrowserFileSelectionResult, InteractiveBrowserError>;
+  /** PNG bytes are caller-owned and bounded by the pass's per-result byte limit. */
+  readonly screenshot: (request: BrowserScreenshotRequest) => Effect.Effect<PageScreenshotResult, InteractiveBrowserError>;
+  readonly scroll: (request: BrowserScrollRequest) => Effect.Effect<BrowserActionResult, InteractiveBrowserError>;
+  /** Invalidate the handle and close its resources early, including after an interrupted action. */
+  readonly close: Effect.Effect<void, InteractiveBrowserError>;
+}
+declare const InteractiveBrowser_base: Context.ServiceClass<InteractiveBrowser, "@effect-agent/sandbox/InteractiveBrowser", {
+  readonly open: (policy: InteractiveBrowserPolicy) => Effect.Effect<BrowserHandle, InteractiveBrowserError, Scope.Scope>;
+}>;
+export declare class InteractiveBrowser extends InteractiveBrowser_base {}
+//#endregion
+export { InteractiveBrowser_d_exports as t };
+//# sourceMappingURL=InteractiveBrowser.d.mts.map