@mairwunnx/minecraft-mcp 0.0.0-stage → 2.0.0

package/dist/tools/entities.js

@@ -0,0 +1,219 @@
+import { z } from "zod";
+import { unwrap } from "../client.js";
+import { tool } from "../tool.js";
+import { cursor, format, limit, location, world } from "./common.js";
+export function entityTools(ctx) {
+    const { api, token } = ctx;
+    const one = (args) => ({ params: { path: { world: args.world, uuid: args.uuid } } });
+    tool(ctx, {
+        name: "list_entities",
+        untrusted: true,
+        title: "Entities",
+        description: "Loaded entities in a world, filtered by type and by a radius around x, y, z. Only loaded chunks count: entities far from players aren't listed.",
+        scope: "read",
+        effect: "read",
+        input: {
+            world,
+            types: z.array(z.string()).optional().describe('Entity keys, such as ["minecraft:zombie"]'),
+            x: z.number().optional(),
+            y: z.number().optional(),
+            z: z.number().optional(),
+            radius: z.number().positive().optional().describe("Blocks around x, y, z; give all three with it"),
+            limit,
+            cursor,
+        },
+        run: (args) => unwrap(api.GET("/worlds/{world}/entities", {
+            params: {
+                path: { world: args.world },
+                query: {
+                    type: args.types?.join(","),
+                    x: args.x,
+                    y: args.y,
+                    z: args.z,
+                    radius: args.radius,
+                    limit: args.limit,
+                    cursor: args.cursor,
+                },
+            },
+        }), token),
+    });
+    tool(ctx, {
+        name: "get_entity",
+        untrusted: true,
+        title: "Entity",
+        description: "One entity in detail: position, health, equipment, effects, owner, tags.",
+        scope: "read",
+        effect: "read",
+        input: { world, uuid: z.string() },
+        run: (args) => unwrap(api.GET("/worlds/{world}/entities/{uuid}", one(args)), token),
+    });
+    tool(ctx, {
+        name: "spawn_entity",
+        title: "Spawn entities",
+        description: "Spawn one or more entities of a type, such as `minecraft:cow`, at a location. The server caps the count (50 by default).",
+        scope: "write:world",
+        effect: "write",
+        input: {
+            world,
+            type: z.string().min(1),
+            location,
+            count: z.number().int().min(1).default(1),
+            customName: z.string().optional(),
+            format,
+            ai: z.boolean().optional(),
+            persistent: z.boolean().optional().describe("Don't despawn"),
+            glowing: z.boolean().optional(),
+        },
+        run: ({ world: name, ...body }) => unwrap(api.POST("/worlds/{world}/entities", { params: { path: { world: name } }, body }), token),
+    });
+    tool(ctx, {
+        name: "update_entity",
+        title: "Change an entity",
+        description: "Rename, toggle AI, glowing, gravity, invulnerability, set health or fire, teleport, push, or tag an entity. Not for players.",
+        scope: "write:world",
+        effect: "write",
+        input: {
+            world,
+            uuid: z.string(),
+            customName: z.string().optional(),
+            format,
+            customNameVisible: z.boolean().optional(),
+            glowing: z.boolean().optional(),
+            silent: z.boolean().optional(),
+            invulnerable: z.boolean().optional(),
+            gravity: z.boolean().optional(),
+            persistent: z.boolean().optional(),
+            ai: z.boolean().optional(),
+            health: z.number().min(0).optional(),
+            fireTicks: z.number().int().optional(),
+            location: location.optional().describe("Teleport here"),
+            velocity: z.object({ x: z.number(), y: z.number(), z: z.number() }).optional(),
+            addTags: z.array(z.string()).optional(),
+            removeTags: z.array(z.string()).optional(),
+        },
+        run: ({ world: name, uuid, ...body }) => unwrap(api.PATCH("/worlds/{world}/entities/{uuid}", {
+            params: { path: { world: name, uuid } },
+            body: { ...body, addTags: body.addTags ?? [], removeTags: body.removeTags ?? [] },
+        }), token),
+    });
+    tool(ctx, {
+        name: "remove_entity",
+        title: "Remove entities",
+        description: "Remove entities without drops: one by uuid, or many by types, such as dropped items, arrows, or a mob farm's overflow, optionally within a radius of x, y, z. Many at once never touches players, skips named mobs and tamed pets unless includeNamed is true, takes the nearest first up to max, and dryRun only counts. Try dryRun first and tell the user what would go.",
+        scope: "write:world",
+        effect: "destructive",
+        input: {
+            world,
+            uuid: z.string().optional().describe("One entity"),
+            types: z
+                .array(z.string().min(1))
+                .optional()
+                .describe('Entity keys, such as ["minecraft:item", "minecraft:arrow"]'),
+            x: z.number().optional(),
+            y: z.number().optional(),
+            z: z.number().optional(),
+            radius: z.number().positive().optional().describe("Blocks around x, y, z"),
+            max: z
+                .number()
+                .int()
+                .min(1)
+                .optional()
+                .describe("Remove at most this many; the server caps it (1000 by default)"),
+            includeNamed: z.boolean().optional().describe("Also remove named mobs and tamed pets"),
+            dryRun: z.boolean().optional().describe("Only count what would be removed"),
+        },
+        run: (args) => {
+            if (args.uuid)
+                return unwrap(api.DELETE("/worlds/{world}/entities/{uuid}", one({ world: args.world, uuid: args.uuid })), token);
+            if (!args.types?.length)
+                throw new Error("Give uuid, or types for many at once");
+            return unwrap(api.DELETE("/worlds/{world}/entities", {
+                params: {
+                    path: { world: args.world },
+                    query: {
+                        type: args.types.join(","),
+                        x: args.x,
+                        y: args.y,
+                        z: args.z,
+                        radius: args.radius,
+                        max: args.max,
+                        includeNamed: args.includeNamed,
+                        dryRun: args.dryRun,
+                    },
+                },
+            }), token);
+        },
+    });
+    tool(ctx, {
+        name: "world_effect",
+        title: "Lightning, explosions, sounds, particles",
+        description: "Make something happen at a location. `lightning` strikes (effectOnly makes it harmless). `explosion` blows up with power (TNT is 4); breakBlocks destroys terrain and fire sets things alight. `sound` plays a sound such as `minecraft:entity.ender_dragon.growl` for everyone nearby. `particles` shows particles such as `minecraft:heart` or `minecraft:flame`; ones that need extra data (dust, block) aren't supported.",
+        scope: "write:world",
+        effect: "destructive",
+        input: {
+            world,
+            kind: z.enum(["lightning", "explosion", "sound", "particles"]),
+            location,
+            effectOnly: z.boolean().optional().describe("lightning: only the flash and the sound"),
+            power: z.number().min(0).optional().describe("explosion: 4 by default"),
+            fire: z.boolean().optional().describe("explosion"),
+            breakBlocks: z.boolean().optional().describe("explosion"),
+            sound: z.string().optional().describe("sound: the sound key"),
+            volume: z.number().min(0).max(16).optional().describe("sound"),
+            pitch: z.number().min(0.5).max(2).optional().describe("sound"),
+            category: z.string().optional().describe("sound: `master` by default"),
+            particle: z.string().optional().describe("particles: the particle key"),
+            count: z.number().int().min(1).optional().describe("particles: 10 by default"),
+            offset: z.object({ x: z.number(), y: z.number(), z: z.number() }).optional().describe("particles: spread"),
+            speed: z.number().min(0).optional().describe("particles"),
+        },
+        run: (args) => {
+            const params = { params: { path: { world: args.world } } };
+            const location = args.location;
+            switch (args.kind) {
+                case "lightning":
+                    return unwrap(api.POST("/worlds/{world}/lightning", {
+                        ...params,
+                        body: { location, effectOnly: args.effectOnly ?? false },
+                    }), token);
+                case "explosion":
+                    return unwrap(api.POST("/worlds/{world}/explosions", {
+                        ...params,
+                        body: {
+                            location,
+                            power: args.power ?? 4,
+                            fire: args.fire ?? false,
+                            breakBlocks: args.breakBlocks ?? false,
+                        },
+                    }), token);
+                case "sound":
+                    if (!args.sound)
+                        throw new Error("kind sound needs sound");
+                    return unwrap(api.POST("/worlds/{world}/sounds", {
+                        ...params,
+                        body: {
+                            sound: args.sound,
+                            location,
+                            volume: args.volume ?? 1,
+                            pitch: args.pitch ?? 1,
+                            category: args.category ?? "master",
+                        },
+                    }), token);
+                case "particles":
+                    if (!args.particle)
+                        throw new Error("kind particles needs particle");
+                    return unwrap(api.POST("/worlds/{world}/particles", {
+                        ...params,
+                        body: {
+                            particle: args.particle,
+                            location,
+                            count: args.count ?? 10,
+                            offset: args.offset,
+                            speed: args.speed ?? 0,
+                        },
+                    }), token);
+            }
+        },
+    });
+}
+//# sourceMappingURL=entities.js.map

