@open-insight/core 0.0.0

package/dist/index.mjs

@@ -0,0 +1,585 @@
+import { t as __exportAll } from "./rolldown-runtime-BBjsoOtd.mjs";
+import { A as derive, B as Instructions, C as Script, D as resolve, E as makeDist, F as encode, I as Image, L as Snapshot, M as fromImage, N as hash, O as ContextSchema, P as makeName, R as make$5, S as Cwd, T as makeDir, V as instruction_exports, _ as bashQuote, a as Trajectory, b as SandboxError, c as ProviderService$1, d as ResourceLimitsSchema, f as make$3, g as provider_exports, h as spawn_exports, i as ToolMessage, j as extend, k as ModeSchema, l as AgentError, m as asPromise, n as Message, o as UserMessage, p as makeName$1, r as SystemMessage, t as AssistantMessage, v as formatBash, w as make$4, x as snapshot_exports, y as ProviderService, z as Instruction } from "./agent-2V5_4nlu.mjs";
+import { Context, Crypto, Effect, FileSystem, Option, Path, Ref, Schema, Stream } from "effect";
+import { HttpClient } from "effect/unstable/http";
+import { ChildProcessSpawner } from "effect/unstable/process/ChildProcessSpawner";
+import { ChildProcess } from "effect/unstable/process";
+import { Chat, LanguageModel, Response, Toolkit } from "effect/unstable/ai";
+//#region src/sandbox/provider/builtin/docker/utils.ts
+const makeRuntime = Effect.fn("sandbox/docker/makeRuntime")(function* () {
+	const runtimes = [
+		"docker",
+		"podman",
+		"nerdctl"
+	];
+	const spawner = yield* spawn_exports.SpawnService;
+	const found = (yield* Effect.all(runtimes.map((runtime) => spawner.string(ChildProcess.make`command -v ${runtime}`).pipe(Effect.map(Option.some), Effect.catchIf((error) => Boolean(error && typeof error === "object" && "reason" in error), () => Effect.succeed(Option.none())))), { concurrency: "unbounded" })).find((o) => Option.isSome(o));
+	if (found === void 0) return yield* Effect.fail(/* @__PURE__ */ new Error("No container runtime found."));
+	return ChildProcess.prefix(found.value.trim());
+});
+//#endregion
+//#region src/sandbox/provider/builtin/docker/index.ts
+const formatResources = (resources) => {
+	if (resources === null) return [];
+	const { numCPUs, memoryMiB, numGPUs, diskMiB } = resources;
+	const resourceArgs = [];
+	if (numCPUs !== void 0) resourceArgs.push("--cpus", `${numCPUs}`);
+	if (memoryMiB !== void 0) resourceArgs.push("--memory", `${memoryMiB}m`);
+	if (numGPUs !== void 0 && numGPUs > 0) resourceArgs.push("--gpus", `count=${numGPUs}`);
+	if (diskMiB !== void 0) resourceArgs.push("--storage-opt", `size=${diskMiB}m`);
+	return resourceArgs;
+};
+const make$2 = Effect.fn(function* ({ portMappings = [] }) {
+	const runtime = yield* makeRuntime().pipe(Effect.mapError(SandboxError.provider("docker")));
+	const crypto = yield* Crypto.Crypto;
+	const spawner = yield* spawn_exports.SpawnService;
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const httpClient = yield* HttpClient.HttpClient;
+	const childProcessSpawner = yield* ChildProcessSpawner;
+	const serviceContext = Context.mergeAll(Context.make(Crypto.Crypto, crypto), Context.make(FileSystem.FileSystem, fs), Context.make(Path.Path, path), Context.make(HttpClient.HttpClient, httpClient), Context.make(ChildProcessSpawner, childProcessSpawner));
+	const ensureSnapshot = Effect.fn(function* ({ snapshot, context }) {
+		const mapBuildError = Effect.mapError(SandboxError.snapshotBuild(snapshot));
+		const name = yield* makeName(snapshot).pipe(Effect.provideService(Crypto.Crypto, crypto), mapBuildError);
+		if (yield* spawner.string(ChildProcess.make`image inspect ${name}`.pipe(runtime)).pipe(Effect.as(true), Effect.catch(() => Effect.succeed(false)))) return;
+		const contextDir = yield* resolve(context).pipe(Effect.provideContext(serviceContext), mapBuildError);
+		const containerfilePath = yield* fs.makeTempFile({
+			prefix: "open-insight-",
+			suffix: ".Containerfile"
+		}).pipe(mapBuildError);
+		const command = ChildProcess.make`build -f ${containerfilePath} -t ${name} ${contextDir}`.pipe(runtime);
+		const containerfile = yield* encode(snapshot).pipe(mapBuildError);
+		yield* fs.writeFileString(containerfilePath, containerfile).pipe(mapBuildError);
+		yield* spawner.string(command).pipe(mapBuildError);
+	});
+	const removeSnapshot = Effect.fn(function* ({ snapshot }) {
+		const mapBuildError = Effect.mapError(SandboxError.snapshotBuild(snapshot));
+		const name = yield* makeName(snapshot).pipe(Effect.provideService(Crypto.Crypto, crypto), mapBuildError);
+		const command = ChildProcess.make`rmi ${name}`.pipe(runtime);
+		yield* spawner.string(command).pipe(mapBuildError);
+	});
+	return {
+		ensureSnapshot,
+		deriveSnapshot: Effect.fn(function* ({ snapshot, context, instructions }) {
+			yield* ensureSnapshot({
+				snapshot,
+				context
+			});
+			const name = yield* makeName(snapshot).pipe(Effect.provideService(Crypto.Crypto, crypto), Effect.mapError(SandboxError.snapshotBuild(snapshot)));
+			yield* ensureSnapshot({
+				snapshot: Snapshot.make({
+					image: name,
+					instructions
+				}),
+				context
+			});
+		}),
+		removeSnapshot,
+		runSandbox: Effect.fn(function* ({ snapshot, resources }) {
+			const mapUsageError = Effect.mapError(SandboxError.snapshotUsage(snapshot));
+			const name = yield* makeName(snapshot).pipe(Effect.provideService(Crypto.Crypto, crypto), mapUsageError);
+			const sandboxName = yield* makeName$1(snapshot).pipe(Effect.provideService(Crypto.Crypto, crypto), mapUsageError);
+			const portMappingArgs = portMappings.flatMap((mapping) => ["-p", `${mapping.hostPort}:${mapping.sandboxPort}`]);
+			const run = ChildProcess.make("run", [
+				"-it",
+				"--rm",
+				"--detach",
+				"--name",
+				sandboxName,
+				...portMappingArgs,
+				...formatResources(resources),
+				name,
+				"sleep",
+				"infinity"
+			]).pipe(runtime);
+			yield* spawner.string(run).pipe(Effect.mapError(SandboxError.provider("docker")));
+			yield* Effect.addFinalizer(() => spawner.string(ChildProcess.make`rm --force ${sandboxName}`.pipe(runtime)).pipe(Effect.ignore));
+			const makeExecCommand = (command, input) => {
+				const args = [];
+				if (input !== void 0) args.push("-i");
+				for (const [key, value] of Object.entries(command.options.env ?? {})) if (value !== void 0) args.push("-e", `${key}=${value}`);
+				if (command.options.cwd !== void 0) args.push("-w", command.options.cwd);
+				args.push(sandboxName, "sh", "-c", formatBash(command));
+				const options = input === void 0 ? {} : { stdin: { stream: Stream.make(input).pipe(Stream.encodeText) } };
+				return ChildProcess.make("exec", args, options).pipe(runtime);
+			};
+			return yield* make$3({
+				$(cmd, input) {
+					const bash = formatBash(cmd);
+					const execCommand = makeExecCommand(cmd, input);
+					return spawner.string(execCommand).pipe(Effect.mapError(SandboxError.sandboxExec({
+						name,
+						operation: bash
+					})));
+				},
+				expose: Effect.fn(function* ({ sandboxPort, hostPort }) {
+					if (!portMappings.some((mapping) => mapping.sandboxPort === sandboxPort && mapping.hostPort === hostPort)) return yield* Effect.fail(SandboxError.sandboxExpose({
+						name,
+						sandboxPort,
+						hostPort
+					})("Expected port mapping cannot be exposed because it was not specified in the configuration. Containers cannot exposing arbitrary ports that were not mapped when the container was created."));
+					return { hostUrl: `http://localhost:${hostPort}` };
+				}),
+				download: Effect.fn(function* ({ sandboxPath, hostPath }) {
+					const from = `${sandboxName}:${sandboxPath}`;
+					const command = ChildProcess.make`cp ${from} ${hostPath}`;
+					yield* spawner.string(command.pipe(runtime)).pipe(Effect.mapError(SandboxError.sandboxExec({
+						name,
+						operation: formatBash(command)
+					})));
+				}),
+				upload: Effect.fn(function* ({ sandboxPath, hostPath }) {
+					const to = `${sandboxName}:${sandboxPath}`;
+					const command = ChildProcess.make`cp ${hostPath} ${to}`;
+					yield* spawner.string(command.pipe(runtime)).pipe(Effect.mapError(SandboxError.sandboxExec({
+						name,
+						operation: formatBash(command)
+					})));
+				}),
+				readFile: "cat",
+				writeFile: "tee"
+			}).pipe(Effect.provideService(spawn_exports.SpawnService, spawner));
+		})
+	};
+}, (effect) => effect.pipe(Effect.provide(spawn_exports.SpawnService.layer)));
+//#endregion
+//#region src/sandbox/provider/builtin/docker/export.ts
+var export_exports$6 = /* @__PURE__ */ __exportAll({ make: () => make$2 });
+//#endregion
+//#region src/sandbox/context/export.ts
+var export_exports$5 = /* @__PURE__ */ __exportAll({
+	ContextSchema: () => ContextSchema,
+	Cwd: () => Cwd,
+	ModeSchema: () => ModeSchema,
+	Script: () => Script,
+	make: () => make$4,
+	makeDir: () => makeDir,
+	makeDist: () => makeDist
+});
+//#endregion
+//#region src/sandbox/snapshot/export.ts
+var export_exports$4 = /* @__PURE__ */ __exportAll({
+	Image: () => Image,
+	Inst: () => instruction_exports,
+	Instruction: () => Instruction,
+	Instructions: () => Instructions,
+	Internal: () => snapshot_exports,
+	Snapshot: () => Snapshot,
+	derive: () => derive,
+	extend: () => extend,
+	fromImage: () => fromImage,
+	hash: () => hash,
+	make: () => make$5,
+	snapshotName: () => makeName
+});
+//#endregion
+//#region src/sandbox/export.ts
+var export_exports$1 = /* @__PURE__ */ __exportAll({
+	Context: () => export_exports$5,
+	Docker: () => export_exports$6,
+	Internal: () => provider_exports,
+	ProviderService: () => ProviderService,
+	ResourceLimitsSchema: () => ResourceLimitsSchema,
+	SandboxError: () => SandboxError,
+	Snapshot: () => export_exports$4,
+	asPromise: () => asPromise,
+	bashQuote: () => bashQuote,
+	formatBash: () => formatBash,
+	make: () => make$3
+});
+//#endregion
+//#region src/agent/builtin/effect/index.ts
+const makeAgent$1 = Effect.fn(function* ({ sandbox: _sandbox, chat = Chat.empty, toolkit = Toolkit.empty }) {
+	const llm = yield* LanguageModel.LanguageModel;
+	const service = yield* chat;
+	return {
+		trajectory: () => Ref.get(service.history),
+		prompt: ({ prompt }) => Effect.succeed(service.streamText({
+			prompt,
+			toolkit
+		}).pipe(Stream.mapError(AgentError.stream), Stream.provideService(LanguageModel.LanguageModel, llm)))
+	};
+});
+const make$1 = Effect.fn(function* ({ chat = Chat.empty, toolkit = Toolkit.empty }) {
+	const llm = yield* LanguageModel.LanguageModel;
+	return {
+		runSession: Effect.fn(function* ({ sandbox }) {
+			return yield* makeAgent$1({
+				sandbox,
+				chat,
+				toolkit
+			});
+		}, (effect) => effect.pipe(Effect.provideService(LanguageModel.LanguageModel, llm))),
+		deriveSnapshot: Effect.fn(function* ({ snapshot }) {
+			return yield* Effect.succeed(snapshot);
+		})
+	};
+});
+//#endregion
+//#region src/agent/builtin/effect/export.ts
+var export_exports$3 = /* @__PURE__ */ __exportAll({ make: () => make$1 });
+//#endregion
+//#region src/agent/builtin/dummy/index.ts
+var dummy_exports = /* @__PURE__ */ __exportAll({
+	make: () => make,
+	makeAgent: () => makeAgent
+});
+const randomText = Effect.fn(function* () {
+	return yield* Effect.sync(() => crypto.randomUUID().replaceAll("-", ""));
+});
+const finishPart = {
+	type: "finish",
+	reason: "stop",
+	usage: {
+		inputTokens: {
+			uncached: 0,
+			total: 0,
+			cacheRead: void 0,
+			cacheWrite: void 0
+		},
+		outputTokens: {
+			total: 0,
+			text: void 0,
+			reasoning: void 0
+		}
+	},
+	response: void 0
+};
+const makeDummyLanguageModel = Effect.fn(function* () {
+	return yield* LanguageModel.make({
+		generateText: () => randomText().pipe(Effect.map((text) => [{
+			type: "text",
+			text
+		}, finishPart])),
+		streamText: () => Stream.unwrap(randomText().pipe(Effect.map((text) => Stream.fromIterable([
+			{
+				type: "text-start",
+				id: "dummy"
+			},
+			{
+				type: "text-delta",
+				id: "dummy",
+				delta: text
+			},
+			{
+				type: "text-end",
+				id: "dummy"
+			},
+			finishPart
+		]))))
+	});
+});
+const makeAgent = Effect.fn(function* ({ chat = Chat.empty, toolkit = Toolkit.empty }) {
+	const llm = yield* makeDummyLanguageModel();
+	const service = yield* chat;
+	return {
+		trajectory: () => Ref.get(service.history),
+		prompt: ({ prompt }) => Effect.succeed(service.streamText({
+			prompt,
+			toolkit
+		}).pipe(Stream.mapError(AgentError.stream), Stream.provideService(LanguageModel.LanguageModel, llm)))
+	};
+});
+const make = Effect.fn(function* ({ chat = Chat.empty, toolkit = Toolkit.empty }) {
+	const llm = yield* makeDummyLanguageModel();
+	return {
+		runSession: Effect.fn(function* ({ sandbox: _sandbox }) {
+			return yield* makeAgent({
+				chat,
+				toolkit
+			});
+		}, (effect) => effect.pipe(Effect.provideService(LanguageModel.LanguageModel, llm))),
+		deriveSnapshot: Effect.fn(function* ({ snapshot }) {
+			return yield* Effect.succeed(snapshot);
+		})
+	};
+});
+//#endregion
+//#region src/agent/builtin/ai-sdk/stream.ts
+var AiSdkStreamError = class extends Schema.TaggedErrorClass()("AiSdkStreamError", { cause: Schema.Defect() }) {};
+const decodeJsonOption = Schema.decodeUnknownOption(Schema.Json);
+const decodeDocumentSourcePart = Schema.decodeUnknownOption(Response.DocumentSourcePart);
+const decodeUrlSourcePart = Schema.decodeUnknownOption(Response.UrlSourcePart);
+const jsonOrOmitted = (value) => Option.getOrElse(decodeJsonOption(value), () => ({
+	omitted: true,
+	reason: "non_json_value"
+}));
+const metadataPart = (part, details = {}) => Response.makePart("response-metadata", {
+	id: void 0,
+	modelId: void 0,
+	timestamp: void 0,
+	request: void 0,
+	metadata: aiSdkMetadata(part, details)
+});
+const aiSdkMetadata = (part, details = {}) => {
+	const partDetails = {
+		...details,
+		type: part.type
+	};
+	const metadata = part.providerMetadata;
+	return { aiSdk: metadata === void 0 ? { part: partDetails } : {
+		part: partDetails,
+		providerMetadata: jsonOrOmitted(metadata)
+	} };
+};
+const usageFromAiSdk = (usage) => new Response.Usage({
+	inputTokens: {
+		uncached: usage.inputTokenDetails.noCacheTokens,
+		total: usage.inputTokens,
+		cacheRead: usage.inputTokenDetails.cacheReadTokens,
+		cacheWrite: usage.inputTokenDetails.cacheWriteTokens
+	},
+	outputTokens: {
+		total: usage.outputTokens,
+		text: usage.outputTokenDetails.textTokens,
+		reasoning: usage.outputTokenDetails.reasoningTokens
+	}
+});
+const emptyUsage = () => new Response.Usage({
+	inputTokens: {
+		uncached: void 0,
+		total: void 0,
+		cacheRead: void 0,
+		cacheWrite: void 0
+	},
+	outputTokens: {
+		total: void 0,
+		text: void 0,
+		reasoning: void 0
+	}
+});
+const finishReason = (reason) => reason;
+const filePart = (part) => {
+	const file = fileFromPart(part.file);
+	return file === void 0 ? [metadataPart(part, { reason: "file_data_unavailable" })] : [Response.makePart("file", {
+		mediaType: file.mediaType,
+		data: file.data,
+		metadata: aiSdkMetadata(part, part.type === "reasoning-file" ? { content: "reasoning" } : {})
+	})];
+};
+const fileFromPart = (file) => {
+	try {
+		return {
+			mediaType: file.mediaType,
+			data: file.uint8Array
+		};
+	} catch {
+		return;
+	}
+};
+const sourcePart = (part) => {
+	switch (part.sourceType) {
+		case "url": return urlSourcePart(part);
+		case "document": return documentSourcePart(part);
+	}
+};
+const urlSourcePart = (part) => {
+	const source = decodeUrlSourcePart({
+		type: "source",
+		sourceType: "url",
+		id: part.id,
+		url: part.url,
+		title: part.title ?? part.url,
+		metadata: aiSdkMetadata(part)
+	});
+	return Option.match(source, {
+		onNone: () => [metadataPart(part, { reason: "invalid_source_url" })],
+		onSome: (sourcePart) => [sourcePart]
+	});
+};
+const documentSourcePart = (part) => {
+	const source = decodeDocumentSourcePart({
+		type: "source",
+		sourceType: "document",
+		id: part.id,
+		mediaType: part.mediaType,
+		title: part.title,
+		fileName: part.filename,
+		metadata: aiSdkMetadata(part)
+	});
+	return Option.match(source, {
+		onNone: () => [metadataPart(part, { reason: "invalid_document_source" })],
+		onSome: (sourcePart) => [sourcePart]
+	});
+};
+const toolCallDetails = (part) => ({
+	dynamic: part.dynamic ?? false,
+	title: part.title ?? null,
+	toolMetadata: jsonOrOmitted(part.toolMetadata)
+});
+const partToParts = (part) => {
+	switch (part.type) {
+		case "text-start": return [Response.makePart("text-start", {
+			id: part.id,
+			metadata: aiSdkMetadata(part)
+		})];
+		case "text-delta": return [Response.makePart("text-delta", {
+			id: part.id,
+			delta: part.text,
+			metadata: aiSdkMetadata(part)
+		})];
+		case "text-end": return [Response.makePart("text-end", {
+			id: part.id,
+			metadata: aiSdkMetadata(part)
+		})];
+		case "reasoning-start": return [Response.makePart("reasoning-start", {
+			id: part.id,
+			metadata: aiSdkMetadata(part)
+		})];
+		case "reasoning-delta": return [Response.makePart("reasoning-delta", {
+			id: part.id,
+			delta: part.text,
+			metadata: aiSdkMetadata(part)
+		})];
+		case "reasoning-end": return [Response.makePart("reasoning-end", {
+			id: part.id,
+			metadata: aiSdkMetadata(part)
+		})];
+		case "tool-input-start": return [Response.makePart("tool-params-start", {
+			id: part.id,
+			name: part.toolName,
+			providerExecuted: part.providerExecuted ?? false,
+			metadata: aiSdkMetadata(part, {
+				dynamic: part.dynamic ?? false,
+				title: part.title ?? null,
+				toolMetadata: jsonOrOmitted(part.toolMetadata)
+			})
+		})];
+		case "tool-input-delta": return [Response.makePart("tool-params-delta", {
+			id: part.id,
+			delta: part.delta,
+			metadata: aiSdkMetadata(part)
+		})];
+		case "tool-input-end": return [Response.makePart("tool-params-end", {
+			id: part.id,
+			metadata: aiSdkMetadata(part)
+		})];
+		case "tool-call": return [Response.toolCallPart({
+			id: part.toolCallId,
+			name: part.toolName,
+			params: part.input,
+			providerExecuted: part.providerExecuted ?? false,
+			metadata: aiSdkMetadata(part, toolCallDetails(part))
+		})];
+		case "tool-result": return [Response.toolResultPart({
+			id: part.toolCallId,
+			name: part.toolName,
+			isFailure: false,
+			result: part.output,
+			encodedResult: part.output,
+			providerExecuted: part.providerExecuted ?? false,
+			preliminary: part.preliminary ?? false,
+			metadata: aiSdkMetadata(part, toolCallDetails(part))
+		})];
+		case "tool-error": {
+			const result = {
+				error: part.error,
+				input: part.input
+			};
+			return [Response.toolResultPart({
+				id: part.toolCallId,
+				name: part.toolName,
+				isFailure: true,
+				result,
+				encodedResult: result,
+				providerExecuted: part.providerExecuted ?? false,
+				preliminary: false,
+				metadata: aiSdkMetadata(part, toolCallDetails(part))
+			})];
+		}
+		case "tool-output-denied": {
+			const result = { denied: true };
+			return [Response.toolResultPart({
+				id: part.toolCallId,
+				name: part.toolName,
+				isFailure: true,
+				result,
+				encodedResult: result,
+				providerExecuted: part.providerExecuted ?? false,
+				preliminary: false,
+				metadata: aiSdkMetadata(part, { dynamic: part.dynamic ?? false })
+			})];
+		}
+		case "tool-approval-request": return [Response.toolApprovalRequestPart({
+			approvalId: part.approvalId,
+			toolCallId: part.toolCall.toolCallId,
+			metadata: aiSdkMetadata(part, {
+				isAutomatic: part.isAutomatic ?? false,
+				signature: part.signature ?? null,
+				toolCall: jsonOrOmitted(part.toolCall)
+			})
+		})];
+		case "tool-approval-response": return [metadataPart(part, {
+			approvalId: part.approvalId,
+			approved: part.approved,
+			providerExecuted: part.providerExecuted ?? false,
+			reason: part.reason ?? null,
+			toolCall: jsonOrOmitted(part.toolCall)
+		})];
+		case "file":
+		case "reasoning-file": return filePart(part);
+		case "source": return sourcePart(part);
+		case "finish": return [Response.makePart("finish", {
+			reason: finishReason(part.finishReason),
+			usage: usageFromAiSdk(part.totalUsage),
+			response: void 0,
+			metadata: aiSdkMetadata(part, { rawFinishReason: part.rawFinishReason ?? null })
+		})];
+		case "abort": return [Response.makePart("finish", {
+			reason: "unknown",
+			usage: emptyUsage(),
+			response: void 0,
+			metadata: aiSdkMetadata(part, { reason: part.reason ?? null })
+		})];
+		case "error": return [Response.makePart("error", {
+			error: part.error,
+			metadata: aiSdkMetadata(part)
+		})];
+		case "start": return [metadataPart(part)];
+		case "start-step": return [metadataPart(part, {
+			request: jsonOrOmitted(part.request),
+			warnings: jsonOrOmitted(part.warnings)
+		})];
+		case "finish-step": return [metadataPart(part, {
+			finishReason: part.finishReason,
+			performance: jsonOrOmitted(part.performance),
+			rawFinishReason: part.rawFinishReason ?? null,
+			response: jsonOrOmitted(part.response),
+			usage: jsonOrOmitted(part.usage)
+		})];
+		case "custom": return [metadataPart(part, { kind: part.kind })];
+		case "raw": return [metadataPart(part, { rawValue: jsonOrOmitted(part.rawValue) })];
+	}
+};
+const transform = Effect.fn(function* (stream) {
+	return yield* Effect.succeed(stream.pipe(Stream.flatMap((part) => Stream.fromIterable(partToParts(part)))));
+}, Stream.unwrap);
+const fromAiStream = Effect.fn(function* (stream) {
+	return yield* Effect.succeed(Stream.fromAsyncIterable(stream, (cause) => AiSdkStreamError.make({ cause })).pipe(transform));
+}, Stream.unwrap);
+//#endregion
+//#region src/agent/builtin/ai-sdk/export.ts
+var export_exports$2 = /* @__PURE__ */ __exportAll({
+	AiSdkStreamError: () => AiSdkStreamError,
+	fromAiStream: () => fromAiStream,
+	transform: () => transform
+});
+//#endregion
+//#region src/agent/export.ts
+var export_exports = /* @__PURE__ */ __exportAll({
+	AgentError: () => AgentError,
+	Ai: () => export_exports$2,
+	AssistantMessage: () => AssistantMessage,
+	Dummy: () => dummy_exports,
+	Effect: () => export_exports$3,
+	Message: () => Message,
+	ProviderService: () => ProviderService$1,
+	SystemMessage: () => SystemMessage,
+	ToolMessage: () => ToolMessage,
+	Trajectory: () => Trajectory,
+	UserMessage: () => UserMessage
+});
+//#endregion
+export { export_exports as Agent, export_exports$1 as Sandbox };
+
+//# sourceMappingURL=index.mjs.map