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

package/dist/RunPolicyUsage-ClZxyR46.d.mts

@@ -0,0 +1,21 @@
+import { Schema } from "effect";
+declare namespace RunPolicyUsage_d_exports {
+  export { RunPolicyUsage };
+}
+/**
+ * Cumulative policy accounting for one logical Run across replacement Attempts.
+ * Turns and model-declared calls include a pending batch. The failure streak excludes that
+ * entire batch until its declaration-ordered outcomes are folded once during continuation.
+ * Programmatic calls are reserved before execution; finalization is reserved before its model call.
+ */
+declare const RunPolicyUsage: Schema.Struct<{
+  readonly committedTurns: Schema.Natural;
+  readonly toolCalls: Schema.Natural;
+  readonly programmaticToolCalls: Schema.Natural;
+  readonly consecutiveToolFailures: Schema.Natural;
+  readonly finalizationUsed: Schema.Boolean;
+}>;
+type RunPolicyUsage = typeof RunPolicyUsage.Type;
+//#endregion
+export { RunPolicyUsage_d_exports as n, RunPolicyUsage as t };
+//# sourceMappingURL=RunPolicyUsage-ClZxyR46.d.mts.map

package/dist/Sandbox-CEsDWBLq.d.mts

@@ -0,0 +1,173 @@
+import { Context, Duration, Schema, Stream } from "effect";
+declare namespace Sandbox_d_exports {
+  export { NetworkAllowlist, NetworkDisabled, SANDBOX_DIAGNOSTIC_MAX_LENGTH, Sandbox, SandboxArtifact, SandboxArtifactRule, SandboxEnvironment, SandboxError, SandboxEvent, SandboxExecute, SandboxExitError, SandboxExited, SandboxImplementation, SandboxLimits, SandboxMount, SandboxNetworkPolicy, SandboxOutput, SandboxOutputLimitError, SandboxRequest, SandboxResourceUse, SandboxRuntime, SandboxSecretHandle, SandboxSpawnError, SandboxStarted, SandboxTimeoutError, SandboxUnsupportedRequestError };
+}
+declare const SANDBOX_DIAGNOSTIC_MAX_LENGTH: number;
+declare const SandboxRuntime_base: Schema.Class<SandboxRuntime, Schema.Struct<{
+  readonly kind: Schema.Literals<readonly ["container", "microvm", "wasm", "unisolated-process"]>;
+  readonly identity: Schema.NonEmptyString;
+}>, {}>;
+/** A requested runtime image or executable environment. */
+declare class SandboxRuntime extends SandboxRuntime_base {}
+declare const SandboxImplementation_base: Schema.Class<SandboxImplementation, Schema.Struct<{
+  readonly isolation: Schema.Literals<readonly ["isolated", "unisolated"]>;
+  readonly identity: Schema.NonEmptyString;
+}>, {}>;
+/** The implementation and its isolation posture that executed a request. */
+declare class SandboxImplementation extends SandboxImplementation_base {}
+declare const SandboxMount_base: Schema.Class<SandboxMount, Schema.Struct<{
+  readonly source: Schema.NonEmptyString;
+  readonly target: Schema.NonEmptyString;
+  readonly access: Schema.Literals<readonly ["read-only", "read-write"]>;
+}>, {}>;
+/** A host path made available to the requested runtime. */
+declare class SandboxMount extends SandboxMount_base {}
+declare const NetworkDisabled_base: Schema.Class<NetworkDisabled, Schema.TaggedStruct<"NetworkDisabled", {}>, {}>;
+/** Explicitly denies all workload network access. */
+declare class NetworkDisabled extends NetworkDisabled_base {}
+declare const NetworkAllowlist_base: Schema.Class<NetworkAllowlist, Schema.TaggedStruct<"NetworkAllowlist", {
+  readonly domains: Schema.$Array<Schema.NonEmptyString>;
+  readonly ports: Schema.$Array<Schema.Int>;
+}>, {}>;
+/** Explicitly permits connections only to the named destination and port allowlists. */
+declare class NetworkAllowlist extends NetworkAllowlist_base {}
+/** Network access policy supplied to a sandbox implementation. */
+declare const SandboxNetworkPolicy: Schema.Union<readonly [typeof NetworkDisabled, typeof NetworkAllowlist]>;
+type SandboxNetworkPolicy = typeof SandboxNetworkPolicy.Type;
+declare const SandboxEnvironment_base: Schema.Class<SandboxEnvironment, Schema.Struct<{
+  readonly allow: Schema.$Array<Schema.NonEmptyString>;
+}>, {}>;
+/** Names of ambient variables that may be copied into the workload environment. */
+declare class SandboxEnvironment extends SandboxEnvironment_base {}
+declare const SandboxLimits_base: Schema.Class<SandboxLimits, Schema.Struct<{
+  readonly cpuCores: Schema.optionalKey<Schema.Finite>;
+  readonly memoryBytes: Schema.optionalKey<Schema.Int>;
+  readonly maxOutputBytes: Schema.Int;
+  readonly maxWallTime: Schema.refine<Duration.Duration, Schema.Duration>;
+}>, {}>;
+/** Limits that a sandbox implementation must either enforce or reject. */
+declare class SandboxLimits extends SandboxLimits_base {}
+declare const SandboxSecretHandle_base: Schema.Class<SandboxSecretHandle, Schema.Struct<{
+  readonly id: Schema.NonEmptyString;
+  readonly purpose: Schema.NonEmptyString;
+}>, {}>;
+/** A secret reference; raw secret values are never part of a sandbox request. */
+declare class SandboxSecretHandle extends SandboxSecretHandle_base {}
+declare const SandboxArtifactRule_base: Schema.Class<SandboxArtifactRule, Schema.Struct<{
+  readonly path: Schema.NonEmptyString;
+  readonly maxBytes: Schema.Int;
+}>, {}>;
+/** Rules for copying selected workload output out of an isolated runtime. */
+declare class SandboxArtifactRule extends SandboxArtifactRule_base {}
+declare const SandboxArtifact_base: Schema.Class<SandboxArtifact, Schema.Struct<{
+  readonly path: Schema.NonEmptyString;
+  readonly bytes: Schema.Natural;
+  readonly digest: Schema.NonEmptyString;
+  readonly mediaType: Schema.optionalKey<Schema.NonEmptyString>;
+}>, {}>;
+/** Metadata for an artifact that a sandbox implementation released after applying its rules. */
+declare class SandboxArtifact extends SandboxArtifact_base {}
+declare const SandboxRequest_base: Schema.Class<SandboxRequest, Schema.Struct<{
+  readonly runtime: typeof SandboxRuntime;
+  readonly command: Schema.NonEmptyString;
+  readonly args: Schema.$Array<Schema.String>;
+  readonly cwd: Schema.NonEmptyString;
+  readonly environment: typeof SandboxEnvironment;
+  readonly mounts: Schema.$Array<typeof SandboxMount>;
+  readonly network: Schema.Union<readonly [typeof NetworkDisabled, typeof NetworkAllowlist]>;
+  readonly limits: typeof SandboxLimits;
+  readonly secretHandles: Schema.$Array<typeof SandboxSecretHandle>;
+  readonly artifactRules: Schema.$Array<typeof SandboxArtifactRule>;
+}>, {}>;
+/** Schema-first command execution request. Command and arguments are intentionally separate. */
+declare class SandboxRequest extends SandboxRequest_base {}
+declare const SandboxResourceUse_base: Schema.Class<SandboxResourceUse, Schema.Struct<{
+  readonly wallTime: Schema.refine<Duration.Duration, Schema.Duration>;
+  readonly stdoutBytes: Schema.Natural;
+  readonly stderrBytes: Schema.Natural;
+  readonly cpuMillis: Schema.optionalKey<Schema.Natural>;
+  readonly memoryBytes: Schema.optionalKey<Schema.Natural>;
+}>, {}>;
+/** Accounting that a sandbox implementation was able to observe for one execution. */
+declare class SandboxResourceUse extends SandboxResourceUse_base {}
+declare const SandboxStarted_base: Schema.Class<SandboxStarted, Schema.TaggedStruct<"SandboxStarted", {
+  readonly eventVersion: Schema.Literal<1>;
+  readonly implementation: typeof SandboxImplementation;
+  readonly runtime: typeof SandboxRuntime;
+}>, {}>;
+/** Signals that the implementation has accepted the request and started its workload. */
+declare class SandboxStarted extends SandboxStarted_base {}
+declare const SandboxOutput_base: Schema.Class<SandboxOutput, Schema.TaggedStruct<"SandboxOutput", {
+  readonly eventVersion: Schema.Literal<1>;
+  readonly implementation: typeof SandboxImplementation;
+  readonly stream: Schema.Literals<readonly ["stdout", "stderr"]>;
+  readonly text: Schema.String;
+  readonly bytes: Schema.Natural;
+}>, {}>;
+/** A bounded text fragment from stdout or stderr. Sandbox output is sensitive by default. */
+declare class SandboxOutput extends SandboxOutput_base {}
+declare const SandboxExited_base: Schema.Class<SandboxExited, Schema.TaggedStruct<"SandboxExited", {
+  readonly eventVersion: Schema.Literal<1>;
+  readonly implementation: typeof SandboxImplementation;
+  readonly exitCode: Schema.Int;
+  readonly resourceUse: typeof SandboxResourceUse;
+  readonly artifacts: Schema.$Array<typeof SandboxArtifact>;
+}>, {}>;
+/** The terminal process status and observed bounded resource usage. */
+declare class SandboxExited extends SandboxExited_base {}
+/** Versioned execution event stream. */
+declare const SandboxEvent: Schema.Union<readonly [typeof SandboxStarted, typeof SandboxOutput, typeof SandboxExited]>;
+type SandboxEvent = typeof SandboxEvent.Type;
+declare const SandboxSpawnError_base: Schema.Class<SandboxSpawnError, Schema.TaggedStruct<"SandboxSpawnError", {
+  readonly implementation: typeof SandboxImplementation;
+  readonly command: Schema.NonEmptyString;
+  readonly message: Schema.String;
+  readonly cause: Schema.optionalKey<Schema.Defect>;
+}>, import("effect/Cause").YieldableError>;
+/** The runtime could not start the requested process. */
+declare class SandboxSpawnError extends SandboxSpawnError_base {}
+declare const SandboxExitError_base: Schema.Class<SandboxExitError, Schema.TaggedStruct<"SandboxExitError", {
+  readonly implementation: typeof SandboxImplementation;
+  readonly exitCode: Schema.Int;
+  readonly message: Schema.String;
+  readonly cause: Schema.optionalKey<Schema.Defect>;
+}>, import("effect/Cause").YieldableError>;
+/** The process ended unsuccessfully after starting. */
+declare class SandboxExitError extends SandboxExitError_base {}
+declare const SandboxTimeoutError_base: Schema.Class<SandboxTimeoutError, Schema.TaggedStruct<"SandboxTimeoutError", {
+  readonly implementation: typeof SandboxImplementation;
+  readonly maxWallTime: Schema.refine<Duration.Duration, Schema.Duration>;
+}>, import("effect/Cause").YieldableError>;
+/** The wall-clock execution limit elapsed and the owned process was interrupted. */
+declare class SandboxTimeoutError extends SandboxTimeoutError_base {}
+declare const SandboxOutputLimitError_base: Schema.Class<SandboxOutputLimitError, Schema.TaggedStruct<"SandboxOutputLimitError", {
+  readonly implementation: typeof SandboxImplementation;
+  readonly stream: Schema.Literals<readonly ["stdout", "stderr"]>;
+  readonly limit: Schema.Int;
+  readonly observed: Schema.Int;
+}>, import("effect/Cause").YieldableError>;
+/** A stdout or stderr stream exceeded its configured bounded-output limit. */
+declare class SandboxOutputLimitError extends SandboxOutputLimitError_base {}
+declare const SandboxUnsupportedRequestError_base: Schema.Class<SandboxUnsupportedRequestError, Schema.TaggedStruct<"SandboxUnsupportedRequestError", {
+  readonly implementation: typeof SandboxImplementation;
+  readonly feature: Schema.Literals<readonly ["runtime", "mounts", "network", "cpu-limit", "memory-limit", "secret-handles", "artifacts"]>;
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** The selected implementation cannot honestly enforce one requested security or resource feature. */
+declare class SandboxUnsupportedRequestError extends SandboxUnsupportedRequestError_base {}
+/** Expected sandbox execution failures. Interruption remains an Effect interruption, never a fabricated exit. */
+declare const SandboxError: Schema.Union<readonly [typeof SandboxSpawnError, typeof SandboxExitError, typeof SandboxTimeoutError, typeof SandboxOutputLimitError, typeof SandboxUnsupportedRequestError]>;
+type SandboxError = typeof SandboxError.Type;
+declare const Sandbox_base: Context.ServiceClass<Sandbox, "@effect-agent/sandbox/Sandbox", {
+  readonly execute: (request: SandboxRequest) => Stream.Stream<SandboxEvent, SandboxError>;
+}>;
+/**
+ * Scoped command/code execution capability. Implementations must identify their isolation posture
+ * in every emitted event; an `unisolated` implementation is never a security sandbox.
+ */
+declare class Sandbox extends Sandbox_base {}
+/** Type helper for implementations that preserve the public Sandbox service contract. */
+type SandboxExecute = (request: SandboxRequest) => Stream.Stream<SandboxEvent, SandboxError, never>;
+//#endregion
+export { SandboxSpawnError as C, Sandbox_d_exports as D, SandboxUnsupportedRequestError as E, SandboxSecretHandle as S, SandboxTimeoutError as T, SandboxOutput as _, SandboxArtifact as a, SandboxResourceUse as b, SandboxError as c, SandboxExitError as d, SandboxExited as f, SandboxNetworkPolicy as g, SandboxMount as h, Sandbox as i, SandboxEvent as l, SandboxLimits as m, NetworkDisabled as n, SandboxArtifactRule as o, SandboxImplementation as p, SANDBOX_DIAGNOSTIC_MAX_LENGTH as r, SandboxEnvironment as s, NetworkAllowlist as t, SandboxExecute as u, SandboxOutputLimitError as v, SandboxStarted as w, SandboxRuntime as x, SandboxRequest as y };
+//# sourceMappingURL=Sandbox-CEsDWBLq.d.mts.map