package/dist/tools/players.js

@@ -0,0 +1,272 @@
+import { z } from "zod";
+import { unwrap } from "../client.js";
+import { tool } from "../tool.js";
+import { player as anyPlayer, cursor, format, item, limit, location, OFFLINE_NOTE, playerOrMe, SLOT_LAYOUT, } from "./common.js";
+const container = z.enum(["inventory", "enderchest"]).default("inventory");
+export function playerTools(ctx) {
+    const { api, token } = ctx;
+    const who = (name) => ({ params: { path: { player: name } } });
+    const player = playerOrMe(ctx.player);
+    tool(ctx, {
+        name: "list_players",
+        title: "Players",
+        description: "Everyone who has played here: online state, first and last seen, playtime in seconds.",
+        scope: "read",
+        effect: "read",
+        input: {
+            online: z.boolean().optional(),
+            sort: z.enum(["name", "last_seen", "playtime"]).optional(),
+            limit,
+            cursor,
+        },
+        run: (args) => unwrap(api.GET("/players", { params: { query: args } }), token),
+    });
+    tool(ctx, {
+        name: "list_online_players",
+        untrusted: true,
+        title: "Online players",
+        description: "Who is playing now, with world, game mode, health, food, level, ping, idle time, and location.",
+        scope: "read",
+        effect: "read",
+        input: {},
+        run: () => unwrap(api.GET("/players/online"), token),
+    });
+    tool(ctx, {
+        name: "get_player",
+        untrusted: true,
+        title: "Player",
+        description: "A player's profile and, while online, full state: game mode, health, food, XP, location, flight, speed, ping, client. Offline players show their last location.",
+        scope: "read",
+        effect: "read",
+        input: { player },
+        run: (args) => unwrap(api.GET("/players/{player}", who(args.player)), token),
+    });
+    tool(ctx, {
+        name: "get_player_inventory",
+        untrusted: true,
+        title: "Inventory or ender chest",
+        description: `Main inventory, armor, and offhand with full item data, or the ender chest. ${SLOT_LAYOUT} ${OFFLINE_NOTE}`,
+        scope: "read",
+        effect: "read",
+        input: { player, container },
+        run: (args) => args.container === "enderchest"
+            ? unwrap(api.GET("/players/{player}/enderchest", who(args.player)), token)
+            : unwrap(api.GET("/players/{player}/inventory", who(args.player)), token),
+    });
+    tool(ctx, {
+        name: "get_player_effects",
+        title: "Effects",
+        description: `Active potion effects. ${OFFLINE_NOTE}`,
+        scope: "read",
+        effect: "read",
+        input: { player },
+        run: (args) => unwrap(api.GET("/players/{player}/effects", who(args.player)), token),
+    });
+    tool(ctx, {
+        name: "get_player_statistics",
+        title: "Statistics",
+        description: "Vanilla statistics by category (custom, mined, broken, crafted, used, picked_up, dropped, killed, killed_by); live while online. play_time is in ticks (20 per second); distances in centimeters.",
+        scope: "read",
+        effect: "read",
+        input: { player, category: z.string().optional().describe("Only one category, such as `mined`") },
+        run: (args) => unwrap(api.GET("/players/{player}/statistics", {
+            params: { path: { player: args.player }, query: { category: args.category } },
+        }), token),
+    });
+    tool(ctx, {
+        name: "get_player_advancements",
+        title: "Advancements",
+        description: "Every advancement on the server with its title, description, frame, and parent, done or not, and when it was finished. done false lists what's left: with the parents, it shows what to go for next.",
+        scope: "read",
+        effect: "read",
+        input: { player, done: z.boolean().optional().describe("Only finished (true) or unfinished (false)") },
+        run: (args) => unwrap(api.GET("/players/{player}/advancements", {
+            params: { path: { player: args.player }, query: { done: args.done } },
+        }), token),
+    });
+    tool(ctx, {
+        name: "get_player_sessions",
+        title: "Play sessions",
+        description: "When the player joined and left, newest first, as WorldAPI recorded them.",
+        scope: "read",
+        effect: "read",
+        input: { player, limit, cursor },
+        run: (args) => unwrap(api.GET("/players/{player}/sessions", {
+            params: { path: { player: args.player }, query: { limit: args.limit, cursor: args.cursor } },
+        }), token),
+    });
+    tool(ctx, {
+        name: "check_permission",
+        title: "Permissions",
+        description: "Whether a player is an operator and, if online, whether they have a permission node.",
+        scope: "read",
+        effect: "read",
+        input: { player, node: z.string().optional().describe("Such as `worldedit.wand`") },
+        run: (args) => unwrap(api.GET("/players/{player}/permissions", {
+            params: { path: { player: args.player }, query: { node: args.node } },
+        }), token),
+    });
+    tool(ctx, {
+        name: "teleport_player",
+        title: "Teleport a player",
+        description: `Teleport to coordinates, to another player, or to a world's spawn; give exactly one. Check get_highest_block first to land on solid ground. ${OFFLINE_NOTE}`,
+        scope: "write:players",
+        effect: "write",
+        input: {
+            player,
+            location: location.optional(),
+            toPlayer: z.string().optional().describe("Another player's name or UUID"),
+            worldSpawn: z.string().optional().describe("A world name"),
+        },
+        run: (args) => unwrap(api.POST("/players/{player}/teleport", {
+            ...who(args.player),
+            body: { location: args.location, player: args.toPlayer, worldSpawn: args.worldSpawn },
+        }), token),
+    });
+    tool(ctx, {
+        name: "set_player_property",
+        title: "Change a player",
+        description: `Set game mode, health, food (0–20), saturation, XP level or progress, flight, walk or fly speed (-1 to 1; defaults 0.2 and 0.1), display or tab-list name, invulnerability, fire, or air. ${OFFLINE_NOTE}`,
+        scope: "write:players",
+        effect: "write",
+        input: {
+            player,
+            gameMode: z.enum(["survival", "creative", "adventure", "spectator"]).optional(),
+            health: z.number().min(0).optional(),
+            food: z.number().int().min(0).max(20).optional(),
+            saturation: z.number().min(0).max(20).optional(),
+            exhaustion: z.number().min(0).optional(),
+            level: z.number().int().min(0).optional(),
+            exp: z.number().min(0).max(1).optional().describe("Progress to the next level"),
+            allowFlight: z.boolean().optional(),
+            flying: z.boolean().optional(),
+            walkSpeed: z.number().min(-1).max(1).optional(),
+            flySpeed: z.number().min(-1).max(1).optional(),
+            displayName: z.string().optional(),
+            listName: z.string().optional(),
+            format,
+            invulnerable: z.boolean().optional(),
+            fireTicks: z.number().int().optional(),
+            remainingAir: z.number().int().optional(),
+        },
+        run: ({ player: name, ...body }) => unwrap(api.PATCH("/players/{player}", { ...who(name), body }), token),
+    });
+    tool(ctx, {
+        name: "send_message",
+        title: "Message a player",
+        description: `Send one player a chat message, title, or action bar text, optionally with a sound. ${OFFLINE_NOTE}`,
+        scope: "write:players",
+        effect: "write",
+        input: {
+            player,
+            message: z.string().min(1),
+            kind: z.enum(["chat", "title", "actionbar"]).default("chat"),
+            subtitle: z.string().optional(),
+            sound: z.string().optional().describe("Such as `minecraft:entity.experience_orb.pickup`"),
+            format,
+        },
+        run: ({ player: name, ...body }) => unwrap(api.POST("/players/{player}/message", { ...who(name), body }), token),
+    });
+    tool(ctx, {
+        name: "kick_player",
+        title: "Kick a player",
+        description: "Disconnect a player with an optional reason.",
+        scope: "admin",
+        effect: "destructive",
+        input: { player: anyPlayer, reason: z.string().optional(), format },
+        run: ({ player: name, ...body }) => unwrap(api.POST("/players/{player}/kick", { ...who(name), body }), token),
+    });
+    tool(ctx, {
+        name: "give_item",
+        title: "Give an item",
+        description: `Add an item to a player's inventory (what doesn't fit drops at their feet) or ender chest. ${OFFLINE_NOTE}`,
+        scope: "write:players",
+        effect: "write",
+        input: { player, item, container },
+        run: (args) => unwrap(args.container === "enderchest"
+            ? api.POST("/players/{player}/enderchest/give", { ...who(args.player), body: { item: args.item } })
+            : api.POST("/players/{player}/inventory/give", { ...who(args.player), body: { item: args.item } }), token),
+    });
+    tool(ctx, {
+        name: "edit_inventory",
+        title: "Edit an inventory",
+        description: `Change a player's inventory or ender chest: \`set\` puts an item in a slot, replacing what was there; \`clear_slot\` empties one slot; \`clear\` empties everything, armor and offhand included. Cleared items are gone. To add items without picking a slot, use give_item. ${SLOT_LAYOUT} ${OFFLINE_NOTE}`,
+        scope: "write:players",
+        effect: "destructive",
+        input: {
+            player,
+            action: z.enum(["set", "clear_slot", "clear"]),
+            slot: z.number().int().min(0).optional().describe("For set and clear_slot"),
+            item: item.optional().describe("For set"),
+            container,
+        },
+        run: (args) => {
+            const ender = args.container === "enderchest";
+            if (args.action === "clear")
+                return unwrap(ender
+                    ? api.DELETE("/players/{player}/enderchest", who(args.player))
+                    : api.DELETE("/players/{player}/inventory", who(args.player)), token);
+            if (args.slot === undefined)
+                throw new Error(`${args.action} needs slot`);
+            const params = { params: { path: { player: args.player, slot: args.slot } } };
+            if (args.action === "clear_slot")
+                return unwrap(ender
+                    ? api.DELETE("/players/{player}/enderchest/slots/{slot}", params)
+                    : api.DELETE("/players/{player}/inventory/slots/{slot}", params), token);
+            if (!args.item)
+                throw new Error("set needs item");
+            return unwrap(ender
+                ? api.PATCH("/players/{player}/enderchest/slots/{slot}", { ...params, body: args.item })
+                : api.PATCH("/players/{player}/inventory/slots/{slot}", { ...params, body: args.item }), token);
+        },
+    });
+    const effect = z.object({
+        type: z.string().min(1).describe("Such as `minecraft:speed`"),
+        durationSeconds: z.number().int().positive().optional().describe("Leave out for an infinite effect"),
+        amplifier: z.number().int().min(0).max(255).default(0).describe("0 is level I"),
+        ambient: z.boolean().default(false),
+        particles: z.boolean().default(true),
+        icon: z.boolean().default(true),
+    });
+    tool(ctx, {
+        name: "set_effects",
+        title: "Change potion effects",
+        description: `Give, take away, or clear a player's potion effects, in that order: clear first, then remove, then add. Answers with the effects the player has afterwards. ${OFFLINE_NOTE}`,
+        scope: "write:players",
+        effect: "write",
+        input: {
+            player,
+            add: z.array(effect).optional(),
+            remove: z.array(z.string().min(1)).optional().describe("Effect keys to take away"),
+            clear: z.boolean().optional().describe("Take away every effect first"),
+        },
+        run: async (args) => {
+            if (args.clear)
+                await unwrap(api.DELETE("/players/{player}/effects", who(args.player)), token);
+            for (const type of args.remove ?? [])
+                await unwrap(api.DELETE("/players/{player}/effects/{effect}", { params: { path: { player: args.player, effect: type } } }), token);
+            for (const body of args.add ?? [])
+                await unwrap(api.POST("/players/{player}/effects", { ...who(args.player), body }), token);
+            return unwrap(api.GET("/players/{player}/effects", who(args.player)), token);
+        },
+    });
+    tool(ctx, {
+        name: "set_advancement",
+        title: "Grant or revoke an advancement",
+        description: `Complete every criterion of an advancement for a player (done true), or take them all back (done false). ${OFFLINE_NOTE}`,
+        scope: "write:players",
+        effect: "idempotent",
+        input: {
+            player,
+            key: z.string().min(1).describe("Advancement key, such as `minecraft:story/mine_diamond`"),
+            done: z.boolean(),
+        },
+        run: (args) => {
+            const params = { params: { path: { player: args.player, key: args.key } } };
+            return unwrap(args.done
+                ? api.POST("/players/{player}/advancements/{key}", { ...params, body: {} })
+                : api.DELETE("/players/{player}/advancements/{key}", params), token);
+        },
+    });
+}
+//# sourceMappingURL=players.js.map

