ucu-mcp 0.1.2 → 0.2.0

package/dist/src/mcp/tools.js

@@ -10,7 +10,7 @@ import { SafetyGuard } from "../safety/guard.js";
 import { checkPermission } from "../safety/permissions.js";
 import { retry } from "../util/retry.js";
 import { createLogger } from "../util/logger.js";
-import { SafetyError, PermissionError, UnsupportedParameterError } from "../util/errors.js";
+import { SafetyError, PermissionError, UnsupportedParameterError, UcuError, WindowNotFoundError } from "../util/errors.js";
 const log = createLogger("tools");
 let _platform;
 function getPlatform() {
@@ -31,16 +31,89 @@ const captureAfterFields = {
 async function resolvePoint(x, y, windowId) {
     if (!windowId)
         return { x, y };
+    const win = (await getPlatform().listWindows()).find(w => w.id === windowId);
+    if (!win)
+        throw new WindowNotFoundError(windowId);
+    return { x: win.bounds.x + x, y: win.bounds.y + y };
+}
+function jsonText(value) {
+    return { type: "text", text: JSON.stringify(value, null, 2) };
+}
+function recoveryHint(code) {
+    switch (code) {
+        case "WINDOW_NOT_FOUND":
+            return "Run list_windows again, then retry with a fresh windowId or omit windowId for screen coordinates.";
+        case "ELEMENT_NOT_FOUND":
+            return "Run find_element again, then retry with a fresh elementId.";
+        case "PERMISSION_DENIED":
+            return "Run doctor and grant the missing macOS permission, then restart the launching client.";
+        case "UNSUPPORTED_PARAMETER":
+            return "Remove or replace the unsupported parameter; inspect tools/list for this tool schema.";
+        case "SAFETY_BLOCKED":
+            return "Choose a less risky action or ask the user to perform it manually.";
+        case "INPUT_FAILED":
+            return "Observe current state with screenshot or get_window_state before retrying manually.";
+        case "CAPTURE_FAILED":
+            return "Run doctor to check Screen Recording permission, then retry screenshot or ocr.";
+        case "COORDINATE_OUT_OF_BOUNDS":
+            return "Run get_screen_size or list_windows, then retry with coordinates inside the active display or window bounds.";
+        default:
+            return "Inspect the error message, observe the current UI state, and retry only if the operation is safe.";
+    }
+}
+function mcpErrorResponse(error) {
+    const err = error instanceof Error ? error : new Error(String(error));
+    const code = error instanceof UcuError ? error.code : "UNKNOWN_ERROR";
+    const retryable = error instanceof UcuError ? error.retryable : false;
+    return {
+        isError: true,
+        content: [
+            jsonText({
+                error: {
+                    name: err.name,
+                    code,
+                    retryable,
+                    message: err.message,
+                    recovery: recoveryHint(code),
+                },
+            }),
+        ],
+    };
+}
+async function actionResponse(result, captureAfter, captureFormat = "jpeg", captureMaxWidth = 1280) {
+    if (!captureAfter)
+        return { content: [jsonText(result)] };
     try {
-        const win = (await getPlatform().listWindows()).find(w => w.id === windowId);
-        if (!win)
-            return { x, y };
-        return { x: win.bounds.x + x, y: win.bounds.y + y };
+        const buf = await getPlatform().screenshot(undefined, undefined, {
+            format: captureFormat,
+            maxWidth: captureMaxWidth,
+        });
+        return {
+            content: [
+                jsonText({ actionResult: result }),
+                {
+                    type: "image",
+                    data: buf.toString("base64"),
+                    mimeType: `image/${captureFormat}`,
+                },
+            ],
+        };
     }
     catch {
-        return { x, y };
+        return { content: [jsonText(result)] };
     }
 }
+const retryableActions = new Set([
+    "screenshot",
+    "list_windows",
+    "list_apps",
+    "get_window_state",
+    "get_cursor_position",
+    "get_screen_size",
+    "ocr",
+    "doctor",
+    "find_element",
+]);
 async function withSafety(sa) {
     const platform = getPlatform();
     if (platform.isScreenLocked?.())
@@ -64,27 +137,24 @@ async function withSafety(sa) {
     if (shouldManageFocus)
         await platform.saveFocus?.();
     try {
-        return await retry(() => sa.execute());
+        return retryableActions.has(sa.action)
+            ? await retry(() => sa.execute())
+            : await sa.execute();
     }
     finally {
         if (shouldManageFocus)
             await platform.restoreFocus?.();
     }
 }
-async function appendCaptureAfter(result, captureAfter) {
-    if (!captureAfter)
-        return result;
+export function startUserActivityMonitor() {
+    if (userActivityInterval)
+        return;
     try {
-        const buf = await getPlatform().screenshot();
-        return { actionResult: result, screenshot: { type: "image", data: buf.toString("base64"), mimeType: "image/png" } };
+        lastCursorPos = getPlatform().getCursorPosition();
     }
     catch {
-        return result;
+        // Keep the default when the cursor cannot be queried during startup.
     }
-}
-export function startUserActivityMonitor() {
-    if (userActivityInterval)
-        return;
     userActivityInterval = setInterval(() => {
         try {
             const pos = getPlatform().getCursorPosition();
@@ -95,8 +165,9 @@ export function startUserActivityMonitor() {
         }
         catch { /* can't check cursor */ }
     }, 250);
+    userActivityInterval.unref?.();
 }
-function stopUserActivityMonitor() {
+export function stopUserActivityMonitor() {
     if (userActivityInterval) {
         clearInterval(userActivityInterval);
         userActivityInterval = undefined;
@@ -104,43 +175,66 @@ function stopUserActivityMonitor() {
 }
 export function registerTools(server) {
     const registry = ToolRegistry.instance;
-    server.tool("screenshot", "Capture a screenshot of the entire screen or a region", {
+    const registerTool = (name, description, schema, handler) => {
+        server.tool(name, description, schema, async (params) => {
+            try {
+                return await handler(params);
+            }
+            catch (error) {
+                return mcpErrorResponse(error);
+            }
+        });
+    };
+    registerTool("screenshot", "Capture a screenshot of the entire screen or a region", {
         display: z.number().optional().describe("Display index (default 0)"),
+        windowId: z.string().optional().describe("Window ID from list_windows; when set, captures that window"),
         region: z.object({ x: z.number(), y: z.number(), width: z.number(), height: z.number() }).optional().describe("Region to capture"),
         format: z.enum(["png", "jpeg"]).default("png").describe("Image format"),
         maxWidth: z.number().default(1280).describe("Maximum output width in pixels. Aspect ratio is preserved."),
     }, async (params) => {
-        const buf = await withSafety({ action: "screenshot", params: {}, requiresScreenRecording: true, execute: () => getPlatform().screenshot(params.display, params.region, { format: params.format }) });
+        if (params.windowId && params.region)
+            throw new UnsupportedParameterError("screenshot windowId cannot be combined with region");
+        const options = { format: params.format, maxWidth: params.maxWidth };
+        const buf = await withSafety({
+            action: "screenshot",
+            params,
+            requiresScreenRecording: true,
+            execute: () => params.windowId
+                ? getPlatform().screenshotWindow
+                    ? getPlatform().screenshotWindow(params.windowId, options)
+                    : Promise.reject(new UnsupportedParameterError("window screenshots are not implemented on this platform"))
+                : getPlatform().screenshot(params.display, params.region, options),
+        });
         return { content: [{ type: "image", data: buf.toString("base64"), mimeType: `image/${params.format}` }] };
     });
     registry.register("screenshot");
-    server.tool("list_windows", "List all visible windows on screen", {
+    registerTool("list_windows", "List all visible windows on screen", {
         includeMinimized: z.boolean().optional().describe("Include minimized windows"),
     }, async (params) => {
         const windows = await withSafety({ action: "list_windows", params: {}, requiresAccessibility: true, execute: () => getPlatform().listWindows(params.includeMinimized) });
         return { content: [{ type: "text", text: JSON.stringify(windows, null, 2) }] };
     });
     registry.register("list_windows");
-    server.tool("list_apps", "List all running applications", {}, async () => {
+    registerTool("list_apps", "List all running applications", {}, async () => {
         const apps = await withSafety({ action: "list_apps", params: {}, requiresAccessibility: true, execute: async () => getPlatform().listApps() });
         return { content: [{ type: "text", text: JSON.stringify(apps, null, 2) }] };
     });
     registry.register("list_apps");
-    server.tool("focus_app", "Bring an application to the foreground", {
+    registerTool("focus_app", "Select an application/window as the active target context", {
         app: z.string().describe("Application name to focus"),
     }, async (params) => {
         const target = await withSafety({ action: "focus_app", params: {}, requiresAccessibility: true, execute: () => getPlatform().focusApp(params.app) });
         return { content: [{ type: "text", text: JSON.stringify(target, null, 2) }] };
     });
     registry.register("focus_app");
-    server.tool("get_window_state", "Get detailed state of a window including accessibility tree", {
+    registerTool("get_window_state", "Get detailed state of a window including accessibility tree", {
         windowId: z.string().optional().describe("Window ID"), depth: z.number().optional().describe("AX tree depth"), includeBounds: z.boolean().optional().describe("Include element bounds"),
     }, async (params) => {
         const state = await withSafety({ action: "get_window_state", params: {}, requiresAccessibility: true, execute: () => getPlatform().getWindowState(params.windowId, params.depth, params.includeBounds) });
         return { content: [{ type: "text", text: JSON.stringify(state, null, 2) }] };
     });
     registry.register("get_window_state");
-    server.tool("click", "Click at screen coordinates", {
+    registerTool("click", "Click at screen coordinates", {
         x: z.number().describe("X coordinate"), y: z.number().describe("Y coordinate"),
         button: z.enum(["left", "right", "middle"]).optional().describe("Mouse button"),
         windowId: z.string().optional().describe("If set, x/y are relative to this window"),
@@ -148,10 +242,10 @@ export function registerTools(server) {
     }, async (params) => {
         const pt = await resolvePoint(params.x, params.y, params.windowId);
         await withSafety({ action: "click", params: { x: pt.x, y: pt.y }, requiresAccessibility: true, execute: () => getPlatform().click(pt.x, pt.y, params.button) });
-        return { content: [{ type: "text", text: JSON.stringify(await appendCaptureAfter({ clicked: true, x: pt.x, y: pt.y }, params.captureAfter), null, 2) }] };
+        return actionResponse({ clicked: true, x: pt.x, y: pt.y }, params.captureAfter, params.captureFormat, params.captureMaxWidth);
     });
     registry.register("click");
-    server.tool("double_click", "Double-click at screen coordinates", {
+    registerTool("double_click", "Double-click at screen coordinates", {
         x: z.number().describe("X coordinate"), y: z.number().describe("Y coordinate"),
         button: z.enum(["left", "right", "middle"]).optional().describe("Mouse button"),
         windowId: z.string().optional().describe("If set, x/y are relative to this window"),
@@ -159,10 +253,10 @@ export function registerTools(server) {
     }, async (params) => {
         const pt = await resolvePoint(params.x, params.y, params.windowId);
         await withSafety({ action: "click", params: { x: pt.x, y: pt.y, doubleClick: true }, requiresAccessibility: true, execute: () => getPlatform().click(pt.x, pt.y, params.button, true) });
-        return { content: [{ type: "text", text: JSON.stringify(await appendCaptureAfter({ doubleClicked: true, x: pt.x, y: pt.y }, params.captureAfter), null, 2) }] };
+        return actionResponse({ doubleClicked: true, x: pt.x, y: pt.y }, params.captureAfter, params.captureFormat, params.captureMaxWidth);
     });
     registry.register("double_click");
-    server.tool("type_text", "Type text at the current cursor position", {
+    registerTool("type_text", "Type text at the current cursor position", {
         text: z.string().describe("Text to type"), delay: z.number().optional().describe("Delay between keystrokes in ms"),
         windowId: z.string().optional().describe("UNSUPPORTED: windowId-targeted keyboard typing is not implemented"),
         ...captureAfterFields,
@@ -170,47 +264,55 @@ export function registerTools(server) {
         if (params.windowId)
             throw new UnsupportedParameterError("windowId-targeted keyboard typing is not implemented");
         await withSafety({ action: "type_text", params: { text: params.text }, requiresAccessibility: true, execute: () => getPlatform().type(params.text, params.delay) });
-        return { content: [{ type: "text", text: JSON.stringify(await appendCaptureAfter({ typed: true, charCount: params.text.length }, params.captureAfter), null, 2) }] };
+        return actionResponse({ typed: true, charCount: params.text.length }, params.captureAfter, params.captureFormat, params.captureMaxWidth);
     });
     registry.register("type_text");
-    server.tool("press_key", "Press a keyboard shortcut", {
+    registerTool("press_key", "Press a keyboard shortcut", {
         keys: z.array(z.string()).optional().describe("Keys to press simultaneously"),
         key: z.string().optional().describe("Single key to press (alias for keys)"),
+        modifiers: z.array(z.string()).optional().describe("Modifier keys used with key, such as cmd, shift, alt, or ctrl"),
         windowId: z.string().optional().describe("UNSUPPORTED: windowId-targeted key events are not implemented"),
         ...captureAfterFields,
     }, async (params) => {
         if (params.windowId)
             throw new UnsupportedParameterError("windowId-targeted key events are not implemented");
-        const keys = params.keys ?? (params.key ? [params.key] : []);
+        const keys = params.keys ?? [
+            ...(params.modifiers ?? []),
+            ...(params.key ? [params.key] : []),
+        ];
         if (keys.length === 0)
-            throw new Error("press_key requires at least one key");
+            throw new UnsupportedParameterError("press_key requires at least one key");
         await withSafety({ action: "press_key", params: { keys }, requiresAccessibility: true, execute: () => getPlatform().key(keys) });
-        return { content: [{ type: "text", text: JSON.stringify(await appendCaptureAfter({ pressed: true, keys: params.keys }, params.captureAfter), null, 2) }] };
+        return actionResponse({ pressed: true, keys }, params.captureAfter, params.captureFormat, params.captureMaxWidth);
     });
     registry.register("press_key");
-    server.tool("scroll", "Scroll at coordinates", {
+    registerTool("scroll", "Scroll at coordinates", {
         x: z.number().describe("X coordinate"), y: z.number().describe("Y coordinate"),
-        deltaX: z.number().describe("Horizontal scroll"), deltaY: z.number().describe("Vertical scroll (negative = up)"),
+        deltaX: z.number().default(0).describe("Horizontal scroll"), deltaY: z.number().describe("Vertical scroll (negative = up)"),
         windowId: z.string().optional().describe("If set, x/y are relative to this window"),
         ...captureAfterFields,
     }, async (params) => {
         const pt = await resolvePoint(params.x, params.y, params.windowId);
-        await withSafety({ action: "scroll", params: { x: pt.x, y: pt.y }, requiresAccessibility: true, execute: () => getPlatform().scroll(pt.x, pt.y, params.deltaX, params.deltaY) });
-        return { content: [{ type: "text", text: JSON.stringify(await appendCaptureAfter({ scrolled: true, x: pt.x, y: pt.y }, params.captureAfter), null, 2) }] };
+        const deltaX = params.deltaX ?? 0;
+        await withSafety({ action: "scroll", params: { x: pt.x, y: pt.y }, requiresAccessibility: true, execute: () => getPlatform().scroll(pt.x, pt.y, deltaX, params.deltaY) });
+        return actionResponse({ scrolled: true, x: pt.x, y: pt.y }, params.captureAfter, params.captureFormat, params.captureMaxWidth);
     });
     registry.register("scroll");
-    server.tool("drag", "Drag from one point to another", {
+    registerTool("drag", "Drag from one point to another", {
         startX: z.number().describe("Start X"), startY: z.number().describe("Start Y"),
         endX: z.number().describe("End X"), endY: z.number().describe("End Y"),
         button: z.enum(["left", "right", "middle"]).optional().describe("Mouse button"),
+        windowId: z.string().optional().describe("If set, start/end coordinates are relative to this window"),
         duration: z.number().optional().describe("Drag duration in ms"),
         ...captureAfterFields,
     }, async (params) => {
-        await withSafety({ action: "drag", params: {}, requiresAccessibility: true, execute: () => getPlatform().drag(params.startX, params.startY, params.endX, params.endY, params.button, params.duration) });
-        return { content: [{ type: "text", text: JSON.stringify(await appendCaptureAfter({ dragged: true }, params.captureAfter), null, 2) }] };
+        const start = await resolvePoint(params.startX, params.startY, params.windowId);
+        const end = await resolvePoint(params.endX, params.endY, params.windowId);
+        await withSafety({ action: "drag", params: { startX: start.x, startY: start.y, endX: end.x, endY: end.y }, requiresAccessibility: true, execute: () => getPlatform().drag(start.x, start.y, end.x, end.y, params.button, params.duration) });
+        return actionResponse({ dragged: true, startX: start.x, startY: start.y, endX: end.x, endY: end.y }, params.captureAfter, params.captureFormat, params.captureMaxWidth);
     });
     registry.register("drag");
-    server.tool("doctor", "Check system permissions and diagnose common issues", {}, async () => {
+    registerTool("doctor", "Check system permissions and diagnose common issues", {}, async () => {
         const { checkPermissions } = await import("../safety/permissions.js");
         const { MacOSPlatform: MacPlat } = await import("../platform/macos.js");
         const permissions = await checkPermissions();
@@ -236,41 +338,46 @@ export function registerTools(server) {
         return { content: [{ type: "text", text: JSON.stringify(report, null, 2) }] };
     });
     registry.register("doctor");
-    server.tool("wait", "Wait for a specified duration", { ms: z.number().describe("Duration in milliseconds") }, async (params) => {
+    registerTool("wait", "Wait for a specified duration", { ms: z.number().describe("Duration in milliseconds") }, async (params) => {
         await new Promise(r => setTimeout(r, params.ms));
         return { content: [{ type: "text", text: JSON.stringify({ waited: params.ms }) }] };
     });
     registry.register("wait");
-    server.tool("wait_for_element", "Poll until an accessibility element matching the criteria appears", {
+    registerTool("wait_for_element", "Poll until an accessibility element matching the criteria appears", {
         text: z.string().optional().describe("Element text"), role: z.string().optional().describe("Element role"),
-        app: z.string().optional().describe("Target app"), timeout: z.number().optional().describe("Timeout ms (default 5000)"), interval: z.number().optional().describe("Poll interval ms (default 500)"),
+        app: z.string().optional().describe("Target app"),
+        timeout: z.number().optional().describe("Timeout ms (default 5000)"),
+        timeoutMs: z.number().optional().describe("Alias for timeout"),
+        interval: z.number().optional().describe("Poll interval ms (default 500)"),
+        intervalMs: z.number().optional().describe("Alias for interval"),
     }, async (params) => {
-        const deadline = Date.now() + (params.timeout ?? 5000);
-        const interval = params.interval ?? 500;
+        const deadline = Date.now() + (params.timeout ?? params.timeoutMs ?? 5000);
+        const interval = params.interval ?? params.intervalMs ?? 500;
+        const query = { text: params.text, role: params.role, app: params.app, maxResults: 1 };
+        const { granted } = await checkPermission("accessibility");
+        if (!granted)
+            throw new PermissionError("accessibility", process.platform);
         while (Date.now() < deadline) {
-            try {
-                const results = await getPlatform().findElement({ text: params.text, role: params.role, app: params.app, maxResults: 1 });
-                if (results.length > 0)
-                    return { content: [{ type: "text", text: JSON.stringify({ found: true, element: results[0] }, null, 2) }] };
-            }
-            catch { /* retry */ }
+            const results = await getPlatform().findElement(query);
+            if (results.length > 0)
+                return { content: [{ type: "text", text: JSON.stringify({ found: true, element: results[0] }, null, 2) }] };
             await new Promise(r => setTimeout(r, interval));
         }
         return { content: [{ type: "text", text: JSON.stringify({ found: false, reason: "timeout" }) }] };
     });
     registry.register("wait_for_element");
-    server.tool("get_cursor_position", "Get current cursor position", {}, async () => {
+    registerTool("get_cursor_position", "Get current cursor position", {}, async () => {
         const pos = await withSafety({ action: "get_cursor_position", params: {}, execute: () => Promise.resolve(getPlatform().getCursorPosition()) });
         return { content: [{ type: "text", text: JSON.stringify(pos, null, 2) }] };
     });
     registry.register("get_cursor_position");
-    server.tool("get_screen_size", "Get screen dimensions and scale factor", {
+    registerTool("get_screen_size", "Get screen dimensions and scale factor", {
         display: z.number().optional().describe("Display index"),
     }, async (params) => {
         return { content: [{ type: "text", text: JSON.stringify(getPlatform().getScreenSize(params.display), null, 2) }] };
     });
     registry.register("get_screen_size");
-    server.tool("ocr", "Perform OCR on screen region", {
+    registerTool("ocr", "Perform OCR on screen region", {
         display: z.number().optional().describe("Display index"),
         region: z.object({ x: z.number(), y: z.number(), width: z.number(), height: z.number() }).optional().describe("Region to OCR"),
     }, async (params) => {
@@ -278,16 +385,17 @@ export function registerTools(server) {
         return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
     });
     registry.register("ocr");
-    server.tool("move", "Move cursor to coordinates", {
+    registerTool("move", "Move cursor to coordinates", {
         x: z.number().describe("X coordinate"), y: z.number().describe("Y coordinate"),
         windowId: z.string().optional().describe("If set, x/y are relative to this window"),
+        ...captureAfterFields,
     }, async (params) => {
         const pt = await resolvePoint(params.x, params.y, params.windowId);
         await withSafety({ action: "move", params: { x: pt.x, y: pt.y }, requiresAccessibility: true, execute: () => getPlatform().move(pt.x, pt.y) });
-        return { content: [{ type: "text", text: JSON.stringify({ moved: true, x: pt.x, y: pt.y }, null, 2) }] };
+        return actionResponse({ moved: true, x: pt.x, y: pt.y }, params.captureAfter, params.captureFormat, params.captureMaxWidth);
     });
     registry.register("move");
-    server.tool("find_element", "Find accessibility elements by text, role, or app", {
+    registerTool("find_element", "Find accessibility elements by text, role, or app", {
         text: z.string().optional().describe("Text to search"), role: z.string().optional().describe("AX role"), app: z.string().optional().describe("Target app"),
         depth: z.number().optional().describe("AX tree depth"), includeBounds: z.boolean().default(true).describe("Include bounds"), maxResults: z.number().min(1).max(200).default(50).describe("Max results"),
     }, async (params) => {
@@ -296,26 +404,26 @@ export function registerTools(server) {
         return { content: [{ type: "text", text: JSON.stringify(results, null, 2) }] };
     });
     registry.register("find_element");
-    server.tool("click_element", "Click an accessibility element by its ID", {
+    registerTool("click_element", "Click an accessibility element by its ID", {
         elementId: z.string().describe("AX element identifier"), app: z.string().optional().describe("Target app"), ...captureAfterFields,
     }, async (params) => {
         await withSafety({ action: "click_element", params: {}, requiresAccessibility: true, execute: () => getPlatform().clickElement(params.elementId, params.app) });
-        return { content: [{ type: "text", text: JSON.stringify(await appendCaptureAfter({ clicked: true, elementId: params.elementId }, params.captureAfter), null, 2) }] };
+        return actionResponse({ clicked: true, elementId: params.elementId }, params.captureAfter, params.captureFormat, params.captureMaxWidth);
     });
     registry.register("click_element");
-    server.tool("set_value", "Set the value of an accessibility element", {
+    registerTool("set_value", "Set the value of an accessibility element", {
         elementId: z.string().describe("AX element identifier"), value: z.string().describe("Value to set"), app: z.string().optional().describe("Target app"), ...captureAfterFields,
     }, async (params) => {
         await withSafety({ action: "set_value", params: { value: params.value }, requiresAccessibility: true, execute: () => getPlatform().setElementValue(params.elementId, params.value, params.app) });
-        return { content: [{ type: "text", text: JSON.stringify(await appendCaptureAfter({ setValue: true, elementId: params.elementId }, params.captureAfter), null, 2) }] };
+        return actionResponse({ setValue: true, elementId: params.elementId }, params.captureAfter, params.captureFormat, params.captureMaxWidth);
     });
     registry.register("set_value");
-    server.tool("type_in_element", "Type text into an accessibility element, optionally clearing first", {
+    registerTool("type_in_element", "Type text into an accessibility element, optionally clearing first", {
         elementId: z.string().describe("AX element identifier"), text: z.string().describe("Text to type"),
         app: z.string().optional().describe("Target app"), clearFirst: z.boolean().optional().describe("Clear existing text before typing"), ...captureAfterFields,
     }, async (params) => {
         await withSafety({ action: "type_in_element", params: { text: params.text }, requiresAccessibility: true, execute: () => getPlatform().typeInElement(params.elementId, params.text, params.app, params.clearFirst) });
-        return { content: [{ type: "text", text: JSON.stringify(await appendCaptureAfter({ typed: true, elementId: params.elementId, charCount: params.text.length }, params.captureAfter), null, 2) }] };
+        return actionResponse({ typed: true, elementId: params.elementId, charCount: params.text.length }, params.captureAfter, params.captureFormat, params.captureMaxWidth);
     });
     registry.register("type_in_element");
     log.info("Registered tools", { count: registry.tools.length, tools: registry.tools.join(", ") });

package/dist/src/platform/macos.d.ts

@@ -3,6 +3,8 @@ export declare class MacOSPlatform implements Platform {
     private readonly elementCache;
     private readonly elementCacheTtlMs;
     private readonly elementCacheMaxSize;
+    private readonly windowCacheTtlMs;
+    private windowCache;
     private activeTarget;
     private savedFocus;
     /** Remove expired entries from the element cache. */
@@ -30,6 +32,8 @@ export declare class MacOSPlatform implements Platform {
     scroll(x: number, y: number, deltaX: number, deltaY: number): Promise<void>;
     getCursorPosition(): CursorPosition;
     ocr(display?: number, region?: ScreenRegion): Promise<OcrResult>;
+    private ocrNative;
+    private ocrJxa;
     type(text: string, delay?: number): Promise<void>;
     key(keys: string[]): Promise<void>;
     findElement(options: FindElementOptions): Promise<FindElementResult[]>;