@open-insight/core 0.0.0

package/dist/index-CmxU7-9a.d.mts

@@ -0,0 +1,725 @@
+import { Context, Crypto, Effect, FileSystem, Layer, Path, PlatformError, Schema, Scope, Stream } from "effect";
+import { HttpClient } from "effect/unstable/http";
+import { ChildProcessHandle, ChildProcessSpawner, ExitCode } from "effect/unstable/process/ChildProcessSpawner";
+import { ChildProcess } from "effect/unstable/process";
+import { AiError, Prompt, Response } from "effect/unstable/ai";
+import { AssistantMessage, Message, Prompt as Prompt$1, Prompt as Trajectory, SystemMessage, ToolMessage, UserMessage } from "effect/unstable/ai/Prompt";
+import { Command } from "effect/unstable/process/ChildProcess";
+
+//#region src/sandbox/snapshot/schema.d.ts
+/**
+ * OCI image reference (e.g. `docker.io/library/node:18-alpine`).
+ */
+declare const Image: Schema.String;
+type Image = Schema.Schema.Type<typeof Image>;
+declare const Snapshot_base: Schema.Class<Snapshot, Schema.Struct<{
+  readonly image: Schema.String;
+  readonly instructions: Schema.$Array<Schema.TaggedUnion<{
+    readonly Cmd: Schema.TaggedStruct<"Cmd", {
+      readonly cmd: Schema.$Array<Schema.String>;
+    }>;
+    readonly Copy: Schema.TaggedStruct<"Copy", {
+      readonly src: Schema.$Array<Schema.String>;
+      readonly dest: Schema.String;
+    }>;
+    readonly Entrypoint: Schema.TaggedStruct<"Entrypoint", {
+      readonly cmd: Schema.$Array<Schema.String>;
+    }>;
+    readonly Env: Schema.TaggedStruct<"Env", {
+      readonly env: Schema.$Record<Schema.String, Schema.String>;
+    }>;
+    readonly Run: Schema.TaggedStruct<"Run", {
+      readonly cmd: Schema.String;
+    }>;
+    readonly User: Schema.TaggedStruct<"User", {
+      readonly user: Schema.String;
+    }>;
+    readonly Workdir: Schema.TaggedStruct<"Workdir", {
+      readonly path: Schema.String;
+    }>;
+  }>>;
+}>, {}>;
+declare class Snapshot extends Snapshot_base {}
+/**
+ * The name of the snapshot.
+ *
+ * Each snapshot must use this name and mapped to different hash tags.
+ */
+declare const SNAPSHOT_NAME = "open-insight-snapshot";
+declare const make$3: typeof Snapshot.make;
+//#endregion
+//#region src/sandbox/snapshot/decode.d.ts
+declare const Containerfile: Schema.decodeTo<typeof Snapshot, Schema.String, never, never>;
+declare const encode: (snapshot: Snapshot) => Effect.Effect<string, Schema.SchemaError, never>;
+declare const decode: (containerfile: string) => Effect.Effect<Snapshot, Schema.SchemaError, never>;
+declare namespace instruction_d_exports {
+  export { Instruction, Instructions, assert, available, cmd, copy, entrypoint, env, make$2 as make, run, user, workdir };
+}
+declare const Instruction: Schema.TaggedUnion<{
+  readonly Cmd: Schema.TaggedStruct<"Cmd", {
+    readonly cmd: Schema.$Array<Schema.String>;
+  }>;
+  readonly Copy: Schema.TaggedStruct<"Copy", {
+    readonly src: Schema.$Array<Schema.String>;
+    readonly dest: Schema.String;
+  }>;
+  readonly Entrypoint: Schema.TaggedStruct<"Entrypoint", {
+    readonly cmd: Schema.$Array<Schema.String>;
+  }>;
+  readonly Env: Schema.TaggedStruct<"Env", {
+    readonly env: Schema.$Record<Schema.String, Schema.String>;
+  }>;
+  readonly Run: Schema.TaggedStruct<"Run", {
+    readonly cmd: Schema.String;
+  }>;
+  readonly User: Schema.TaggedStruct<"User", {
+    /**
+     * Accepts either `"user"` or `"user:group"`.
+     */
+    readonly user: Schema.String;
+  }>;
+  readonly Workdir: Schema.TaggedStruct<"Workdir", {
+    readonly path: Schema.String;
+  }>;
+}>;
+type Instruction = Schema.Schema.Type<typeof Instruction>;
+declare const workdir: (workdir: string) => Instruction;
+declare const user: (user: string) => Instruction;
+declare const run: (cmd: string) => Instruction;
+declare const assert: (...cmd: string[]) => Instruction;
+declare const available: (...program: string[]) => Instruction;
+declare const env: (env: Record<string, string>) => Instruction;
+declare const copy: (src: string[], dest: string) => Instruction;
+declare const cmd: (cmd: string[]) => Instruction;
+declare const entrypoint: (cmd: string[]) => Instruction;
+declare const Instructions: Schema.$Array<Schema.TaggedUnion<{
+  readonly Cmd: Schema.TaggedStruct<"Cmd", {
+    readonly cmd: Schema.$Array<Schema.String>;
+  }>;
+  readonly Copy: Schema.TaggedStruct<"Copy", {
+    readonly src: Schema.$Array<Schema.String>;
+    readonly dest: Schema.String;
+  }>;
+  readonly Entrypoint: Schema.TaggedStruct<"Entrypoint", {
+    readonly cmd: Schema.$Array<Schema.String>;
+  }>;
+  readonly Env: Schema.TaggedStruct<"Env", {
+    readonly env: Schema.$Record<Schema.String, Schema.String>;
+  }>;
+  readonly Run: Schema.TaggedStruct<"Run", {
+    readonly cmd: Schema.String;
+  }>;
+  readonly User: Schema.TaggedStruct<"User", {
+    /**
+     * Accepts either `"user"` or `"user:group"`.
+     */
+    readonly user: Schema.String;
+  }>;
+  readonly Workdir: Schema.TaggedStruct<"Workdir", {
+    readonly path: Schema.String;
+  }>;
+}>>;
+type Instructions = Schema.Schema.Type<typeof Instructions>;
+declare const make$2: (...instructions: Instruction[]) => Instructions;
+//#endregion
+//#region src/sandbox/snapshot/derive.d.ts
+declare const hash: (snapshot: Snapshot) => Effect.Effect<string, import("effect/PlatformError").PlatformError | import("effect/Schema").SchemaError, Crypto.Crypto>;
+/**
+ * Get the name of a snapshot. The built snapshot must be tagged with this name.
+ *
+ * - The name of a snapshot is always `open-insight-snapshot`.
+ * - The tag of a snapshot is the SHA-256 hash of the snapshot's content.
+ */
+declare const makeName$1: (snapshot: Snapshot) => Effect.Effect<string, import("effect/PlatformError").PlatformError | import("effect/Schema").SchemaError, Crypto.Crypto>;
+/**
+ * Create a snapshot from an OCI image reference.
+ */
+declare const fromImage: (image: Image) => Snapshot;
+/**
+ * Extend an existing snapshot with a set of new instructions, without changing the base image.
+ */
+declare const extend: ({
+  snapshot,
+  instructions
+}: {
+  snapshot: Snapshot;
+  instructions: Instructions;
+}) => Snapshot;
+/**
+ * Derive a new snapshot from an existing snapshot with a set of new instructions.
+ *
+ * Note that the base image of the given snapshot must exist.
+ */
+declare const derive: (args_0: {
+  snapshot: Snapshot;
+  instructions: Instructions;
+}) => Effect.Effect<Snapshot, import("effect/PlatformError").PlatformError | import("effect/Schema").SchemaError, Crypto.Crypto>;
+//#endregion
+//#region src/sandbox/context/schema.d.ts
+declare const DistFileType: Schema.Literal<".tar.gz">;
+type DistFileType = Schema.Schema.Type<typeof DistFileType>;
+declare const ModeSchema: Schema.TaggedUnion<{
+  readonly Cwd: Schema.TaggedStruct<"Cwd", {}>;
+  readonly Dir: Schema.TaggedStruct<"Dir", {
+    readonly path: Schema.String;
+  }>;
+  readonly Dist: Schema.TaggedStruct<"Dist", {
+    readonly url: Schema.String;
+    readonly fileType: Schema.Literal<".tar.gz">;
+  }>;
+  readonly Script: Schema.TaggedStruct<"Script", {}>;
+}>;
+type Mode = Schema.Schema.Type<typeof ModeSchema>;
+/**
+ * Context dir for snapshot update operations.
+ *
+ * Any file operations (e.g. COPY) must be resolved relative to this path.
+ */
+declare const ContextSchema: Schema.String;
+type Context$1 = Schema.Schema.Type<typeof ContextSchema>;
+declare namespace index_d_exports$4 {
+  export { Context$1 as Context, ContextSchema, Cwd, DistFileType, Mode, ModeSchema, Script, make$1 as make, makeDir, makeDist, resolve };
+}
+declare const resolve: (mode: import("effect/Schema").Struct.ReadonlySide<{
+  readonly _tag: import("effect/Schema").tag<"Cwd">;
+}, "Type"> | import("effect/Schema").Struct.ReadonlySide<{
+  readonly _tag: import("effect/Schema").tag<"Dir">;
+  readonly path: import("effect/Schema").String;
+}, "Type"> | import("effect/Schema").Struct.ReadonlySide<{
+  readonly _tag: import("effect/Schema").tag<"Dist">;
+  readonly url: import("effect/Schema").String;
+  readonly fileType: import("effect/Schema").Literal<".tar.gz">;
+}, "Type"> | import("effect/Schema").Struct.ReadonlySide<{
+  readonly _tag: import("effect/Schema").tag<"Script">;
+}, "Type">) => Effect.Effect<string, SandboxError, ChildProcessSpawner | FileSystem.FileSystem | HttpClient.HttpClient | Path.Path>;
+declare const make$1: typeof ModeSchema.make;
+/**
+ * Indicates that the context should be a specific directory.
+ */
+declare const makeDir: (path: string) => import("effect/Schema").Struct.ReadonlySide<{
+  readonly _tag: import("effect/Schema").tag<"Cwd">;
+}, "Type"> | import("effect/Schema").Struct.ReadonlySide<{
+  readonly _tag: import("effect/Schema").tag<"Dir">;
+  readonly path: import("effect/Schema").String;
+}, "Type"> | import("effect/Schema").Struct.ReadonlySide<{
+  readonly _tag: import("effect/Schema").tag<"Dist">;
+  readonly url: import("effect/Schema").String;
+  readonly fileType: import("effect/Schema").Literal<".tar.gz">;
+}, "Type"> | import("effect/Schema").Struct.ReadonlySide<{
+  readonly _tag: import("effect/Schema").tag<"Script">;
+}, "Type">;
+/**
+ * Indicates that the context should be downloaded from a distribution archive.
+ */
+declare const makeDist: ({
+  url,
+  fileType
+}: {
+  url: string;
+  fileType: DistFileType;
+}) => import("effect/Schema").Struct.ReadonlySide<{
+  readonly _tag: import("effect/Schema").tag<"Cwd">;
+}, "Type"> | import("effect/Schema").Struct.ReadonlySide<{
+  readonly _tag: import("effect/Schema").tag<"Dir">;
+  readonly path: import("effect/Schema").String;
+}, "Type"> | import("effect/Schema").Struct.ReadonlySide<{
+  readonly _tag: import("effect/Schema").tag<"Dist">;
+  readonly url: import("effect/Schema").String;
+  readonly fileType: import("effect/Schema").Literal<".tar.gz">;
+}, "Type"> | import("effect/Schema").Struct.ReadonlySide<{
+  readonly _tag: import("effect/Schema").tag<"Script">;
+}, "Type">;
+/**
+ * Indicates that the context should be the script's directory.
+ * This is useful for resolving relative paths in scripts.
+ */
+declare const Script: import("effect/Schema").Struct.ReadonlySide<{
+  readonly _tag: import("effect/Schema").tag<"Cwd">;
+}, "Type"> | import("effect/Schema").Struct.ReadonlySide<{
+  readonly _tag: import("effect/Schema").tag<"Dir">;
+  readonly path: import("effect/Schema").String;
+}, "Type"> | import("effect/Schema").Struct.ReadonlySide<{
+  readonly _tag: import("effect/Schema").tag<"Dist">;
+  readonly url: import("effect/Schema").String;
+  readonly fileType: import("effect/Schema").Literal<".tar.gz">;
+}, "Type"> | import("effect/Schema").Struct.ReadonlySide<{
+  readonly _tag: import("effect/Schema").tag<"Script">;
+}, "Type">;
+/**
+ * Indicates that the context should be the current working directory.
+ */
+declare const Cwd: import("effect/Schema").Struct.ReadonlySide<{
+  readonly _tag: import("effect/Schema").tag<"Cwd">;
+}, "Type"> | import("effect/Schema").Struct.ReadonlySide<{
+  readonly _tag: import("effect/Schema").tag<"Dir">;
+  readonly path: import("effect/Schema").String;
+}, "Type"> | import("effect/Schema").Struct.ReadonlySide<{
+  readonly _tag: import("effect/Schema").tag<"Dist">;
+  readonly url: import("effect/Schema").String;
+  readonly fileType: import("effect/Schema").Literal<".tar.gz">;
+}, "Type"> | import("effect/Schema").Struct.ReadonlySide<{
+  readonly _tag: import("effect/Schema").tag<"Script">;
+}, "Type">;
+//#endregion
+//#region src/sandbox/snapshot/build.d.ts
+declare const fromContainerfile: (args_0: {
+  context: Mode;
+  filePath: string;
+}) => Effect.Effect<Snapshot, import("effect/PlatformError").PlatformError | SandboxError | import("effect/Schema").SchemaError, import("effect/unstable/process/ChildProcessSpawner").ChildProcessSpawner | FileSystem.FileSystem | import("effect/unstable/http/HttpClient").HttpClient | Path.Path>;
+declare namespace index_d_exports$3 {
+  export { Containerfile, Image, instruction_d_exports as Inst, SNAPSHOT_NAME, Snapshot, decode, derive, encode, extend, fromContainerfile, fromImage, hash, make$3 as make, makeName$1 as makeName };
+}
+declare namespace error_d_exports {
+  export { ContextResolveError, InstructionUnsupportedError, ProviderError, SandboxError, SandboxErrorReason, SandboxExecError, SandboxExposeError, SnapshotError, SnapshotUnsupportedError };
+}
+declare const ContextResolveError_base: Schema.Class<ContextResolveError, Schema.TaggedStruct<"ContextResolveError", {
+  readonly mode: Schema.TaggedUnion<{
+    readonly Cwd: Schema.TaggedStruct<"Cwd", {}>;
+    readonly Dir: Schema.TaggedStruct<"Dir", {
+      readonly path: Schema.String;
+    }>;
+    readonly Dist: Schema.TaggedStruct<"Dist", {
+      readonly url: Schema.String;
+      readonly fileType: Schema.Literal<".tar.gz">;
+    }>;
+    readonly Script: Schema.TaggedStruct<"Script", {}>;
+  }>;
+  readonly cause: Schema.Defect;
+}>, import("effect/Cause").YieldableError>;
+declare class ContextResolveError extends ContextResolveError_base {}
+declare const SnapshotError_base: Schema.Class<SnapshotError, Schema.TaggedStruct<"SnapshotError", {
+  readonly kind: Schema.Union<readonly [Schema.Literal<"build">, Schema.Literal<"use">]>;
+  readonly snapshot: typeof Snapshot;
+  readonly cause: Schema.Defect;
+  readonly message: Schema.optional<Schema.String>;
+}>, import("effect/Cause").YieldableError>;
+declare class SnapshotError extends SnapshotError_base {}
+declare const ProviderError_base: Schema.Class<ProviderError, Schema.TaggedStruct<"ProviderError", {
+  readonly name: Schema.String;
+  readonly cause: Schema.Defect;
+}>, import("effect/Cause").YieldableError>;
+declare class ProviderError extends ProviderError_base {}
+declare const SandboxExecError_base: Schema.Class<SandboxExecError, Schema.TaggedStruct<"SandboxExecError", {
+  readonly name: Schema.String;
+  readonly operation: Schema.String;
+  readonly cause: Schema.Defect;
+}>, import("effect/Cause").YieldableError>;
+declare class SandboxExecError extends SandboxExecError_base {}
+declare const SandboxExposeError_base: Schema.Class<SandboxExposeError, Schema.TaggedStruct<"SandboxExposeError", {
+  readonly name: Schema.String;
+  readonly sandboxPort: Schema.Number;
+  readonly hostPort: Schema.Number;
+  readonly cause: Schema.Defect;
+}>, import("effect/Cause").YieldableError>;
+declare class SandboxExposeError extends SandboxExposeError_base {}
+declare const SnapshotUnsupportedError_base: Schema.Class<SnapshotUnsupportedError, Schema.TaggedStruct<"SnapshotUnsupportedError", {
+  readonly name: Schema.String;
+  readonly snapshot: typeof Snapshot;
+  readonly cause: Schema.Defect;
+}>, import("effect/Cause").YieldableError>;
+declare class SnapshotUnsupportedError extends SnapshotUnsupportedError_base {}
+declare const InstructionUnsupportedError_base: Schema.Class<InstructionUnsupportedError, Schema.TaggedStruct<"InstructionUnsupportedError", {
+  readonly name: Schema.String;
+  readonly snapshot: typeof Snapshot;
+  readonly instruction: Schema.TaggedUnion<{
+    readonly Cmd: Schema.TaggedStruct<"Cmd", {
+      readonly cmd: Schema.$Array<Schema.String>;
+    }>;
+    readonly Copy: Schema.TaggedStruct<"Copy", {
+      readonly src: Schema.$Array<Schema.String>;
+      readonly dest: Schema.String;
+    }>;
+    readonly Entrypoint: Schema.TaggedStruct<"Entrypoint", {
+      readonly cmd: Schema.$Array<Schema.String>;
+    }>;
+    readonly Env: Schema.TaggedStruct<"Env", {
+      readonly env: Schema.$Record<Schema.String, Schema.String>;
+    }>;
+    readonly Run: Schema.TaggedStruct<"Run", {
+      readonly cmd: Schema.String;
+    }>;
+    readonly User: Schema.TaggedStruct<"User", {
+      readonly user: Schema.String;
+    }>;
+    readonly Workdir: Schema.TaggedStruct<"Workdir", {
+      readonly path: Schema.String;
+    }>;
+  }>;
+}>, import("effect/Cause").YieldableError>;
+declare class InstructionUnsupportedError extends InstructionUnsupportedError_base {}
+declare const SandboxErrorReason: Schema.Union<readonly [typeof ContextResolveError, typeof ProviderError, typeof SnapshotError, typeof SandboxExecError, typeof SandboxExposeError, typeof SnapshotUnsupportedError, typeof InstructionUnsupportedError]>;
+declare const SandboxError_base: Schema.Class<SandboxError, Schema.TaggedStruct<"SandboxError", {
+  readonly reason: Schema.Union<readonly [typeof ContextResolveError, typeof ProviderError, typeof SnapshotError, typeof SandboxExecError, typeof SandboxExposeError, typeof SnapshotUnsupportedError, typeof InstructionUnsupportedError]>;
+}>, import("effect/Cause").YieldableError>;
+declare class SandboxError extends SandboxError_base {
+  static contextResolve: (mode: Mode) => (cause: unknown) => SandboxError;
+  static provider: (name: string) => (cause: unknown) => SandboxError;
+  static snapshotBuild: (snapshot: Snapshot) => (cause: unknown) => SandboxError;
+  static snapshotUsage: (snapshot: Snapshot) => (cause: unknown) => SandboxError;
+  static sandboxExec: ({
+    name,
+    operation
+  }: {
+    name: string;
+    operation: string;
+  }) => (cause: unknown) => SandboxError;
+  static sandboxExpose: ({
+    name,
+    sandboxPort,
+    hostPort
+  }: {
+    name: string;
+    sandboxPort: number;
+    hostPort: number;
+  }) => (cause: unknown) => SandboxError;
+  static snapshotUnsupported: (name: string, snapshot: Snapshot) => (cause: unknown) => SandboxError;
+  static instructionUnsupported: (name: string, snapshot: Snapshot, instruction: Instruction) => SandboxError;
+}
+//#endregion
+//#region src/sandbox/resource.d.ts
+declare const ResourceLimitsSchema: Schema.Struct<{
+  readonly numCPUs: Schema.optionalKey<Schema.Number>;
+  readonly numGPUs: Schema.optionalKey<Schema.Int>;
+  readonly memoryMiB: Schema.optionalKey<Schema.Int>;
+  readonly diskMiB: Schema.optionalKey<Schema.Int>;
+}>;
+type ResourceLimits = Schema.Schema.Type<typeof ResourceLimitsSchema>;
+//#endregion
+//#region ../utils/dist/index.d.mts
+//#region src/spawn.d.ts
+declare namespace spawn_d_exports {
+  export { SpawnError, SpawnErrorReason, SpawnExitCodeError, SpawnService };
+}
+declare const SpawnExitCodeError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "SpawnExitCodeError";
+} & Readonly<A>;
+declare class SpawnExitCodeError extends SpawnExitCodeError_base<{
+  readonly exitCode: ExitCode;
+  readonly stdout: string;
+  readonly stderr: string;
+}> {
+  get message(): string;
+}
+type SpawnErrorReason = PlatformError.PlatformError | SpawnExitCodeError;
+declare const SpawnError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "SpawnError";
+} & Readonly<A>;
+declare class SpawnError extends SpawnError_base<{
+  readonly reason: SpawnErrorReason;
+}> {
+  get message(): string;
+  static platform: (err: PlatformError.PlatformError) => SpawnError;
+  static exit: ({
+    exitCode,
+    stdout,
+    stderr
+  }: {
+    exitCode: ExitCode;
+    stdout: string;
+    stderr: string;
+  }) => SpawnError;
+}
+declare const SpawnService_base: Context.ServiceClass<SpawnService, "packages/utils/SpawnService", {
+  spawn(command: Command): Effect.Effect<ChildProcessHandle, SpawnError, Scope.Scope>;
+  exitCode(command: Command): Effect.Effect<ExitCode, SpawnError>;
+  streamString(command: Command, options?: {
+    readonly includeStderr?: boolean | undefined;
+  }): Stream.Stream<string, SpawnError>;
+  streamLines(command: Command, options?: {
+    readonly includeStderr?: boolean | undefined;
+  }): Stream.Stream<string, SpawnError>;
+  string(command: Command, options?: {
+    readonly includeStderr?: boolean | undefined;
+  }): Effect.Effect<string, SpawnError>;
+  lines(command: Command, options?: {
+    readonly includeStderr?: boolean | undefined;
+  }): Effect.Effect<ReadonlyArray<string>, SpawnError>;
+}>;
+declare class SpawnService extends SpawnService_base {
+  static readonly layer: Layer.Layer<SpawnService, never, ChildProcessSpawner>;
+}
+//#endregion
+//#region src/sandbox/sandbox/promise.d.ts
+type SandboxPromise = {
+  $(options: {
+    command: string;
+    args?: string[];
+    env?: Record<string, string>;
+    cwd?: string;
+  }): Promise<string>;
+  readFile(options: Readonly<{
+    sandboxPath: string;
+  }>): Promise<string>;
+  writeFile(options: Readonly<{
+    sandboxPath: string;
+    content: string;
+  }>): Promise<void>;
+  download(options: Readonly<{
+    sandboxPath: string;
+    hostPath: string;
+  }>): Promise<void>;
+  upload(options: Readonly<{
+    sandboxPath: string;
+    hostPath: string;
+  }>): Promise<void>;
+  expose(options: Readonly<{
+    sandboxPort: number;
+    hostPort: number;
+  }>): Promise<{
+    hostUrl: string;
+  }>;
+};
+declare const asPromise: (_sandbox: Sandbox) => SandboxPromise;
+//#endregion
+//#region src/sandbox/sandbox/index.d.ts
+declare const SANDBOX_NAME = "open-insight-sandbox";
+declare const makeName: (snapshot: Snapshot) => Effect.Effect<string, import("effect/PlatformError").PlatformError | import("effect/Schema").SchemaError, Crypto.Crypto>;
+type Sandbox = Readonly<{
+  $(process: ChildProcess.Command): Effect.Effect<string, SandboxError>;
+  readFile(options: Readonly<{
+    sandboxPath: string;
+  }>): Effect.Effect<string, SandboxError>;
+  writeFile(options: Readonly<{
+    sandboxPath: string;
+    content: string;
+  }>): Effect.Effect<void, SandboxError>;
+  download(options: Readonly<{
+    sandboxPath: string;
+    hostPath: string;
+  }>): Effect.Effect<void, SandboxError>;
+  upload(options: Readonly<{
+    sandboxPath: string;
+    hostPath: string;
+  }>): Effect.Effect<void, SandboxError>;
+  expose(options: Readonly<{
+    sandboxPort: number;
+    hostPort: number;
+  }>): Effect.Effect<{
+    hostUrl: string;
+  }, SandboxError>;
+}>;
+type MakeSandboxOptions = Readonly<{
+  $(process: ChildProcess.StandardCommand, stdin?: string): Effect.Effect<string, SandboxError>;
+  expose: Sandbox["expose"];
+  download: Sandbox["download"] | "rsync";
+  upload: Sandbox["upload"] | "rsync";
+  readFile: Sandbox["readFile"] | "cat";
+  writeFile: Sandbox["writeFile"] | "tee";
+}>;
+declare const make: (args_0: Readonly<{
+  $(process: ChildProcess.StandardCommand, stdin?: string): Effect.Effect<string, SandboxError>;
+  expose: Sandbox["expose"];
+  download: Sandbox["download"] | "rsync";
+  upload: Sandbox["upload"] | "rsync";
+  readFile: Sandbox["readFile"] | "cat";
+  writeFile: Sandbox["writeFile"] | "tee";
+}>) => Effect.Effect<Readonly<{
+  $(process: ChildProcess.Command): Effect.Effect<string, SandboxError>;
+  readFile(options: Readonly<{
+    sandboxPath: string;
+  }>): Effect.Effect<string, SandboxError>;
+  writeFile(options: Readonly<{
+    sandboxPath: string;
+    content: string;
+  }>): Effect.Effect<void, SandboxError>;
+  download(options: Readonly<{
+    sandboxPath: string;
+    hostPath: string;
+  }>): Effect.Effect<void, SandboxError>;
+  upload(options: Readonly<{
+    sandboxPath: string;
+    hostPath: string;
+  }>): Effect.Effect<void, SandboxError>;
+  expose(options: Readonly<{
+    sandboxPort: number;
+    hostPort: number;
+  }>): Effect.Effect<{
+    hostUrl: string;
+  }, SandboxError>;
+}>, SandboxError, spawn_d_exports.SpawnService>;
+//#endregion
+//#region src/sandbox/provider/service.d.ts
+type Provider$1 = Readonly<{
+  /**
+   * Ensure that the given snapshot exists in the provider's storage.
+   *
+   * The snapshot must be indexed with the hash of the snapshot's containerfile.
+   */
+  ensureSnapshot(options: Readonly<{
+    snapshot: Snapshot;
+    context: Mode;
+  }>): Effect.Effect<void, SandboxError>;
+  /**
+   * Derive a new snapshot from an existing snapshot and a set of instructions.
+   *
+   * The new snapshot must be indexed with the hash of the derived snapshot's containerfile.
+   */
+  deriveSnapshot(options: Readonly<{
+    snapshot: Snapshot;
+    context: Mode;
+    instructions: Instructions;
+  }>): Effect.Effect<void, SandboxError>;
+  /**
+   * Remove a snapshot from the provider's storage.
+   */
+  removeSnapshot(options: Readonly<{
+    snapshot: Snapshot;
+  }>): Effect.Effect<void, SandboxError>;
+  /**
+   * Run a sandbox with the given snapshot.
+   *
+   * The sandbox is scoped and will be automatically cleaned up.
+   */
+  runSandbox(options: Readonly<{
+    snapshot: Snapshot;
+    resources: ResourceLimits | null;
+  }>): Effect.Effect<Sandbox, SandboxError, Scope.Scope>;
+}>;
+declare const ProviderService_base$1: Context.ServiceClass<ProviderService$1, "sandbox/ProviderService", Readonly<{
+  /**
+   * Ensure that the given snapshot exists in the provider's storage.
+   *
+   * The snapshot must be indexed with the hash of the snapshot's containerfile.
+   */
+  ensureSnapshot(options: Readonly<{
+    snapshot: Snapshot;
+    context: import("effect/Schema").Struct.ReadonlySide<{
+      readonly _tag: import("effect/Schema").tag<"Cwd">;
+    }, "Type"> | import("effect/Schema").Struct.ReadonlySide<{
+      readonly _tag: import("effect/Schema").tag<"Dir">;
+      readonly path: import("effect/Schema").String;
+    }, "Type"> | import("effect/Schema").Struct.ReadonlySide<{
+      readonly _tag: import("effect/Schema").tag<"Dist">;
+      readonly url: import("effect/Schema").String;
+      readonly fileType: import("effect/Schema").Literal<".tar.gz">;
+    }, "Type"> | import("effect/Schema").Struct.ReadonlySide<{
+      readonly _tag: import("effect/Schema").tag<"Script">;
+    }, "Type">;
+  }>): Effect.Effect<void, SandboxError>;
+  /**
+   * Derive a new snapshot from an existing snapshot and a set of instructions.
+   *
+   * The new snapshot must be indexed with the hash of the derived snapshot's containerfile.
+   */
+  deriveSnapshot(options: Readonly<{
+    snapshot: Snapshot;
+    context: import("effect/Schema").Struct.ReadonlySide<{
+      readonly _tag: import("effect/Schema").tag<"Cwd">;
+    }, "Type"> | import("effect/Schema").Struct.ReadonlySide<{
+      readonly _tag: import("effect/Schema").tag<"Dir">;
+      readonly path: import("effect/Schema").String;
+    }, "Type"> | import("effect/Schema").Struct.ReadonlySide<{
+      readonly _tag: import("effect/Schema").tag<"Dist">;
+      readonly url: import("effect/Schema").String;
+      readonly fileType: import("effect/Schema").Literal<".tar.gz">;
+    }, "Type"> | import("effect/Schema").Struct.ReadonlySide<{
+      readonly _tag: import("effect/Schema").tag<"Script">;
+    }, "Type">;
+    instructions: readonly (import("effect/Schema").Struct.ReadonlySide<{
+      readonly _tag: import("effect/Schema").tag<"Cmd">;
+      readonly cmd: import("effect/Schema").$Array<import("effect/Schema").String>;
+    }, "Type"> | import("effect/Schema").Struct.ReadonlySide<{
+      readonly _tag: import("effect/Schema").tag<"Copy">;
+      readonly src: import("effect/Schema").$Array<import("effect/Schema").String>;
+      readonly dest: import("effect/Schema").String;
+    }, "Type"> | import("effect/Schema").Struct.ReadonlySide<{
+      readonly _tag: import("effect/Schema").tag<"Entrypoint">;
+      readonly cmd: import("effect/Schema").$Array<import("effect/Schema").String>;
+    }, "Type"> | import("effect/Schema").Struct.ReadonlySide<{
+      readonly _tag: import("effect/Schema").tag<"Env">;
+      readonly env: import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").String>;
+    }, "Type"> | import("effect/Schema").Struct.ReadonlySide<{
+      readonly _tag: import("effect/Schema").tag<"Run">;
+      readonly cmd: import("effect/Schema").String;
+    }, "Type"> | import("effect/Schema").Struct.ReadonlySide<{
+      readonly _tag: import("effect/Schema").tag<"User">;
+      readonly user: import("effect/Schema").String;
+    }, "Type"> | import("effect/Schema").Struct.ReadonlySide<{
+      readonly _tag: import("effect/Schema").tag<"Workdir">;
+      readonly path: import("effect/Schema").String;
+    }, "Type">)[];
+  }>): Effect.Effect<void, SandboxError>;
+  /**
+   * Remove a snapshot from the provider's storage.
+   */
+  removeSnapshot(options: Readonly<{
+    snapshot: Snapshot;
+  }>): Effect.Effect<void, SandboxError>;
+  /**
+   * Run a sandbox with the given snapshot.
+   *
+   * The sandbox is scoped and will be automatically cleaned up.
+   */
+  runSandbox(options: Readonly<{
+    snapshot: Snapshot;
+    resources: {
+      readonly numCPUs?: number | undefined;
+      readonly numGPUs?: number | undefined;
+      readonly memoryMiB?: number | undefined;
+      readonly diskMiB?: number | undefined;
+    } | null;
+  }>): Effect.Effect<Sandbox, SandboxError, Scope.Scope>;
+}>>;
+declare class ProviderService$1 extends ProviderService_base$1 {}
+//#endregion
+//#region src/sandbox/provider/utils.d.ts
+declare const bashQuote: (value: string) => string;
+declare const formatBash: (command: ChildProcess.StandardCommand) => string;
+declare namespace index_d_exports$2 {
+  export { Provider$1 as Provider, ProviderService$1 as ProviderService, bashQuote, formatBash };
+}
+//#endregion
+//#region src/sandbox/config.d.ts
+type Config = Readonly<{
+  cacheSnapshot?: boolean;
+}>;
+//#endregion
+//#region src/agent/error.d.ts
+declare const StreamError_base: Schema.Class<StreamError, Schema.TaggedStruct<"StreamError", {
+  readonly cause: Schema.Defect;
+}>, import("effect/Cause").YieldableError>;
+declare class StreamError extends StreamError_base {}
+declare const AgentErrorReason: Schema.Union<readonly [typeof StreamError]>;
+declare const AgentError_base: Schema.Class<AgentError, Schema.TaggedStruct<"AgentError", {
+  readonly reason: Schema.Union<readonly [typeof StreamError]>;
+}>, import("effect/Cause").YieldableError>;
+declare class AgentError extends AgentError_base {
+  static stream: (error: AiError.AiError) => AgentError;
+}
+declare namespace index_d_exports$1 {
+  export { Config, index_d_exports$4 as Context, ContextResolveError, error_d_exports as Error, InstructionUnsupportedError, MakeSandboxOptions, Provider$1 as Provider, ProviderError, ProviderService$1 as ProviderService, ResourceLimits, ResourceLimitsSchema, SANDBOX_NAME, Sandbox, SandboxError, SandboxErrorReason, SandboxExecError, SandboxExposeError, SandboxPromise, index_d_exports$3 as Snapshot, SnapshotError, SnapshotUnsupportedError, asPromise, bashQuote, formatBash, make, makeName };
+}
+//#endregion
+//#region src/agent/service.d.ts
+type Agent = Readonly<{
+  trajectory(): Effect.Effect<Prompt$1, AgentError>;
+  prompt(options: {
+    prompt: ReadonlyArray<Prompt.UserMessage>;
+  }): Effect.Effect<Stream.Stream<Response.StreamPart<any>, AgentError>>;
+}>;
+type Provider = Readonly<{
+  deriveSnapshot: (options: Readonly<{
+    snapshot: Snapshot;
+    context: Mode;
+  }>) => Effect.Effect<Snapshot, AgentError>;
+  runSession(options: Readonly<{
+    sandbox: Sandbox;
+  }>): Effect.Effect<Agent, AgentError>;
+}>;
+declare const ProviderService_base: Context.ServiceClass<ProviderService, "agent/AgentService", Readonly<{
+  deriveSnapshot: (options: Readonly<{
+    snapshot: Snapshot;
+    context: Mode;
+  }>) => Effect.Effect<Snapshot, AgentError>;
+  runSession(options: Readonly<{
+    sandbox: Sandbox;
+  }>): Effect.Effect<Agent, AgentError>;
+}>>;
+declare class ProviderService extends ProviderService_base {}
+declare namespace index_d_exports {
+  export { Agent, AgentError, AgentErrorReason, AssistantMessage, Message, Provider, ProviderService, StreamError, SystemMessage, ToolMessage, Trajectory, UserMessage };
+}
+import * as import_effect_unstable_ai from "effect/unstable/ai";
+//#endregion
+export { makeDir as A, makeName$1 as B, ResourceLimits as C, Cwd as D, index_d_exports$3 as E, ModeSchema as F, Snapshot as G, Instructions as H, derive as I, make$3 as K, extend as L, Context$1 as M, ContextSchema as N, Script as O, Mode as P, fromImage as R, asPromise as S, SandboxError as T, instruction_d_exports as U, Instruction as V, Image as W, Provider$1 as _, Trajectory as a, make as b, Agent as c, index_d_exports$1 as d, AgentError as f, formatBash as g, bashQuote as h, ToolMessage as i, makeDist as j, make$1 as k, Provider as l, index_d_exports$2 as m, Message as n, UserMessage as o, Config as p, SystemMessage as r, index_d_exports as s, AssistantMessage as t, ProviderService as u, ProviderService$1 as v, ResourceLimitsSchema as w, SandboxPromise as x, Sandbox as y, hash as z };
+//# sourceMappingURL=index-CmxU7-9a.d.mts.map