package/dist/tools/scripts.js

@@ -0,0 +1,81 @@
+import { z } from "zod";
+import { unwrap } from "../client.js";
+import { tool } from "../tool.js";
+const API = [
+    "Scripts are Java, compiled and run inside the Minecraft server. This is arbitrary code: it needs the token's `code` scope and scripts.enabled in WorldAPI's config.",
+    "Only Java and the Paper/Bukkit API are visible (plus Adventure, Guava, Brigadier, JOML); process, file, reflection, and class-loading calls are blocked at compile time.",
+    "Interface: `com.mairwunnx.worldapi.script.api.WorldApiScript` with `Object run(ScriptContext ctx)`, `void enable(ScriptContext ctx)`, `void disable()`.",
+    "ScriptContext: `server()`, `log(String)`, `on(EventClass.class, e -> …)`, `on(type, priority, ignoreCancelled, handler)`, `later(ticks, task)`, `every(delay, period, task)`, `async(task)`, `sync(callable)`, `memory()`.",
+].join(" ");
+export function scriptTools(ctx) {
+    const { api, token } = ctx;
+    tool(ctx, {
+        name: "execute_java",
+        untrusted: true,
+        title: "Run Java once",
+        description: `${API} Send either a full public class implementing WorldApiScript, or just the body of run: \`ctx\` and \`server\` are in scope, and org.bukkit.*, org.bukkit.entity.*, org.bukkit.block.*, org.bukkit.inventory.*, java.util.*, and java.util.stream.* are imported. End with \`return <value>;\`: maps, lists, and primitives come back as JSON. Example: \`return server.getOnlinePlayers().stream().map(Player::getName).toList();\`. thread \`main\` (default) may touch the world but blocks the tick while it runs; \`async\` runs beside the server and must use ctx.sync(...) for world access. The script unloads as soon as it returns, with anything it registered.`,
+        scope: "code",
+        effect: "destructive",
+        input: { source: z.string().min(1), thread: z.enum(["main", "async"]).default("main") },
+        run: (args) => unwrap(api.POST("/scripts/run", { body: args }), token),
+    });
+    tool(ctx, {
+        name: "load_java_script",
+        title: "Load a Java script",
+        description: `${API} Loads a resident script: a full public class implementing WorldApiScript whose enable(ctx) runs once on the server thread. Register listeners with ctx.on(...) and tasks with ctx.later/every/async — only those are removed on unload, so never register through Bukkit directly. persistent keeps it across restarts; replace swaps a script with the same id.`,
+        scope: "code",
+        effect: "destructive",
+        input: {
+            id: z
+                .string()
+                .regex(/^[a-z0-9_-]{1,40}$/)
+                .describe("Lowercase letters, digits, dashes, underscores"),
+            source: z.string().min(1),
+            persistent: z.boolean().default(false),
+            replace: z.boolean().default(false),
+        },
+        run: (args) => unwrap(api.POST("/scripts", { body: args }), token),
+    });
+    tool(ctx, {
+        name: "list_java_scripts",
+        title: "Loaded scripts",
+        description: "Resident scripts with their listener and task counts and error count.",
+        scope: "code",
+        effect: "read",
+        input: {},
+        run: () => unwrap(api.GET("/scripts"), token),
+    });
+    tool(ctx, {
+        name: "get_java_script",
+        untrusted: true,
+        title: "Script and its log",
+        description: "One resident script with its source, plus the latest lines it wrote with ctx.log and errors from its handlers and tasks. logs false leaves the log out.",
+        scope: "code",
+        effect: "read",
+        input: {
+            id: z.string(),
+            logs: z.boolean().default(true),
+            limit: z.number().int().min(1).max(10000).optional().describe("Log lines to return"),
+        },
+        run: async (args) => {
+            const path = { id: args.id };
+            const [script, logs] = await Promise.all([
+                unwrap(api.GET("/scripts/{id}", { params: { path } }), token),
+                args.logs
+                    ? unwrap(api.GET("/scripts/{id}/logs", { params: { path, query: { limit: args.limit } } }), token)
+                    : undefined,
+            ]);
+            return logs ? { script, logs } : { script };
+        },
+    });
+    tool(ctx, {
+        name: "unload_java_script",
+        title: "Unload a script",
+        description: "Run the script's disable(), remove its listeners and tasks, and close its class loader. A persistent script's saved copy is deleted too, unless keepSaved is true; then it loads again on the next server start.",
+        scope: "code",
+        effect: "destructive",
+        input: { id: z.string(), keepSaved: z.boolean().optional() },
+        run: (args) => unwrap(api.DELETE("/scripts/{id}", { params: { path: { id: args.id }, query: { keepSaved: args.keepSaved } } }), token),
+    });
+}
+//# sourceMappingURL=scripts.js.map