@better-agent/plugins 0.1.0-beta.1 → 0.1.0-beta.3

package/dist/index.mjs

@@ -1,4 +1,5 @@
 import { BetterAgentError } from "@better-agent/shared/errors";
+import { defineTool } from "@better-agent/core";
 
 //#region src/shared/json.ts
 /** Creates a JSON response with a default content type. */
@@ -24,26 +25,26 @@ function createUnauthorizedResponse() {
 //#endregion
 //#region src/shared/validation.ts
 /** Creates a plugin validation error. */
-function createValidationError(message, at) {
+function createValidationError$1(message, at) {
 	return BetterAgentError.fromCode("VALIDATION_FAILED", message, { trace: [{ at }] });
 }
 /** Requires a positive finite number. */
 function requirePositiveNumber(value, name, at) {
-	if (!Number.isFinite(value) || value <= 0) throw createValidationError(`\`${name}\` must be a positive number.`, at);
+	if (!Number.isFinite(value) || value <= 0) throw createValidationError$1(`\`${name}\` must be a positive number.`, at);
 }
 /** Requires a non-empty array. */
 function requireNonEmptyArray(value, name, at) {
-	if (!value || value.length === 0) throw createValidationError(`\`${name}\` must contain at least one value.`, at);
+	if (!value || value.length === 0) throw createValidationError$1(`\`${name}\` must contain at least one value.`, at);
 }
 
 //#endregion
 //#region src/auth/validate.ts
 /** Validates `authPlugin` configuration. */
 function validateAuthPluginConfig(config) {
-	if (!config.validate && (!config.apiKeys || config.apiKeys.length === 0)) throw createValidationError("`authPlugin` requires either `apiKeys` or `validate`.", "plugins.authPlugin");
-	if (config.header !== void 0 && config.header.trim().length === 0) throw createValidationError("`authPlugin` requires `header` to be a non-empty string when provided.", "plugins.authPlugin");
+	if (!config.validate && (!config.apiKeys || config.apiKeys.length === 0)) throw createValidationError$1("`authPlugin` requires either `apiKeys` or `validate`.", "plugins.authPlugin");
+	if (config.header !== void 0 && config.header.trim().length === 0) throw createValidationError$1("`authPlugin` requires `header` to be a non-empty string when provided.", "plugins.authPlugin");
 	if (config.apiKeys) {
-		if (config.apiKeys.filter((key) => typeof key === "string").map((key) => key.trim()).filter((key) => key.length > 0).length === 0 && !config.validate) throw createValidationError("`authPlugin` requires `apiKeys` to contain at least one non-empty key.", "plugins.authPlugin");
+		if (config.apiKeys.filter((key) => typeof key === "string").map((key) => key.trim()).filter((key) => key.length > 0).length === 0 && !config.validate) throw createValidationError$1("`authPlugin` requires `apiKeys` to contain at least one non-empty key.", "plugins.authPlugin");
 	}
 }
 
@@ -224,7 +225,7 @@ function createIpDeniedResponse() {
 /** Validates `ipAllowlistPlugin` configuration. */
 function validateIpAllowlistPluginConfig(config) {
 	requireNonEmptyArray(config.allow, "allow", "plugins.ipAllowlistPlugin");
-	for (const entry of config.allow) if (typeof entry !== "string" || !parseAllowEntry(entry)) throw createValidationError(`\`ipAllowlistPlugin\` received an invalid allow entry: '${String(entry)}'.`, "plugins.ipAllowlistPlugin");
+	for (const entry of config.allow) if (typeof entry !== "string" || !parseAllowEntry(entry)) throw createValidationError$1(`\`ipAllowlistPlugin\` received an invalid allow entry: '${String(entry)}'.`, "plugins.ipAllowlistPlugin");
 }
 
 //#endregion
@@ -702,5 +703,701 @@ const rateLimitPlugin = (config) => {
 };
 
 //#endregion
-export { authPlugin, ipAllowlistPlugin, loggingPlugin, rateLimitPlugin };
+//#region src/sandbox/daytona.ts
+const loadDaytona = async () => {
+	try {
+		return await import("@daytonaio/sdk");
+	} catch (error) {
+		throw BetterAgentError.fromCode("INTERNAL", "The Daytona sandbox client requires the `@daytonaio/sdk` package to be installed in the host app.", {
+			cause: error,
+			trace: [{ at: "plugins.sandbox.createDaytonaSandboxClient.loadDaytona" }]
+		});
+	}
+};
+const removeUndefined$1 = (value) => Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== void 0));
+const toSeconds = (value) => value === void 0 ? void 0 : Math.max(1, Math.ceil(value / 1e3));
+const toUtf8 = (value) => typeof value === "string" ? value : new TextDecoder().decode(value);
+const normalizeFileEntries = (files) => files.map((entry) => ({
+	name: entry.name ?? entry.path?.split("/").filter(Boolean).at(-1) ?? "",
+	path: entry.path ?? entry.name ?? "",
+	type: entry.type ?? (entry.isDir ? "directory" : "file")
+}));
+/** Creates a sandbox client backed by the Daytona SDK. */
+function createDaytonaSandboxClient(config = {}) {
+	const clientConfig = removeUndefined$1({
+		apiKey: config.apiKey,
+		apiUrl: config.apiUrl,
+		target: config.target
+	});
+	const buildCreateParams = (overrides) => {
+		const template = overrides?.template ?? config.template;
+		const templateKind = config.templateKind ?? "snapshot";
+		return removeUndefined$1({
+			language: config.language,
+			envVars: overrides?.envs ?? config.envs,
+			labels: overrides?.metadata ?? config.metadata,
+			public: config.public,
+			autoStopInterval: config.autoStopInterval,
+			autoArchiveInterval: config.autoArchiveInterval,
+			autoDeleteInterval: config.autoDeleteInterval,
+			...template !== void 0 ? templateKind === "image" ? { image: template } : { snapshot: template } : {},
+			...config.snapshot !== void 0 ? { snapshot: config.snapshot } : {},
+			...config.image !== void 0 ? { image: config.image } : {}
+		});
+	};
+	const getClient = async () => {
+		const { Daytona } = await loadDaytona();
+		return new Daytona(clientConfig);
+	};
+	const getSandbox = async (sandboxId) => {
+		const client = await getClient();
+		return {
+			sandbox: await client.get(sandboxId),
+			client
+		};
+	};
+	const toCommandResult = (response) => ({
+		exitCode: response.exitCode,
+		stdout: response.result
+	});
+	return {
+		provider: "daytona",
+		capabilities: {
+			commands: true,
+			filesystem: true,
+			preview: true,
+			pty: true,
+			desktop: true,
+			git: true,
+			snapshots: true,
+			volumes: true,
+			lifecycle: {
+				start: true,
+				stop: true,
+				archive: true,
+				resume: true
+			}
+		},
+		async createSandbox(params) {
+			const client = await getClient();
+			const timeout = toSeconds(params?.timeoutMs ?? config.timeoutMs);
+			return { sandboxId: (await client.create(buildCreateParams(params), { ...timeout !== void 0 ? { timeout } : {} })).id };
+		},
+		async runCommand(params) {
+			const { sandbox } = await getSandbox(params.sandboxId);
+			return toCommandResult(await sandbox.process.executeCommand(params.cmd, params.cwd, params.envs, toSeconds(params.timeoutMs)));
+		},
+		async readFile(params) {
+			const { sandbox } = await getSandbox(params.sandboxId);
+			return toUtf8(await sandbox.fs.downloadFile(params.path));
+		},
+		async writeFile(params) {
+			const { sandbox } = await getSandbox(params.sandboxId);
+			await sandbox.fs.uploadFile(Buffer.from(params.content), params.path);
+			return { path: params.path };
+		},
+		async listFiles(params) {
+			const { sandbox } = await getSandbox(params.sandboxId);
+			return normalizeFileEntries(await sandbox.fs.listFiles(params.path));
+		},
+		async makeDir(params) {
+			const { sandbox } = await getSandbox(params.sandboxId);
+			await sandbox.fs.createFolder(params.path, "755");
+			return { created: true };
+		},
+		async removePath(params) {
+			const { sandbox } = await getSandbox(params.sandboxId);
+			await sandbox.fs.deleteFile(params.path, true);
+		},
+		async getHost(params) {
+			const { sandbox } = await getSandbox(params.sandboxId);
+			return await sandbox.getPreviewLink(params.port);
+		},
+		async killSandbox(params) {
+			const { client, sandbox } = await getSandbox(params.sandboxId);
+			if (typeof sandbox.delete === "function") {
+				await sandbox.delete(60);
+				return;
+			}
+			if (typeof client.delete === "function") {
+				await client.delete(sandbox, 60);
+				return;
+			}
+			throw BetterAgentError.fromCode("NOT_IMPLEMENTED", "The active Daytona SDK instance does not expose sandbox deletion.", {
+				context: { sandboxId: params.sandboxId },
+				trace: [{ at: "plugins.sandbox.createDaytonaSandboxClient.killSandbox" }]
+			});
+		},
+		lifecycle: {
+			async startSandbox(params) {
+				const { client, sandbox } = await getSandbox(params.sandboxId);
+				const timeout = toSeconds(params.timeoutMs);
+				if (typeof sandbox.start === "function") {
+					await sandbox.start(timeout);
+					return;
+				}
+				if (typeof client.start === "function") await client.start(sandbox, timeout);
+			},
+			async stopSandbox(params) {
+				const { client, sandbox } = await getSandbox(params.sandboxId);
+				if (typeof sandbox.stop === "function") {
+					await sandbox.stop(toSeconds(params.timeoutMs));
+					return;
+				}
+				if (typeof client.stop === "function") await client.stop(sandbox);
+			},
+			async archiveSandbox(params) {
+				const { sandbox } = await getSandbox(params.sandboxId);
+				if (typeof sandbox.archive === "function") {
+					await sandbox.archive();
+					return;
+				}
+				throw BetterAgentError.fromCode("NOT_IMPLEMENTED", "The active Daytona SDK instance does not expose sandbox archiving.", {
+					context: { sandboxId: params.sandboxId },
+					trace: [{ at: "plugins.sandbox.createDaytonaSandboxClient.archiveSandbox" }]
+				});
+			}
+		}
+	};
+}
+
+//#endregion
+//#region src/sandbox/e2b.ts
+const removeUndefined = (value) => Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== void 0));
+const loadE2B = async () => {
+	try {
+		return await import("e2b");
+	} catch (error) {
+		throw BetterAgentError.fromCode("INTERNAL", "The built-in E2B sandbox client requires the `e2b` package to be installed in the host app.", {
+			cause: error,
+			trace: [{ at: "plugins.sandbox.createE2BSandboxClient.loadE2B" }]
+		});
+	}
+};
+/** Creates a sandbox client backed by the E2B SDK. */
+function createE2BSandboxClient(config = {}) {
+	const connectionOptions = removeUndefined({
+		apiKey: config.apiKey,
+		accessToken: config.accessToken,
+		domain: config.domain,
+		requestTimeoutMs: config.requestTimeoutMs
+	});
+	const toCreateOptions = (overrides) => removeUndefined({
+		...connectionOptions,
+		timeoutMs: overrides?.timeoutMs ?? config.timeoutMs,
+		envs: overrides?.envs ?? config.envs,
+		metadata: overrides?.metadata ?? config.metadata
+	});
+	const connectSandbox = async (sandboxId) => {
+		const { Sandbox } = await loadE2B();
+		return await Sandbox.connect(sandboxId, connectionOptions);
+	};
+	const mapCommandResult = (result) => ({
+		exitCode: result.exitCode,
+		stdout: result.stdout,
+		stderr: result.stderr,
+		pid: result.pid
+	});
+	return {
+		provider: "e2b",
+		capabilities: {
+			commands: true,
+			filesystem: true,
+			preview: true,
+			mcp: true,
+			pty: true,
+			desktop: true
+		},
+		async createSandbox(params) {
+			const { Sandbox } = await loadE2B();
+			const template = params?.template ?? config.template;
+			const options = toCreateOptions(params);
+			return { sandboxId: (template !== void 0 ? await Sandbox.create(template, options) : await Sandbox.create(options)).sandboxId };
+		},
+		async runCommand(params) {
+			return mapCommandResult(await (await connectSandbox(params.sandboxId)).commands.run(params.cmd, removeUndefined({
+				cwd: params.cwd,
+				envs: params.envs,
+				timeoutMs: params.timeoutMs
+			})));
+		},
+		async readFile(params) {
+			return await (await connectSandbox(params.sandboxId)).files.read(params.path);
+		},
+		async writeFile(params) {
+			return { path: (await (await connectSandbox(params.sandboxId)).files.write(params.path, params.content)).path ?? params.path };
+		},
+		async listFiles(params) {
+			return await (await connectSandbox(params.sandboxId)).files.list(params.path);
+		},
+		async makeDir(params) {
+			return { created: await (await connectSandbox(params.sandboxId)).files.makeDir(params.path) };
+		},
+		async removePath(params) {
+			await (await connectSandbox(params.sandboxId)).files.remove(params.path);
+		},
+		async getHost(params) {
+			return (await connectSandbox(params.sandboxId)).getHost(params.port);
+		},
+		async killSandbox(params) {
+			await (await connectSandbox(params.sandboxId)).kill();
+		}
+	};
+}
+
+//#endregion
+//#region src/sandbox/memory-store.ts
+/** Creates an in-memory sandbox session store. */
+function createMemorySandboxSessionStore() {
+	const sessions = /* @__PURE__ */ new Map();
+	return {
+		async get(key) {
+			return sessions.get(key) ?? null;
+		},
+		async set(key, sandboxId) {
+			sessions.set(key, sandboxId);
+		},
+		async delete(key) {
+			sessions.delete(key);
+		}
+	};
+}
+
+//#endregion
+//#region src/sandbox/validate.ts
+/** Validates `sandboxPlugin` configuration. */
+function validateSandboxPluginConfig(config) {
+	const client = config.client;
+	if (!client || typeof client !== "object") throw createValidationError$1("`sandboxPlugin` requires a `client`.", "plugins.sandboxPlugin");
+	if (config.prefix !== void 0 && config.prefix.trim().length === 0) throw createValidationError$1("`sandboxPlugin` requires `prefix` to be a non-empty string when provided.", "plugins.sandboxPlugin");
+}
+
+//#endregion
+//#region src/sandbox/plugin.ts
+const trimToUndefined = (value) => {
+	const trimmed = value?.trim();
+	return trimmed ? trimmed : void 0;
+};
+const normalizeHostUrl = (value) => /^[a-z][a-z0-9+.-]*:\/\//i.test(value) ? value : `https://${value}`;
+const createValidationError = (message, at, context) => BetterAgentError.fromCode("VALIDATION_FAILED", message, {
+	...context !== void 0 ? { context } : {},
+	trace: [{ at }]
+});
+/**
+* Adds sandbox tools.
+*
+* By default, the plugin reuses one sandbox per `conversationId`.
+* Use `sessionKey` to customize reuse, or return `null`/`undefined`
+* to disable reuse for a specific tool call.
+*
+* Uses an in-memory store by default.
+*
+* @example
+* ```ts
+* import { sandboxPlugin, createE2BSandboxClient } from "@better-agent/plugins";
+*
+* const plugin = sandboxPlugin({
+*   client: createE2BSandboxClient({
+*     apiKey: process.env.E2B_API_KEY,
+*   }),
+*   defaults: {
+*     template: "base",
+*     timeoutMs: 10 * 60_000,
+*   },
+* });
+* ```
+*/
+const sandboxPlugin = (config) => {
+	validateSandboxPluginConfig(config);
+	const sandboxClient = config.client;
+	const store = config.store ?? createMemorySandboxSessionStore();
+	const prefix = trimToUndefined(config.prefix) ?? "sandbox";
+	const nameFor = (suffix) => `${prefix}_${suffix}`;
+	const getSessionPolicy = (ctx, toolName) => {
+		if (config.sessionKey) {
+			const custom = trimToUndefined(config.sessionKey({
+				runId: ctx.runId,
+				agentName: ctx.agentName,
+				...ctx.conversationId !== void 0 ? { conversationId: ctx.conversationId } : {},
+				toolName
+			}) ?? void 0);
+			return custom !== void 0 ? {
+				kind: "managed",
+				sessionKey: custom
+			} : { kind: "disabled" };
+		}
+		return ctx.conversationId ? {
+			kind: "managed",
+			sessionKey: `conversation:${ctx.conversationId}`
+		} : { kind: "disabled" };
+	};
+	const getExplicitSandboxId = (value) => {
+		if (value === void 0) return;
+		const trimmed = value.trim();
+		if (!trimmed) throw createValidationError("`sandboxId` must be a non-empty string when provided.", "plugins.sandboxPlugin.sandboxId");
+		return trimmed;
+	};
+	const createSandbox = async (params, ctx, toolName) => {
+		const sessionPolicy = getSessionPolicy(ctx, toolName);
+		const created = await sandboxClient.createSandbox({
+			template: params?.template ?? config.defaults?.template,
+			timeoutMs: params?.timeoutMs ?? config.defaults?.timeoutMs,
+			envs: params?.envs ?? config.defaults?.envs,
+			metadata: params?.metadata ?? config.defaults?.metadata
+		});
+		if (sessionPolicy.kind === "managed") await store.set(sessionPolicy.sessionKey, created.sandboxId);
+		return {
+			sandboxId: created.sandboxId,
+			...sessionPolicy.kind === "managed" ? { sessionKey: sessionPolicy.sessionKey } : {},
+			created: true
+		};
+	};
+	const resolveSandbox = async (params) => {
+		const explicitSandboxId = getExplicitSandboxId(params.sandboxId);
+		if (explicitSandboxId) return {
+			sandboxId: explicitSandboxId,
+			created: false
+		};
+		const sessionPolicy = getSessionPolicy(params.ctx, params.toolName);
+		if (sessionPolicy.kind === "managed") {
+			const existing = trimToUndefined(await store.get(sessionPolicy.sessionKey) ?? void 0);
+			if (existing) return {
+				sandboxId: existing,
+				sessionKey: sessionPolicy.sessionKey,
+				created: false
+			};
+		}
+		if (!params.createIfMissing) throw createValidationError(`No sandbox is available for this ${params.ctx.conversationId ? "conversation" : "run"}. Create one first with '${nameFor("create")}' or pass a sandboxId explicitly.`, "plugins.sandboxPlugin.resolveSandbox.missing", {
+			runId: params.ctx.runId,
+			agentName: params.ctx.agentName,
+			conversationId: params.ctx.conversationId,
+			toolName: params.toolName
+		});
+		return await createSandbox(params.createParams, params.ctx, params.toolName);
+	};
+	const clearManagedSessionIfMatches = async (ctx, toolName, sandboxId) => {
+		const sessionPolicy = getSessionPolicy(ctx, toolName);
+		if (sessionPolicy.kind !== "managed") return;
+		if (await store.get(sessionPolicy.sessionKey) === sandboxId) {
+			await store.delete(sessionPolicy.sessionKey);
+			return sessionPolicy.sessionKey;
+		}
+	};
+	const createSchema = {
+		type: "object",
+		properties: {
+			forceNew: { type: "boolean" },
+			template: { type: "string" },
+			timeoutMs: {
+				type: "number",
+				exclusiveMinimum: 0
+			},
+			envs: {
+				type: "object",
+				additionalProperties: { type: "string" }
+			},
+			metadata: {
+				type: "object",
+				additionalProperties: { type: "string" }
+			}
+		},
+		additionalProperties: false
+	};
+	const sandboxIdSchema = { type: "string" };
+	const pathSchema = {
+		type: "string",
+		minLength: 1
+	};
+	const tools = [
+		defineTool({
+			name: nameFor("create"),
+			description: "Create a sandbox, or reuse the current conversation sandbox unless forceNew is true.",
+			schema: createSchema
+		}).server(async (input, ctx) => {
+			if (!input.forceNew) {
+				const sessionPolicy = getSessionPolicy(ctx, nameFor("create"));
+				if (sessionPolicy.kind === "managed") {
+					const existing = trimToUndefined(await store.get(sessionPolicy.sessionKey) ?? void 0);
+					if (existing) return {
+						sandboxId: existing,
+						reused: true,
+						created: false,
+						sessionKey: sessionPolicy.sessionKey
+					};
+				}
+			}
+			const resolved = await createSandbox({
+				template: input.template,
+				timeoutMs: input.timeoutMs,
+				envs: input.envs,
+				metadata: input.metadata
+			}, ctx, nameFor("create"));
+			return {
+				sandboxId: resolved.sandboxId,
+				reused: false,
+				created: true,
+				...resolved.sessionKey !== void 0 ? { sessionKey: resolved.sessionKey } : {}
+			};
+		}),
+		defineTool({
+			name: nameFor("exec"),
+			description: "Run one shell command inside a sandbox. Creates a sandbox automatically when none exists for the conversation.",
+			schema: {
+				type: "object",
+				properties: {
+					sandboxId: sandboxIdSchema,
+					cmd: {
+						type: "string",
+						minLength: 1
+					},
+					cwd: { type: "string" },
+					timeoutMs: {
+						type: "number",
+						exclusiveMinimum: 0
+					},
+					envs: {
+						type: "object",
+						additionalProperties: { type: "string" }
+					}
+				},
+				required: ["cmd"],
+				additionalProperties: false
+			},
+			approval: config.approvals?.exec
+		}).server(async (input, ctx) => {
+			const resolved = await resolveSandbox({
+				sandboxId: input.sandboxId,
+				createIfMissing: true,
+				ctx,
+				toolName: nameFor("exec")
+			});
+			const result = await sandboxClient.runCommand({
+				sandboxId: resolved.sandboxId,
+				cmd: input.cmd,
+				cwd: input.cwd,
+				timeoutMs: input.timeoutMs,
+				envs: input.envs
+			});
+			return {
+				sandboxId: resolved.sandboxId,
+				createdSandbox: resolved.created,
+				...result
+			};
+		}),
+		defineTool({
+			name: nameFor("read_file"),
+			description: "Read one text file from a sandbox. Creates a sandbox automatically when none exists for the conversation.",
+			schema: {
+				type: "object",
+				properties: {
+					sandboxId: sandboxIdSchema,
+					path: pathSchema
+				},
+				required: ["path"],
+				additionalProperties: false
+			}
+		}).server(async (input, ctx) => {
+			const resolved = await resolveSandbox({
+				sandboxId: input.sandboxId,
+				createIfMissing: true,
+				ctx,
+				toolName: nameFor("read_file")
+			});
+			return {
+				sandboxId: resolved.sandboxId,
+				path: input.path,
+				content: await sandboxClient.readFile({
+					sandboxId: resolved.sandboxId,
+					path: input.path
+				})
+			};
+		}),
+		defineTool({
+			name: nameFor("write_file"),
+			description: "Write one text file into a sandbox. Creates a sandbox automatically when none exists for the conversation.",
+			schema: {
+				type: "object",
+				properties: {
+					sandboxId: sandboxIdSchema,
+					path: pathSchema,
+					content: { type: "string" }
+				},
+				required: ["path", "content"],
+				additionalProperties: false
+			},
+			approval: config.approvals?.writeFile
+		}).server(async (input, ctx) => {
+			const resolved = await resolveSandbox({
+				sandboxId: input.sandboxId,
+				createIfMissing: true,
+				ctx,
+				toolName: nameFor("write_file")
+			});
+			const result = await sandboxClient.writeFile({
+				sandboxId: resolved.sandboxId,
+				path: input.path,
+				content: input.content
+			});
+			return {
+				sandboxId: resolved.sandboxId,
+				createdSandbox: resolved.created,
+				path: result.path
+			};
+		}),
+		defineTool({
+			name: nameFor("list_files"),
+			description: "List directory entries inside a sandbox. Creates a sandbox automatically when none exists for the conversation.",
+			schema: {
+				type: "object",
+				properties: {
+					sandboxId: sandboxIdSchema,
+					path: pathSchema
+				},
+				required: ["path"],
+				additionalProperties: false
+			}
+		}).server(async (input, ctx) => {
+			const resolved = await resolveSandbox({
+				sandboxId: input.sandboxId,
+				createIfMissing: true,
+				ctx,
+				toolName: nameFor("list_files")
+			});
+			return {
+				sandboxId: resolved.sandboxId,
+				path: input.path,
+				entries: await sandboxClient.listFiles({
+					sandboxId: resolved.sandboxId,
+					path: input.path
+				})
+			};
+		}),
+		defineTool({
+			name: nameFor("make_dir"),
+			description: "Create a directory inside a sandbox. Creates a sandbox automatically when none exists for the conversation.",
+			schema: {
+				type: "object",
+				properties: {
+					sandboxId: sandboxIdSchema,
+					path: pathSchema
+				},
+				required: ["path"],
+				additionalProperties: false
+			}
+		}).server(async (input, ctx) => {
+			const resolved = await resolveSandbox({
+				sandboxId: input.sandboxId,
+				createIfMissing: true,
+				ctx,
+				toolName: nameFor("make_dir")
+			});
+			const result = await sandboxClient.makeDir({
+				sandboxId: resolved.sandboxId,
+				path: input.path
+			});
+			return {
+				sandboxId: resolved.sandboxId,
+				path: input.path,
+				created: result.created
+			};
+		}),
+		defineTool({
+			name: nameFor("remove_path"),
+			description: "Remove a file or directory from a sandbox.",
+			schema: {
+				type: "object",
+				properties: {
+					sandboxId: sandboxIdSchema,
+					path: pathSchema
+				},
+				required: ["path"],
+				additionalProperties: false
+			},
+			approval: config.approvals?.removePath
+		}).server(async (input, ctx) => {
+			const resolved = await resolveSandbox({
+				sandboxId: input.sandboxId,
+				createIfMissing: false,
+				ctx,
+				toolName: nameFor("remove_path")
+			});
+			await sandboxClient.removePath({
+				sandboxId: resolved.sandboxId,
+				path: input.path
+			});
+			return {
+				sandboxId: resolved.sandboxId,
+				removed: true,
+				path: input.path
+			};
+		}),
+		defineTool({
+			name: nameFor("get_host"),
+			description: "Expose one sandbox port as a host URL so callers can reach an app running inside the sandbox.",
+			schema: {
+				type: "object",
+				properties: {
+					sandboxId: sandboxIdSchema,
+					port: {
+						type: "number",
+						minimum: 1,
+						maximum: 65535
+					}
+				},
+				required: ["port"],
+				additionalProperties: false
+			}
+		}).server(async (input, ctx) => {
+			const resolved = await resolveSandbox({
+				sandboxId: input.sandboxId,
+				createIfMissing: false,
+				ctx,
+				toolName: nameFor("get_host")
+			});
+			const hostResult = await sandboxClient.getHost({
+				sandboxId: resolved.sandboxId,
+				port: input.port
+			});
+			const preview = typeof hostResult === "string" ? void 0 : hostResult;
+			const host = normalizeHostUrl(typeof hostResult === "string" ? hostResult : hostResult.url);
+			return {
+				sandboxId: resolved.sandboxId,
+				port: input.port,
+				host,
+				...preview?.token !== void 0 ? { token: preview.token } : {}
+			};
+		}),
+		defineTool({
+			name: nameFor("kill"),
+			description: "Terminate a sandbox and clear the current conversation sandbox when applicable.",
+			schema: {
+				type: "object",
+				properties: { sandboxId: sandboxIdSchema },
+				additionalProperties: false
+			},
+			approval: config.approvals?.killSandbox
+		}).server(async (input, ctx) => {
+			const resolved = await resolveSandbox({
+				sandboxId: input.sandboxId,
+				createIfMissing: false,
+				ctx,
+				toolName: nameFor("kill")
+			});
+			await sandboxClient.killSandbox({ sandboxId: resolved.sandboxId });
+			const clearedSessionKey = await clearManagedSessionIfMatches(ctx, nameFor("kill"), resolved.sandboxId);
+			return {
+				sandboxId: resolved.sandboxId,
+				killed: true,
+				...clearedSessionKey !== void 0 ? { clearedSessionKey } : {}
+			};
+		})
+	];
+	return {
+		id: config.id ?? "sandbox",
+		tools
+	};
+};
+
+//#endregion
+export { authPlugin, createDaytonaSandboxClient, createE2BSandboxClient, createMemorySandboxSessionStore, ipAllowlistPlugin, loggingPlugin, rateLimitPlugin, sandboxPlugin };
 //# sourceMappingURL=index.mjs.map