@code-yeongyu/senpi 0.74.0

package/dist/core/extensions/builtin/anthropic-computer-use/index.js

@@ -0,0 +1,676 @@
+import { execFile } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { readFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { promisify } from "node:util";
+import { Type } from "typebox";
+const execFileAsync = promisify(execFile);
+const ANTHROPIC_COMPUTER_USE_ENV = "PI_ANTHROPIC_COMPUTER_USE";
+const ANTHROPIC_COMPUTER_USE_WIDTH_ENV = "PI_ANTHROPIC_COMPUTER_USE_WIDTH";
+const ANTHROPIC_COMPUTER_USE_HEIGHT_ENV = "PI_ANTHROPIC_COMPUTER_USE_HEIGHT";
+const ANTHROPIC_COMPUTER_USE_DISPLAY_NUMBER_ENV = "PI_ANTHROPIC_COMPUTER_USE_DISPLAY_NUMBER";
+const ANTHROPIC_COMPUTER_USE_BETA = "computer-use-2025-01-24";
+const ANTHROPIC_NATIVE_COMPUTER_TOOL_TYPE = "computer_20250124";
+const ANTHROPIC_NATIVE_COMPUTER_TOOL_NAME = "computer";
+export const computerSchema = Type.Object({
+    action: Type.Union([
+        Type.Literal("screenshot"),
+        Type.Literal("key"),
+        Type.Literal("type"),
+        Type.Literal("mouse_move"),
+        Type.Literal("left_click"),
+        Type.Literal("right_click"),
+        Type.Literal("middle_click"),
+        Type.Literal("double_click"),
+        Type.Literal("triple_click"),
+        Type.Literal("left_click_drag"),
+        Type.Literal("cursor_position"),
+        Type.Literal("left_mouse_down"),
+        Type.Literal("left_mouse_up"),
+        Type.Literal("scroll"),
+        Type.Literal("hold_key"),
+        Type.Literal("wait"),
+    ]),
+    coordinate: Type.Optional(Type.Array(Type.Number(), { minItems: 2, maxItems: 2 })),
+    start_coordinate: Type.Optional(Type.Array(Type.Number(), { minItems: 2, maxItems: 2 })),
+    text: Type.Optional(Type.String()),
+    key: Type.Optional(Type.String()),
+    scroll_direction: Type.Optional(Type.Union([Type.Literal("up"), Type.Literal("down"), Type.Literal("left"), Type.Literal("right")])),
+    scroll_amount: Type.Optional(Type.Number()),
+    duration: Type.Optional(Type.Number()),
+});
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}
+function enabledByEnv(env) {
+    if (!env) {
+        return false;
+    }
+    const normalized = env.trim().toLowerCase();
+    return normalized === "1" || normalized === "true" || normalized === "yes" || normalized === "on";
+}
+function parsePositiveInt(value) {
+    if (!value) {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    if (!/^\d+$/.test(trimmed)) {
+        return undefined;
+    }
+    const parsed = Number.parseInt(trimmed, 10);
+    return parsed > 0 ? parsed : undefined;
+}
+function getComputerDisplayConfig() {
+    const width = parsePositiveInt(process.env[ANTHROPIC_COMPUTER_USE_WIDTH_ENV]);
+    const height = parsePositiveInt(process.env[ANTHROPIC_COMPUTER_USE_HEIGHT_ENV]);
+    const displayNumber = parsePositiveInt(process.env[ANTHROPIC_COMPUTER_USE_DISPLAY_NUMBER_ENV]);
+    if (width === undefined || height === undefined) {
+        return undefined;
+    }
+    if (displayNumber === undefined) {
+        return { width, height };
+    }
+    return { width, height, displayNumber };
+}
+function getComputerEnableState() {
+    if (!enabledByEnv(process.env[ANTHROPIC_COMPUTER_USE_ENV])) {
+        return { enabled: false };
+    }
+    const config = getComputerDisplayConfig();
+    if (!config) {
+        return { enabled: false };
+    }
+    return { enabled: true, config };
+}
+export function isAnthropicComputerUseEnabled() {
+    return getComputerEnableState().enabled;
+}
+function isComputerToolType(value) {
+    return typeof value === "string" && value.startsWith("computer_");
+}
+function sanitizeTools(tools) {
+    const sanitizedTools = [];
+    for (const tool of tools) {
+        if (!isRecord(tool)) {
+            continue;
+        }
+        const shouldStripFunctionVariant = tool.name === ANTHROPIC_NATIVE_COMPUTER_TOOL_NAME && !isComputerToolType(tool.type);
+        if (!shouldStripFunctionVariant) {
+            sanitizedTools.push(tool);
+        }
+    }
+    return sanitizedTools;
+}
+function mergeBetaHeader(existing) {
+    const existingParts = typeof existing === "string"
+        ? existing
+            .split(",")
+            .map((part) => part.trim())
+            .filter(Boolean)
+        : [];
+    if (existingParts.includes(ANTHROPIC_COMPUTER_USE_BETA)) {
+        return existingParts.join(",");
+    }
+    return [...existingParts, ANTHROPIC_COMPUTER_USE_BETA].join(",");
+}
+export function addAnthropicComputerUseToPayload(api, payload) {
+    if (api !== "anthropic-messages") {
+        return payload;
+    }
+    const state = getComputerEnableState();
+    if (!state.enabled || !state.config) {
+        return payload;
+    }
+    if (!isRecord(payload)) {
+        return payload;
+    }
+    const tools = Array.isArray(payload.tools) ? payload.tools : [];
+    const sanitizedTools = sanitizeTools(tools);
+    const hasNativeComputer = sanitizedTools.some((tool) => isComputerToolType(tool.type));
+    if (!hasNativeComputer) {
+        sanitizedTools.push({
+            type: ANTHROPIC_NATIVE_COMPUTER_TOOL_TYPE,
+            name: ANTHROPIC_NATIVE_COMPUTER_TOOL_NAME,
+            display_width_px: state.config.width,
+            display_height_px: state.config.height,
+            ...(state.config.displayNumber !== undefined ? { display_number: state.config.displayNumber } : {}),
+        });
+    }
+    const existingBetas = isRecord(payload.extra_body) ? payload.extra_body.betas : undefined;
+    const mergedBetas = Array.isArray(existingBetas)
+        ? existingBetas.includes(ANTHROPIC_COMPUTER_USE_BETA)
+            ? existingBetas
+            : [...existingBetas, ANTHROPIC_COMPUTER_USE_BETA]
+        : [ANTHROPIC_COMPUTER_USE_BETA];
+    const headers = isRecord(payload.headers) ? payload.headers : {};
+    const nextHeaders = {
+        ...headers,
+        "anthropic-beta": mergeBetaHeader(headers["anthropic-beta"]),
+    };
+    return {
+        ...payload,
+        tools: sanitizedTools,
+        headers: nextHeaders,
+        extra_body: {
+            ...(isRecord(payload.extra_body) ? payload.extra_body : {}),
+            betas: mergedBetas,
+        },
+    };
+}
+function imageResult(base64) {
+    return {
+        content: [
+            {
+                type: "image",
+                data: base64,
+                mimeType: "image/png",
+            },
+        ],
+    };
+}
+function errorResult(message) {
+    return {
+        isError: true,
+        content: [{ type: "text", text: message }],
+    };
+}
+function parseCoordinate(coordinate, action) {
+    if (!coordinate || coordinate.length !== 2) {
+        throw new Error(`${action} requires coordinate [x, y]`);
+    }
+    return [coordinate[0] ?? 0, coordinate[1] ?? 0];
+}
+function parseDuration(duration, action) {
+    if (duration === undefined || Number.isNaN(duration) || duration < 0) {
+        throw new Error(`${action} requires duration >= 0`);
+    }
+    return duration;
+}
+function parseText(text, action) {
+    if (!text) {
+        throw new Error(`${action} requires text`);
+    }
+    return text;
+}
+export async function executeComputerAction(input, ops) {
+    try {
+        switch (input.action) {
+            case "screenshot": {
+                const screenshot = await ops.screenshot();
+                return imageResult(screenshot.base64);
+            }
+            case "key": {
+                const combo = parseText(input.text ?? input.key, "key");
+                await ops.keyPress(combo);
+                break;
+            }
+            case "type": {
+                await ops.type(parseText(input.text, "type"));
+                break;
+            }
+            case "mouse_move": {
+                const [x, y] = parseCoordinate(input.coordinate, "mouse_move");
+                await ops.mouseMove(x, y);
+                break;
+            }
+            case "left_click": {
+                const coordinate = input.coordinate;
+                if (coordinate) {
+                    const [x, y] = parseCoordinate(coordinate, "left_click");
+                    await ops.click("left", x, y);
+                }
+                else {
+                    await ops.click("left");
+                }
+                break;
+            }
+            case "right_click": {
+                const coordinate = input.coordinate;
+                if (coordinate) {
+                    const [x, y] = parseCoordinate(coordinate, "right_click");
+                    await ops.click("right", x, y);
+                }
+                else {
+                    await ops.click("right");
+                }
+                break;
+            }
+            case "middle_click": {
+                const coordinate = input.coordinate;
+                if (coordinate) {
+                    const [x, y] = parseCoordinate(coordinate, "middle_click");
+                    await ops.click("middle", x, y);
+                }
+                else {
+                    await ops.click("middle");
+                }
+                break;
+            }
+            case "double_click": {
+                const coordinate = input.coordinate;
+                if (coordinate) {
+                    const [x, y] = parseCoordinate(coordinate, "double_click");
+                    await ops.doubleClick(x, y);
+                }
+                else {
+                    await ops.doubleClick();
+                }
+                break;
+            }
+            case "triple_click": {
+                const coordinate = input.coordinate;
+                if (coordinate) {
+                    const [x, y] = parseCoordinate(coordinate, "triple_click");
+                    await ops.tripleClick(x, y);
+                }
+                else {
+                    await ops.tripleClick();
+                }
+                break;
+            }
+            case "left_click_drag": {
+                const [startX, startY] = parseCoordinate(input.start_coordinate, "left_click_drag.start_coordinate");
+                const [endX, endY] = parseCoordinate(input.coordinate, "left_click_drag.coordinate");
+                await ops.drag(startX, startY, endX, endY);
+                break;
+            }
+            case "cursor_position": {
+                const position = await ops.cursorPosition();
+                return { content: [{ type: "text", text: `X=${position.x},Y=${position.y}` }] };
+            }
+            case "left_mouse_down": {
+                const coordinate = input.coordinate;
+                if (coordinate) {
+                    const [x, y] = parseCoordinate(coordinate, "left_mouse_down");
+                    await ops.mouseDown("left", x, y);
+                }
+                else {
+                    await ops.mouseDown("left");
+                }
+                break;
+            }
+            case "left_mouse_up": {
+                const coordinate = input.coordinate;
+                if (coordinate) {
+                    const [x, y] = parseCoordinate(coordinate, "left_mouse_up");
+                    await ops.mouseUp("left", x, y);
+                }
+                else {
+                    await ops.mouseUp("left");
+                }
+                break;
+            }
+            case "scroll": {
+                if (!input.scroll_direction) {
+                    throw new Error("scroll requires scroll_direction");
+                }
+                if (input.scroll_amount === undefined || input.scroll_amount <= 0) {
+                    throw new Error("scroll requires positive scroll_amount");
+                }
+                const coordinate = input.coordinate;
+                if (coordinate) {
+                    const [x, y] = parseCoordinate(coordinate, "scroll");
+                    await ops.scroll(input.scroll_direction, input.scroll_amount, x, y);
+                }
+                else {
+                    await ops.scroll(input.scroll_direction, input.scroll_amount);
+                }
+                break;
+            }
+            case "hold_key": {
+                await ops.holdKey(parseText(input.text ?? input.key, "hold_key"), parseDuration(input.duration, "hold_key"));
+                break;
+            }
+            case "wait": {
+                await ops.wait(parseDuration(input.duration, "wait"));
+                break;
+            }
+        }
+        const screenshot = await ops.screenshot();
+        return imageResult(screenshot.base64);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return errorResult(message);
+    }
+}
+async function commandExists(command) {
+    try {
+        await execFileAsync("which", [command]);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function run(command, args) {
+    const result = await execFileAsync(command, args);
+    return result.stdout;
+}
+function parseKeyComboToAppleScript(combo) {
+    const parts = combo
+        .split("+")
+        .map((part) => part.trim().toLowerCase())
+        .filter(Boolean);
+    if (parts.length === 0) {
+        throw new Error("Empty key combo");
+    }
+    const main = parts[parts.length - 1] ?? "";
+    const modifiers = new Set(parts.slice(0, -1));
+    const usingParts = [];
+    if (modifiers.has("ctrl") || modifiers.has("control"))
+        usingParts.push("control down");
+    if (modifiers.has("cmd") || modifiers.has("command"))
+        usingParts.push("command down");
+    if (modifiers.has("alt") || modifiers.has("option"))
+        usingParts.push("option down");
+    if (modifiers.has("shift"))
+        usingParts.push("shift down");
+    const targetKey = main.length === 1 ? `keystroke ${JSON.stringify(main)}` : `key code ${mapKeyCode(main)}`;
+    if (usingParts.length === 0) {
+        return `tell application "System Events" to ${targetKey}`;
+    }
+    return `tell application "System Events" to ${targetKey} using {${usingParts.join(", ")}}`;
+}
+function mapKeyCode(key) {
+    const map = { enter: 36, return: 36, tab: 48, space: 49, esc: 53, escape: 53 };
+    const code = map[key];
+    if (code === undefined) {
+        throw new Error(`Unsupported macOS special key: ${key}`);
+    }
+    return code;
+}
+export function createUnsupportedOps() {
+    const fail = async () => {
+        throw new Error("Computer use not supported on Windows");
+    };
+    return {
+        screenshot: fail,
+        cursorPosition: fail,
+        mouseMove: fail,
+        click: fail,
+        doubleClick: fail,
+        tripleClick: fail,
+        drag: fail,
+        mouseDown: fail,
+        mouseUp: fail,
+        scroll: fail,
+        keyPress: fail,
+        type: fail,
+        holdKey: fail,
+        wait: fail,
+    };
+}
+export function createMacOSComputerOps() {
+    return {
+        async screenshot() {
+            const filePath = path.join(tmpdir(), `senpi-computer-${randomUUID()}.png`);
+            try {
+                await run("screencapture", ["-x", "-t", "png", filePath]);
+                const buffer = await readFile(filePath);
+                return { base64: buffer.toString("base64") };
+            }
+            finally {
+                await rm(filePath, { force: true });
+            }
+        },
+        async cursorPosition() {
+            const output = await run("osascript", [
+                "-e",
+                'tell app "System Events" to return position of pointer as text',
+            ]);
+            const parts = output.trim().split(",");
+            const xRaw = Number.parseInt((parts[0] ?? "0").trim(), 10);
+            const yRaw = Number.parseInt((parts[1] ?? "0").trim(), 10);
+            return { x: Number.isFinite(xRaw) ? xRaw : 0, y: Number.isFinite(yRaw) ? yRaw : 0 };
+        },
+        async mouseMove(x, y) {
+            await run("cliclick", [`m:${x},${y}`]);
+        },
+        async click(button, x, y) {
+            if (x !== undefined && y !== undefined) {
+                await run("cliclick", [`m:${x},${y}`]);
+            }
+            const command = button === "left" ? "c:." : button === "right" ? "rc:." : "mc:.";
+            await run("cliclick", [command]);
+        },
+        async doubleClick(x, y) {
+            if (x !== undefined && y !== undefined) {
+                await run("cliclick", [`m:${x},${y}`]);
+            }
+            await run("cliclick", ["dc:."]);
+        },
+        async tripleClick(x, y) {
+            if (x !== undefined && y !== undefined) {
+                await run("cliclick", [`m:${x},${y}`]);
+            }
+            await run("cliclick", ["tc:."]);
+        },
+        async drag(startX, startY, endX, endY) {
+            await run("cliclick", [`dd:${startX},${startY}`, `du:${endX},${endY}`]);
+        },
+        async mouseDown(_button, x, y) {
+            if (x !== undefined && y !== undefined) {
+                await run("cliclick", [`m:${x},${y}`]);
+            }
+            await run("cliclick", ["dd:."]);
+        },
+        async mouseUp(_button, x, y) {
+            if (x !== undefined && y !== undefined) {
+                await run("cliclick", [`m:${x},${y}`]);
+            }
+            await run("cliclick", ["du:."]);
+        },
+        async scroll(direction, amount, x, y) {
+            if (x !== undefined && y !== undefined) {
+                await run("cliclick", [`m:${x},${y}`]);
+            }
+            const clicks = Math.max(1, Math.round(amount));
+            const wheel = direction === "up" ? "wd" : direction === "down" ? "wu" : direction === "left" ? "wl" : "wr";
+            await run("cliclick", [`${wheel}:${clicks}`]);
+        },
+        async keyPress(combo) {
+            await run("osascript", ["-e", parseKeyComboToAppleScript(combo)]);
+        },
+        async type(text) {
+            await run("osascript", ["-e", `tell application "System Events" to keystroke ${JSON.stringify(text)}`]);
+        },
+        async holdKey(combo, durationSec) {
+            await run("osascript", ["-e", parseKeyComboToAppleScript(combo)]);
+            await new Promise((resolve) => setTimeout(resolve, durationSec * 1000));
+        },
+        async wait(durationSec) {
+            await new Promise((resolve) => setTimeout(resolve, durationSec * 1000));
+        },
+    };
+}
+export function createLinuxComputerOps() {
+    return {
+        async screenshot() {
+            const filePath = path.join(tmpdir(), `senpi-computer-${randomUUID()}.png`);
+            try {
+                await run("scrot", [filePath]);
+                const buffer = await readFile(filePath);
+                return { base64: buffer.toString("base64") };
+            }
+            finally {
+                await rm(filePath, { force: true });
+            }
+        },
+        async cursorPosition() {
+            const output = await run("xdotool", ["getmouselocation", "--shell"]);
+            const xMatch = output.match(/^X=(\d+)$/m);
+            const yMatch = output.match(/^Y=(\d+)$/m);
+            return {
+                x: xMatch ? Number.parseInt(xMatch[1] ?? "0", 10) : 0,
+                y: yMatch ? Number.parseInt(yMatch[1] ?? "0", 10) : 0,
+            };
+        },
+        async mouseMove(x, y) {
+            await run("xdotool", ["mousemove", `${x}`, `${y}`]);
+        },
+        async click(button, x, y) {
+            if (x !== undefined && y !== undefined) {
+                await run("xdotool", ["mousemove", `${x}`, `${y}`]);
+            }
+            const buttonNumber = button === "left" ? "1" : button === "middle" ? "2" : "3";
+            await run("xdotool", ["click", buttonNumber]);
+        },
+        async doubleClick(x, y) {
+            if (x !== undefined && y !== undefined) {
+                await run("xdotool", ["mousemove", `${x}`, `${y}`]);
+            }
+            await run("xdotool", ["click", "--repeat", "2", "1"]);
+        },
+        async tripleClick(x, y) {
+            if (x !== undefined && y !== undefined) {
+                await run("xdotool", ["mousemove", `${x}`, `${y}`]);
+            }
+            await run("xdotool", ["click", "--repeat", "3", "1"]);
+        },
+        async drag(startX, startY, endX, endY) {
+            await run("xdotool", [
+                "mousemove",
+                `${startX}`,
+                `${startY}`,
+                "mousedown",
+                "1",
+                "mousemove",
+                `${endX}`,
+                `${endY}`,
+                "mouseup",
+                "1",
+            ]);
+        },
+        async mouseDown(_button, x, y) {
+            if (x !== undefined && y !== undefined) {
+                await run("xdotool", ["mousemove", `${x}`, `${y}`]);
+            }
+            await run("xdotool", ["mousedown", "1"]);
+        },
+        async mouseUp(_button, x, y) {
+            if (x !== undefined && y !== undefined) {
+                await run("xdotool", ["mousemove", `${x}`, `${y}`]);
+            }
+            await run("xdotool", ["mouseup", "1"]);
+        },
+        async scroll(direction, amount, x, y) {
+            if (x !== undefined && y !== undefined) {
+                await run("xdotool", ["mousemove", `${x}`, `${y}`]);
+            }
+            const button = direction === "up" ? "4" : direction === "down" ? "5" : direction === "left" ? "6" : "7";
+            const repeat = `${Math.max(1, Math.round(amount))}`;
+            await run("xdotool", ["click", "--repeat", repeat, button]);
+        },
+        async keyPress(combo) {
+            await run("xdotool", ["key", combo]);
+        },
+        async type(text) {
+            await run("xdotool", ["type", "--delay", "12", "--", text]);
+        },
+        async holdKey(combo, durationSec) {
+            await run("xdotool", ["keydown", combo]);
+            await new Promise((resolve) => setTimeout(resolve, durationSec * 1000));
+            await run("xdotool", ["keyup", combo]);
+        },
+        async wait(durationSec) {
+            await new Promise((resolve) => setTimeout(resolve, durationSec * 1000));
+        },
+    };
+}
+export function createComputerOps(platform = process.platform) {
+    if (platform === "darwin") {
+        return createMacOSComputerOps();
+    }
+    if (platform === "linux") {
+        return createLinuxComputerOps();
+    }
+    return createUnsupportedOps();
+}
+async function validateCliDependencies(platform) {
+    const missing = [];
+    if (platform === "darwin") {
+        if (!(await commandExists("cliclick"))) {
+            missing.push("cliclick");
+        }
+    }
+    else if (platform === "linux") {
+        if (!(await commandExists("xdotool"))) {
+            missing.push("xdotool");
+        }
+        if (!(await commandExists("scrot"))) {
+            missing.push("scrot");
+        }
+    }
+    return missing;
+}
+export const ANTHROPIC_COMPUTER_USE_SECTION = `
+## Computer Use
+
+The native computer tool is available in this session. The model can
+control the screen via screenshot, key, type, mouse actions, scroll,
+and wait commands.
+`;
+function buildComputerUseSection(width, height) {
+    return `${ANTHROPIC_COMPUTER_USE_SECTION.trimEnd()} Display dimensions: ${width}x${height}. Use computer when the user asks to interact with GUI applications.\n`;
+}
+export default function anthropicComputerUseExtension(pi) {
+    let extensionDisabledForSession = false;
+    pi.on("session_start", async (_event) => {
+        if (!enabledByEnv(process.env[ANTHROPIC_COMPUTER_USE_ENV])) {
+            extensionDisabledForSession = true;
+            return undefined;
+        }
+        if (!getComputerDisplayConfig()) {
+            extensionDisabledForSession = true;
+            console.error(`[anthropic-computer-use] ${ANTHROPIC_COMPUTER_USE_WIDTH_ENV} and ${ANTHROPIC_COMPUTER_USE_HEIGHT_ENV} must be positive integers; extension disabled for this session.`);
+            return undefined;
+        }
+        extensionDisabledForSession = false;
+        const missingTools = await validateCliDependencies(process.platform);
+        if (missingTools.length > 0) {
+            console.warn(`[anthropic-computer-use] Missing OS automation dependencies: ${missingTools.join(", ")}. Install them for full functionality.`);
+        }
+        return undefined;
+    });
+    if (enabledByEnv(process.env[ANTHROPIC_COMPUTER_USE_ENV]) && getComputerDisplayConfig()) {
+        const ops = createComputerOps();
+        pi.registerTool({
+            name: ANTHROPIC_NATIVE_COMPUTER_TOOL_NAME,
+            label: "Computer Use",
+            description: "Actions: screenshot, key, type, mouse_move, left/right/middle click, double/triple click, drag, cursor_position, mouse down/up, scroll, hold_key, wait.",
+            parameters: computerSchema,
+            async execute(_toolCallId, params) {
+                const result = await executeComputerAction(params, ops);
+                if (result.isError) {
+                    const firstContent = result.content[0];
+                    throw new Error(firstContent?.type === "text" ? firstContent.text : "Computer action failed");
+                }
+                return { content: result.content, details: undefined };
+            },
+        });
+    }
+    pi.on("before_provider_request", (event, ctx) => {
+        if (extensionDisabledForSession) {
+            return event.payload;
+        }
+        return addAnthropicComputerUseToPayload(ctx.model?.api, event.payload);
+    });
+    pi.on("before_agent_start", async (event, ctx) => {
+        if (ctx.model?.api !== "anthropic-messages") {
+            return undefined;
+        }
+        if (extensionDisabledForSession) {
+            return undefined;
+        }
+        const config = getComputerDisplayConfig();
+        if (!enabledByEnv(process.env[ANTHROPIC_COMPUTER_USE_ENV]) || !config) {
+            return undefined;
+        }
+        return {
+            systemPrompt: `${event.systemPrompt}\n${buildComputerUseSection(config.width, config.height)}`,
+        };
+    });
+}
+//# sourceMappingURL=index.js.map