@open-insight/core 0.0.0

package/dist/agent-2V5_4nlu.mjs

@@ -0,0 +1,676 @@
+import { n as __reExport, t as __exportAll$1 } from "./rolldown-runtime-BBjsoOtd.mjs";
+import { Context, Crypto, Data, Effect, Encoding, FileSystem, Latch, Layer, Match, Option, Path, Ref, Schema, SchemaGetter, SchemaIssue, Stream } from "effect";
+import { Cmd, Copy, DockerfileParser, Entrypoint, Env, Run, User, Workdir } from "dockerfile-ast";
+import { HttpClient, HttpClientResponse } from "effect/unstable/http";
+import { ChildProcessSpawner } from "effect/unstable/process/ChildProcessSpawner";
+import { ChildProcess } from "effect/unstable/process";
+import "effect/unstable/ai";
+import { AssistantMessage, Message, Prompt as Trajectory, SystemMessage, ToolMessage, UserMessage } from "effect/unstable/ai/Prompt";
+//#region src/sandbox/snapshot/instruction.ts
+var instruction_exports = /* @__PURE__ */ __exportAll$1({
+	Instruction: () => Instruction,
+	Instructions: () => Instructions,
+	assert: () => assert,
+	available: () => available,
+	cmd: () => cmd,
+	copy: () => copy,
+	entrypoint: () => entrypoint,
+	env: () => env,
+	make: () => make$4,
+	run: () => run,
+	user: () => user,
+	workdir: () => workdir
+});
+const Instruction = Schema.TaggedUnion({
+	Workdir: { path: Schema.String },
+	User: { 
+	/**
+	* Accepts either `"user"` or `"user:group"`.
+	*/
+user: Schema.String },
+	Run: { cmd: Schema.String },
+	Env: { env: Schema.Record(Schema.String, Schema.String) },
+	Copy: {
+		src: Schema.Array(Schema.String),
+		dest: Schema.String
+	},
+	Cmd: { cmd: Schema.Array(Schema.String) },
+	Entrypoint: { cmd: Schema.Array(Schema.String) }
+});
+const workdir = (workdir) => Instruction.make({
+	_tag: "Workdir",
+	path: workdir
+});
+const user = (user) => Instruction.make({
+	_tag: "User",
+	user
+});
+const run = (cmd) => Instruction.make({
+	_tag: "Run",
+	cmd
+});
+const assert = (...cmd) => Instruction.make({
+	_tag: "Run",
+	cmd: cmd.join(" && ") + " || exit 1"
+});
+const available = (...program) => assert(...program.map((p) => `command -v ${p}`));
+const env = (env) => Instruction.make({
+	_tag: "Env",
+	env
+});
+const copy = (src, dest) => Instruction.make({
+	_tag: "Copy",
+	src,
+	dest
+});
+const cmd = (cmd) => Instruction.make({
+	_tag: "Cmd",
+	cmd
+});
+const entrypoint = (cmd) => Instruction.make({
+	_tag: "Entrypoint",
+	cmd
+});
+const Instructions = Schema.Array(Instruction);
+const make$4 = (...instructions) => Instructions.make(instructions);
+//#endregion
+//#region src/sandbox/snapshot/schema.ts
+/**
+* OCI image reference (e.g. `docker.io/library/node:18-alpine`).
+*/
+const Image = Schema.String;
+var Snapshot = class extends Schema.Class("Snapshot")({
+	image: Image,
+	instructions: Instructions
+}) {};
+/**
+* The name of the snapshot.
+*
+* Each snapshot must use this name and mapped to different hash tags.
+*/
+const SNAPSHOT_NAME = "open-insight-snapshot";
+const make$3 = (args) => Snapshot.make(args);
+//#endregion
+//#region src/sandbox/snapshot/decode.ts
+const encodeInstruction = (instruction) => Instruction.match(instruction, {
+	Workdir: ({ path }) => `WORKDIR ${path}`,
+	User: ({ user }) => `USER ${user}`,
+	Run: ({ cmd }) => `RUN ${cmd}`,
+	Env: ({ env }) => {
+		return `ENV ${Object.keys(env).sort().map((key) => `${key}=${env[key]}`).join(" ")}`;
+	},
+	Copy: ({ src, dest }) => `COPY ${JSON.stringify([...src, dest])}`,
+	Cmd: ({ cmd }) => `CMD ${JSON.stringify(cmd)}`,
+	Entrypoint: ({ cmd }) => `ENTRYPOINT ${JSON.stringify(cmd)}`
+});
+const invalidContainerfile = (containerfile, message) => new SchemaIssue.InvalidValue(Option.some(containerfile), { message });
+const requireArguments = Effect.fn("containerfile/requireArguments")(function* (containerfile, instruction) {
+	const argumentsContent = instruction.getArgumentsContent();
+	if (argumentsContent === null) return yield* Effect.fail(invalidContainerfile(containerfile, `${instruction.getKeyword()} instruction is missing arguments`));
+	return argumentsContent;
+});
+const requireNoFlags = Effect.fn("containerfile/requireNoFlags")(function* (containerfile, instruction) {
+	if (instruction.getFlags().length !== 0) return yield* Effect.fail(invalidContainerfile(containerfile, `${instruction.getKeyword()} flags are not supported by Snapshot`));
+});
+const decodeJsonArguments = Effect.fn("containerfile/decodeJsonArguments")(function* (containerfile, instruction) {
+	const openingBracket = instruction.getOpeningBracket();
+	const closingBracket = instruction.getClosingBracket();
+	if (openingBracket === null || closingBracket === null) return yield* Effect.fail(invalidContainerfile(containerfile, `${instruction.getKeyword()} must use JSON array form`));
+	return instruction.getJSONStrings().map((argument) => argument.getJSONValue());
+});
+const decodeCopyArguments = Effect.fn("containerfile/decodeCopyArguments")(function* (containerfile, instruction) {
+	const openingBracket = instruction.getOpeningBracket();
+	const closingBracket = instruction.getClosingBracket();
+	if (openingBracket === null && closingBracket === null) return instruction.getArguments().map((argument) => argument.getValue());
+	if (openingBracket !== null && closingBracket !== null) return instruction.getJSONStrings().map((argument) => argument.getJSONValue());
+	return yield* Effect.fail(invalidContainerfile(containerfile, "COPY has an incomplete JSON array"));
+});
+const decodeInstruction = Effect.fn("containerfile/decodeInstruction")(function* (containerfile, instruction) {
+	if (instruction instanceof Workdir) return Instruction.make({
+		_tag: "Workdir",
+		path: yield* requireArguments(containerfile, instruction)
+	});
+	if (instruction instanceof User) return Instruction.make({
+		_tag: "User",
+		user: yield* requireArguments(containerfile, instruction)
+	});
+	if (instruction instanceof Run) {
+		yield* requireNoFlags(containerfile, instruction);
+		return Instruction.make({
+			_tag: "Run",
+			cmd: yield* requireArguments(containerfile, instruction)
+		});
+	}
+	if (instruction instanceof Env) {
+		const env = {};
+		for (const property of instruction.getProperties()) {
+			const key = property.getName();
+			const value = property.getValue();
+			if (value === null) return yield* Effect.fail(invalidContainerfile(containerfile, `ENV ${key} is missing a value`));
+			env[key] = value;
+		}
+		return Instruction.make({
+			_tag: "Env",
+			env
+		});
+	}
+	if (instruction instanceof Copy) {
+		yield* requireNoFlags(containerfile, instruction);
+		const argumentsContent = yield* decodeCopyArguments(containerfile, instruction);
+		if (argumentsContent.length < 2) return yield* Effect.fail(invalidContainerfile(containerfile, "COPY must include at least one source and one destination"));
+		return Instruction.make({
+			_tag: "Copy",
+			src: argumentsContent.slice(0, -1),
+			dest: argumentsContent[argumentsContent.length - 1]
+		});
+	}
+	if (instruction instanceof Cmd) {
+		yield* requireNoFlags(containerfile, instruction);
+		return Instruction.make({
+			_tag: "Cmd",
+			cmd: yield* decodeJsonArguments(containerfile, instruction)
+		});
+	}
+	if (instruction instanceof Entrypoint) {
+		yield* requireNoFlags(containerfile, instruction);
+		return Instruction.make({
+			_tag: "Entrypoint",
+			cmd: yield* decodeJsonArguments(containerfile, instruction)
+		});
+	}
+	return yield* Effect.fail(invalidContainerfile(containerfile, `${instruction.getKeyword()} instruction is not supported by Snapshot`));
+});
+const decodeContainerfile = Effect.fn("containerfile")(function* (containerfile) {
+	const dockerfile = yield* Effect.try({
+		try: () => DockerfileParser.parse(containerfile),
+		catch: (cause) => invalidContainerfile(containerfile, `Failed to parse Containerfile: ${String(cause)}`)
+	});
+	const froms = dockerfile.getFROMs();
+	if (froms.length !== 1) return yield* Effect.fail(invalidContainerfile(containerfile, `Expected exactly one FROM instruction, found ${froms.length}`));
+	const image = froms[0].getImage();
+	if (image === null) return yield* Effect.fail(invalidContainerfile(containerfile, "FROM instruction is missing an image"));
+	const instructions = [];
+	for (const instruction of dockerfile.getInstructions()) {
+		if (instruction === froms[0]) continue;
+		instructions.push(yield* decodeInstruction(containerfile, instruction));
+	}
+	return Snapshot.make({
+		image,
+		instructions
+	});
+});
+const Containerfile = Schema.String.pipe(Schema.decodeTo(Snapshot, {
+	decode: SchemaGetter.transformOrFail(decodeContainerfile),
+	encode: SchemaGetter.transform(({ image, instructions }) => {
+		return `${[`FROM ${image}`, ...instructions.map(encodeInstruction)].join("\n")}\n`;
+	})
+}));
+const encode = (snapshot) => Schema.encodeEffect(Containerfile)(snapshot);
+const decode = (containerfile) => Schema.decodeEffect(Containerfile)(containerfile);
+//#endregion
+//#region src/sandbox/snapshot/derive.ts
+const hash = Effect.fn(function* (snapshot) {
+	const crypto = yield* Crypto.Crypto;
+	const containerfile = yield* encode(snapshot);
+	const bytes = new TextEncoder().encode(containerfile);
+	const digest = yield* crypto.digest("SHA-256", bytes);
+	return Encoding.encodeHex(digest);
+});
+/**
+* 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.
+*/
+const makeName$1 = Effect.fn(function* (snapshot) {
+	return `${SNAPSHOT_NAME}:${yield* hash(snapshot)}`;
+});
+/**
+* Create a snapshot from an OCI image reference.
+*/
+const fromImage = (image) => Snapshot.make({
+	image,
+	instructions: []
+});
+/**
+* Extend an existing snapshot with a set of new instructions, without changing the base image.
+*/
+const extend = ({ snapshot, instructions }) => Snapshot.make({
+	image: snapshot.image,
+	instructions: [...snapshot.instructions, ...instructions]
+});
+/**
+* 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.
+*/
+const derive = Effect.fn(function* ({ snapshot, instructions }) {
+	const image = yield* makeName$1(snapshot);
+	return Snapshot.make({
+		image,
+		instructions
+	});
+});
+//#endregion
+//#region src/sandbox/context/schema.ts
+const DistFileType = Schema.Literal(".tar.gz");
+const ModeSchema = Schema.TaggedUnion({
+	Dir: { path: Schema.String },
+	Dist: {
+		url: Schema.String,
+		fileType: DistFileType
+	},
+	Script: {},
+	Cwd: {}
+});
+/**
+* Context dir for snapshot update operations.
+*
+* Any file operations (e.g. COPY) must be resolved relative to this path.
+*/
+const ContextSchema = Schema.String;
+//#endregion
+//#region src/sandbox/context/dist.ts
+const decodeUrl = Schema.decodeUnknownEffect(Schema.URLFromString);
+const extractTarGz = Effect.fn(function* (archivePath) {
+	const fs = yield* FileSystem.FileSystem;
+	const spawner = yield* ChildProcessSpawner;
+	const dir = yield* fs.makeTempDirectory({ prefix: "open-insight-dist-" });
+	const exitCode = yield* spawner.exitCode(ChildProcess.make("tar", [
+		"-xzf",
+		archivePath,
+		"-C",
+		dir
+	]));
+	if (exitCode !== 0) return yield* Effect.fail(/* @__PURE__ */ new Error(`tar exited with code ${exitCode}`));
+	return dir;
+});
+const resolveDistContext = Effect.fn(function* ({ url, fileType }) {
+	const fs = yield* FileSystem.FileSystem;
+	const parsedUrl = yield* decodeUrl(url);
+	const archivePath = yield* fs.makeTempFile({
+		prefix: "open-insight-dist-",
+		suffix: fileType
+	});
+	const bytes = yield* HttpClient.get(parsedUrl).pipe(Effect.flatMap(HttpClientResponse.filterStatusOk), Effect.flatMap((response) => response.arrayBuffer), Effect.map((buffer) => new Uint8Array(buffer)));
+	yield* fs.writeFile(archivePath, bytes);
+	if (fileType === ".tar.gz") return yield* extractTarGz(archivePath);
+	return yield* Effect.fail(/* @__PURE__ */ new Error(`Unsupported dist file type: ${String(fileType)}`));
+});
+const resolveDist = Effect.fn(function* (mode) {
+	return yield* resolveDistContext(mode).pipe(Effect.mapError(SandboxError.contextResolve(mode)));
+});
+//#endregion
+//#region src/sandbox/context/index.ts
+var context_exports = /* @__PURE__ */ __exportAll$1({
+	ContextSchema: () => ContextSchema,
+	Cwd: () => Cwd,
+	DistFileType: () => DistFileType,
+	ModeSchema: () => ModeSchema,
+	Script: () => Script,
+	make: () => make$2,
+	makeDir: () => makeDir,
+	makeDist: () => makeDist,
+	resolve: () => resolve
+});
+const resolve = Effect.fn(function* (mode) {
+	const path = yield* Path.Path;
+	return yield* ModeSchema.match(mode, {
+		Dir: ({ path }) => Effect.succeed(path),
+		Dist: resolveDist,
+		Script: () => Effect.succeed(import.meta.dirname),
+		Cwd: () => Effect.succeed(path.resolve("."))
+	});
+});
+const make$2 = (args) => ModeSchema.make(args);
+/**
+* Indicates that the context should be a specific directory.
+*/
+const makeDir = (path) => ModeSchema.make({
+	_tag: "Dir",
+	path
+});
+/**
+* Indicates that the context should be downloaded from a distribution archive.
+*/
+const makeDist = ({ url, fileType }) => ModeSchema.make({
+	_tag: "Dist",
+	url,
+	fileType
+});
+/**
+* Indicates that the context should be the script's directory.
+* This is useful for resolving relative paths in scripts.
+*/
+const Script = ModeSchema.make({ _tag: "Script" });
+/**
+* Indicates that the context should be the current working directory.
+*/
+const Cwd = ModeSchema.make({ _tag: "Cwd" });
+//#endregion
+//#region src/sandbox/snapshot/build.ts
+const fromContainerfile = Effect.fn(function* ({ context, filePath }) {
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const contextDir = yield* resolve(context);
+	const containerfilePath = path.join(contextDir, filePath);
+	return yield* decode(yield* fs.readFileString(containerfilePath));
+});
+//#endregion
+//#region src/sandbox/snapshot/index.ts
+var snapshot_exports = /* @__PURE__ */ __exportAll$1({
+	Containerfile: () => Containerfile,
+	Image: () => Image,
+	Inst: () => instruction_exports,
+	SNAPSHOT_NAME: () => SNAPSHOT_NAME,
+	Snapshot: () => Snapshot,
+	decode: () => decode,
+	derive: () => derive,
+	encode: () => encode,
+	extend: () => extend,
+	fromContainerfile: () => fromContainerfile,
+	fromImage: () => fromImage,
+	hash: () => hash,
+	make: () => make$3,
+	makeName: () => makeName$1
+});
+//#endregion
+//#region src/sandbox/error.ts
+var error_exports = /* @__PURE__ */ __exportAll$1({
+	ContextResolveError: () => ContextResolveError,
+	InstructionUnsupportedError: () => InstructionUnsupportedError,
+	ProviderError: () => ProviderError,
+	SandboxError: () => SandboxError,
+	SandboxErrorReason: () => SandboxErrorReason,
+	SandboxExecError: () => SandboxExecError,
+	SandboxExposeError: () => SandboxExposeError,
+	SnapshotError: () => SnapshotError,
+	SnapshotUnsupportedError: () => SnapshotUnsupportedError
+});
+var ContextResolveError = class extends Schema.TaggedErrorClass()("ContextResolveError", {
+	mode: ModeSchema,
+	cause: Schema.Defect()
+}) {};
+var SnapshotError = class extends Schema.TaggedErrorClass()("SnapshotError", {
+	kind: Schema.Union([Schema.Literal("build"), Schema.Literal("use")]),
+	snapshot: Snapshot,
+	cause: Schema.Defect(),
+	message: Schema.optional(Schema.String)
+}) {};
+var ProviderError = class extends Schema.TaggedErrorClass()("ProviderError", {
+	name: Schema.String,
+	cause: Schema.Defect()
+}) {};
+var SandboxExecError = class extends Schema.TaggedErrorClass()("SandboxExecError", {
+	name: Schema.String,
+	operation: Schema.String,
+	cause: Schema.Defect()
+}) {};
+var SandboxExposeError = class extends Schema.TaggedErrorClass()("SandboxExposeError", {
+	name: Schema.String,
+	sandboxPort: Schema.Number,
+	hostPort: Schema.Number,
+	cause: Schema.Defect()
+}) {};
+var SnapshotUnsupportedError = class extends Schema.TaggedErrorClass()("SnapshotUnsupportedError", {
+	name: Schema.String,
+	snapshot: Snapshot,
+	cause: Schema.Defect()
+}) {};
+var InstructionUnsupportedError = class extends Schema.TaggedErrorClass()("InstructionUnsupportedError", {
+	name: Schema.String,
+	snapshot: Snapshot,
+	instruction: Instruction
+}) {};
+const SandboxErrorReason = Schema.Union([
+	ContextResolveError,
+	ProviderError,
+	SnapshotError,
+	SandboxExecError,
+	SandboxExposeError,
+	SnapshotUnsupportedError,
+	InstructionUnsupportedError
+]);
+var SandboxError = class extends Schema.TaggedErrorClass()("SandboxError", { reason: SandboxErrorReason }) {
+	static contextResolve = (mode) => (cause) => this.make({ reason: ContextResolveError.make({
+		mode,
+		cause
+	}) });
+	static provider = (name) => (cause) => this.make({ reason: ProviderError.make({
+		name,
+		cause
+	}) });
+	static snapshotBuild = (snapshot) => (cause) => this.make({ reason: SnapshotError.make({
+		kind: "build",
+		snapshot,
+		cause
+	}) });
+	static snapshotUsage = (snapshot) => (cause) => this.make({ reason: SnapshotError.make({
+		kind: "use",
+		snapshot,
+		cause
+	}) });
+	static sandboxExec = ({ name, operation }) => (cause) => this.make({ reason: SandboxExecError.make({
+		name,
+		operation,
+		cause
+	}) });
+	static sandboxExpose = ({ name, sandboxPort, hostPort }) => (cause) => this.make({ reason: SandboxExposeError.make({
+		name,
+		sandboxPort,
+		hostPort,
+		cause
+	}) });
+	static snapshotUnsupported = (name, snapshot) => (cause) => this.make({ reason: SnapshotUnsupportedError.make({
+		name,
+		snapshot,
+		cause
+	}) });
+	static instructionUnsupported = (name, snapshot, instruction) => this.make({ reason: InstructionUnsupportedError.make({
+		name,
+		snapshot,
+		instruction
+	}) });
+};
+//#endregion
+//#region src/sandbox/provider/service.ts
+var ProviderService$1 = class extends Context.Service()("sandbox/ProviderService") {};
+//#endregion
+//#region src/sandbox/provider/utils.ts
+const bashQuote = (value) => `'${value.replaceAll("'", `'\\''`)}'`;
+const formatBash = (command) => [command.command, ...command.args].map(bashQuote).join(" ");
+//#endregion
+//#region src/sandbox/provider/index.ts
+var provider_exports = /* @__PURE__ */ __exportAll$1({
+	ProviderService: () => ProviderService$1,
+	bashQuote: () => bashQuote,
+	formatBash: () => formatBash
+});
+//#endregion
+//#region ../utils/dist/rolldown-runtime-D7D4PA-g.mjs
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+//#region ../utils/dist/index.mjs
+var spawn_exports = /* @__PURE__ */ __exportAll({
+	SpawnError: () => SpawnError,
+	SpawnExitCodeError: () => SpawnExitCodeError,
+	SpawnService: () => SpawnService
+});
+var SpawnExitCodeError = class extends Data.TaggedError("SpawnExitCodeError") {
+	get message() {
+		return `process exited with code ${this.exitCode}`;
+	}
+};
+var SpawnError = class SpawnError extends Data.TaggedError("SpawnError") {
+	get message() {
+		return this.reason.message;
+	}
+	static platform = (err) => new SpawnError({ reason: err });
+	static exit = ({ exitCode, stdout, stderr }) => new SpawnError({ reason: new SpawnExitCodeError({
+		exitCode,
+		stdout,
+		stderr
+	}) });
+};
+var SpawnService = class SpawnService extends Context.Service()("packages/utils/SpawnService") {
+	static layer = Layer.effect(SpawnService, Effect.gen(function* () {
+		const spawner = yield* ChildProcessSpawner;
+		const streamText = (stream) => Stream.mkString(Stream.decodeText(stream));
+		const spawn = Effect.fn(function* (command) {
+			const handle = yield* spawner.spawn(command).pipe(Effect.mapError(SpawnError.platform));
+			const exitCode = yield* handle.exitCode.pipe(Effect.mapError(SpawnError.platform));
+			if (exitCode !== 0) {
+				const output = yield* Effect.all({
+					stdout: streamText(handle.stdout),
+					stderr: streamText(handle.stderr)
+				}, { concurrency: "unbounded" }).pipe(Effect.mapError(SpawnError.platform));
+				return yield* SpawnError.exit({
+					exitCode,
+					...output
+				});
+			}
+			return handle;
+		});
+		const streamString = (command, options) => spawn(command).pipe(Effect.map((handle) => Stream.decodeText(options?.includeStderr === true ? handle.all : handle.stdout).pipe(Stream.mapError(SpawnError.platform))), Stream.unwrap);
+		const streamLines = (command, options) => Stream.splitLines(streamString(command, options));
+		const exitCode = (command) => spawn(command).pipe(Effect.scoped, Effect.flatMap((handle) => handle.exitCode.pipe(Effect.mapError(SpawnError.platform))));
+		const string = (command, options) => Stream.mkString(streamString(command, options));
+		const lines = (command, options) => Stream.runCollect(streamLines(command, options));
+		return {
+			spawn,
+			exitCode,
+			streamString,
+			streamLines,
+			lines,
+			string
+		};
+	}));
+};
+Effect.fn(function* (count) {
+	const countDown = yield* Ref.make(count);
+	const latch = yield* Latch.make();
+	return {
+		open: Effect.gen(function* () {
+			if ((yield* Ref.updateAndGet(countDown, (c) => c - 1)) <= 0) yield* latch.open;
+		}),
+		await: latch.await
+	};
+});
+//#endregion
+//#region src/sandbox/sandbox/promise.ts
+const asPromise = (_sandbox) => {
+	throw new Error("Not implemented yet");
+};
+//#endregion
+//#region src/sandbox/sandbox/index.ts
+const SANDBOX_NAME = "open-insight-sandbox";
+const makeName = Effect.fn(function* (snapshot) {
+	const crypto = yield* Crypto.Crypto;
+	return `${SANDBOX_NAME}-${yield* hash(snapshot)}-${yield* crypto.randomUUIDv4}`;
+});
+const make = Effect.fn(function* ({ $: sandbox$, expose, download, upload, readFile, writeFile }) {
+	const spawner = yield* spawn_exports.SpawnService;
+	const $ = Effect.fn(function* (command, input) {
+		return yield* Match.value(command).pipe(Match.tag("StandardCommand", (cmd) => sandbox$(cmd, input)), Match.tag("PipedCommand", (cmd) => Effect.gen(function* () {
+			const output = yield* $(cmd.left, input);
+			return yield* $(cmd.right, output);
+		})), Match.exhaustive);
+	});
+	return {
+		$,
+		readFile: readFile === "cat" ? Effect.fn(function* ({ sandboxPath }) {
+			return yield* $(ChildProcess.make`cat ${sandboxPath}`);
+		}) : readFile,
+		writeFile: writeFile === "tee" ? Effect.fn(function* ({ sandboxPath, content }) {
+			yield* $(ChildProcess.make`tee ${sandboxPath}`, content);
+		}) : writeFile,
+		download: download === "rsync" ? Effect.fn(function* ({ sandboxPath, hostPath }) {
+			const content = yield* $(ChildProcess.make`cat ${sandboxPath}`);
+			yield* spawner.string(ChildProcess.make("tee", [hostPath], { stdin: { stream: Stream.make(content).pipe(Stream.encodeText) } })).pipe(Effect.mapError((e) => SandboxError.sandboxExec({
+				name: "host",
+				operation: `download ${sandboxPath} -> ${hostPath}`
+			})(e)));
+		}) : download,
+		upload: upload === "rsync" ? Effect.fn(function* ({ sandboxPath, hostPath }) {
+			const content = yield* spawner.string(ChildProcess.make`cat ${hostPath}`).pipe(Effect.mapError((e) => SandboxError.sandboxExec({
+				name: "host",
+				operation: `upload ${hostPath} -> ${sandboxPath}`
+			})(e)));
+			yield* $(ChildProcess.make`tee ${sandboxPath}`, content);
+		}) : upload,
+		expose
+	};
+});
+//#endregion
+//#region src/sandbox/resource.ts
+const NonNegativeNumber = Schema.Number.check(Schema.isGreaterThanOrEqualTo(0));
+const NonNegativeInt = Schema.Int.check(Schema.isGreaterThanOrEqualTo(0));
+const ResourceLimitsSchema = Schema.Struct({
+	numCPUs: Schema.optionalKey(NonNegativeNumber).annotate({ description: "Maximum CPU cores available to the sandbox. Use fractional values such as 0.5 for half a core." }),
+	numGPUs: Schema.optionalKey(NonNegativeInt).annotate({ description: "Maximum GPU devices available to the sandbox." }),
+	memoryMiB: Schema.optionalKey(NonNegativeInt).annotate({ description: "Maximum memory available to the sandbox, in MiB." }),
+	diskMiB: Schema.optionalKey(NonNegativeInt).annotate({ description: "Maximum writable disk space available to the sandbox, in MiB." })
+}).annotate({ description: "Sandbox resource limit configuration." });
+//#endregion
+//#region src/sandbox/index.ts
+var sandbox_exports = /* @__PURE__ */ __exportAll$1({
+	Context: () => context_exports,
+	ContextResolveError: () => ContextResolveError,
+	Error: () => error_exports,
+	InstructionUnsupportedError: () => InstructionUnsupportedError,
+	ProviderError: () => ProviderError,
+	ProviderService: () => ProviderService$1,
+	ResourceLimitsSchema: () => ResourceLimitsSchema,
+	SANDBOX_NAME: () => SANDBOX_NAME,
+	SandboxError: () => SandboxError,
+	SandboxErrorReason: () => SandboxErrorReason,
+	SandboxExecError: () => SandboxExecError,
+	SandboxExposeError: () => SandboxExposeError,
+	Snapshot: () => snapshot_exports,
+	SnapshotError: () => SnapshotError,
+	SnapshotUnsupportedError: () => SnapshotUnsupportedError,
+	asPromise: () => asPromise,
+	bashQuote: () => bashQuote,
+	formatBash: () => formatBash,
+	make: () => make,
+	makeName: () => makeName
+});
+//#endregion
+//#region src/agent/error.ts
+var StreamError = class extends Schema.TaggedErrorClass()("StreamError", { cause: Schema.Defect() }) {};
+const AgentErrorReason = Schema.Union([StreamError]);
+var AgentError = class AgentError extends Schema.TaggedErrorClass()("AgentError", { reason: AgentErrorReason }) {
+	static stream = (error) => new AgentError({ reason: new StreamError({ cause: error }) });
+};
+//#endregion
+//#region src/agent/service.ts
+var ProviderService = class extends Context.Service()("agent/AgentService") {};
+//#endregion
+//#region src/agent/index.ts
+var agent_exports = /* @__PURE__ */ __exportAll$1({
+	AgentError: () => AgentError,
+	AgentErrorReason: () => AgentErrorReason,
+	AssistantMessage: () => AssistantMessage,
+	Message: () => Message,
+	ProviderService: () => ProviderService,
+	StreamError: () => StreamError,
+	SystemMessage: () => SystemMessage,
+	ToolMessage: () => ToolMessage,
+	Trajectory: () => Trajectory,
+	UserMessage: () => UserMessage
+});
+import * as import_effect_unstable_ai from "effect/unstable/ai";
+__reExport(agent_exports, import_effect_unstable_ai);
+//#endregion
+export { derive as A, Instructions as B, Script as C, resolve as D, makeDist as E, encode as F, Image as I, Snapshot as L, fromImage as M, hash as N, ContextSchema as O, makeName$1 as P, make$3 as R, Cwd as S, makeDir as T, instruction_exports as V, bashQuote as _, Trajectory as a, SandboxError as b, ProviderService as c, ResourceLimitsSchema as d, make as f, provider_exports as g, spawn_exports as h, ToolMessage as i, extend as j, ModeSchema as k, AgentError as l, asPromise as m, Message as n, UserMessage as o, makeName as p, SystemMessage as r, agent_exports as s, AssistantMessage as t, sandbox_exports as u, formatBash as v, make$2 as w, snapshot_exports as x, ProviderService$1 as y, Instruction as z };
+
+//# sourceMappingURL=agent-2V5_4nlu.mjs.map