@trycua/cua-driver 0.11.0 → 0.12.2

package/dist/native/cua_driver_sdk.js

@@ -118,6 +118,37 @@ const FfiConverterTypeDriverMetadata = (() => {
     ;
     return new FFIConverter();
 })();
+/**
+ * Generated factory for {@link DriverOptions} record objects.
+ */
+export const DriverOptions = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeDriverOptions = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                claudeCodeCompatibility: FfiConverterBool.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterBool.write(value.claudeCodeCompatibility, into);
+        }
+        allocationSize(value) {
+            return FfiConverterBool.allocationSize(value.claudeCodeCompatibility);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
 /**
  * Generated factory for {@link EmbeddedEnvironmentVariable} record objects.
  */
@@ -494,6 +525,7 @@ export var DriverError_Tags;
     DriverError_Tags["Transport"] = "Transport";
     DriverError_Tags["Protocol"] = "Protocol";
     DriverError_Tags["Tool"] = "Tool";
+    DriverError_Tags["Shutdown"] = "Shutdown";
 })(DriverError_Tags || (DriverError_Tags = {}));
 export const DriverError = (() => {
     class Configuration_ extends UniffiError {
@@ -621,6 +653,26 @@ export const DriverError = (() => {
             return obj.inner;
         }
     }
+    class Shutdown_ extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "DriverError";
+        tag = DriverError_Tags.Shutdown;
+        constructor() {
+            super("DriverError", "Shutdown");
+        }
+        static new() {
+            return new Shutdown_();
+        }
+        static instanceOf(obj) {
+            return obj.tag === DriverError_Tags.Shutdown;
+        }
+        static hasInner(obj) {
+            return false;
+        }
+    }
     function instanceOf(obj) {
         return obj[uniffiTypeNameSymbol] === "DriverError";
     }
@@ -630,7 +682,8 @@ export const DriverError = (() => {
         InvalidArguments: InvalidArguments_,
         Transport: Transport_,
         Protocol: Protocol_,
-        Tool: Tool_
+        Tool: Tool_,
+        Shutdown: Shutdown_
     });
 })();
 // FfiConverter for enum DriverError
@@ -644,6 +697,7 @@ const FfiConverterTypeDriverError = (() => {
                 case 3: return new DriverError.Transport({ socketPath: FfiConverterString.read(from), reason: FfiConverterString.read(from) });
                 case 4: return new DriverError.Protocol({ reason: FfiConverterString.read(from) });
                 case 5: return new DriverError.Tool({ tool: FfiConverterString.read(from), message: FfiConverterString.read(from), errorCode: FfiConverterString.read(from) });
+                case 6: return new DriverError.Shutdown();
                 default: throw new UniffiInternalError.UnexpectedEnumCase();
             }
         }
@@ -683,6 +737,10 @@ const FfiConverterTypeDriverError = (() => {
                     FfiConverterString.write(inner.errorCode, into);
                     return;
                 }
+                case DriverError_Tags.Shutdown: {
+                    ordinalConverter.write(6, into);
+                    return;
+                }
                 default:
                     // Throwing from here means that DriverError_Tags hasn't matched an ordinal.
                     throw new UniffiInternalError.UnexpectedEnumCase();
@@ -724,9 +782,42 @@ const FfiConverterTypeDriverError = (() => {
                     size += FfiConverterString.allocationSize(inner.errorCode);
                     return size;
                 }
+                case DriverError_Tags.Shutdown: {
+                    return ordinalConverter.allocationSize(6);
+                }
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+    }
+    return new FFIConverter();
+})();
+/**
+ * Process topology used by this SDK object.
+ */
+export var DriverExecutionMode;
+(function (DriverExecutionMode) {
+    DriverExecutionMode[DriverExecutionMode["Embedded"] = 0] = "Embedded";
+    DriverExecutionMode[DriverExecutionMode["Daemon"] = 1] = "Daemon";
+})(DriverExecutionMode || (DriverExecutionMode = {}));
+const FfiConverterTypeDriverExecutionMode = (() => {
+    const ordinalConverter = FfiConverterInt32;
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            switch (ordinalConverter.read(from)) {
+                case 1: return DriverExecutionMode.Embedded;
+                case 2: return DriverExecutionMode.Daemon;
                 default: throw new UniffiInternalError.UnexpectedEnumCase();
             }
         }
+        write(value, into) {
+            switch (value) {
+                case DriverExecutionMode.Embedded: return ordinalConverter.write(1, into);
+                case DriverExecutionMode.Daemon: return ordinalConverter.write(2, into);
+            }
+        }
+        allocationSize(value) {
+            return ordinalConverter.allocationSize(0);
+        }
     }
     return new FFIConverter();
 })();
@@ -1113,6 +1204,38 @@ const FfiConverterTypeEmbeddedDriverHostState = (() => {
     }
     return new FFIConverter();
 })();
+/**
+ * Runtime that imported the shared UniFFI SDK library. The language package
+ * selects this automatically at its root entry point; callers do not need to
+ * supply telemetry metadata.
+ */
+export var SdkClientKind;
+(function (SdkClientKind) {
+    SdkClientKind[SdkClientKind["Python"] = 0] = "Python";
+    SdkClientKind[SdkClientKind["Typescript"] = 1] = "Typescript";
+})(SdkClientKind || (SdkClientKind = {}));
+const FfiConverterTypeSdkClientKind = (() => {
+    const ordinalConverter = FfiConverterInt32;
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            switch (ordinalConverter.read(from)) {
+                case 1: return SdkClientKind.Python;
+                case 2: return SdkClientKind.Typescript;
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        write(value, into) {
+            switch (value) {
+                case SdkClientKind.Python: return ordinalConverter.write(1, into);
+                case SdkClientKind.Typescript: return ordinalConverter.write(2, into);
+            }
+        }
+        allocationSize(value) {
+            return ordinalConverter.allocationSize(0);
+        }
+    }
+    return new FFIConverter();
+})();
 export class CuaDriver extends UniffiAbstractObject {
     [uniffiTypeNameSymbol] = "CuaDriver";
     [destructorGuardSymbol];
@@ -1125,7 +1248,7 @@ export class CuaDriver extends UniffiAbstractObject {
     }
     /**
      * Connect to the default installed daemon or an explicitly selected socket.
-     * Construction does not launch a process or perform I/O.
+     * This is the temporary compatibility path for released socket clients.
      */
     static connect(socketPath) {
         return FfiConverterTypeCuaDriver.lift(uniffiCaller.rustCallWithError(
@@ -1136,158 +1259,349 @@ export class CuaDriver extends UniffiAbstractObject {
         /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
     }
     /**
-     * Escape hatch for forward-compatible tools and application-owned server
-     * adapters. Typed methods below serialize the same canonical Rust inputs.
+     * Language-package entry point that preserves the public `connect` API
+     * while attaching a closed runtime category to daemon requests.
      */
-    callTool(name, argumentsJson) {
-        return ((__rb) => {
-            try {
-                return FfiConverterTypeToolResult.lift(__rb);
-            }
-            finally {
-                nativeModule().rustbuffer_free(__rb);
-            }
-        })(uniffiCaller.rustCallWithError(
+    static connectWithClientKind(socketPath, clientKind) {
+        return FfiConverterTypeCuaDriver.lift(uniffiCaller.rustCallWithError(
         /*liftError:*/ FfiConverterTypeDriverError.lift.bind(FfiConverterTypeDriverError), 
         /*caller:*/ (callStatus) => {
-            return nativeModule().uniffi_cua_driver_sdk_fn_method_cuadriver_call_tool(uniffiTypeCuaDriverObjectFactory.clonePointer(this), FfiConverterString.lower(name, nativeModule().rustbuffer_alloc), FfiConverterString.lower(argumentsJson, nativeModule().rustbuffer_alloc), callStatus);
+            return nativeModule().uniffi_cua_driver_sdk_fn_constructor_cuadriver_connect_with_client_kind(FfiConverterOptionalString.lower(socketPath, nativeModule().rustbuffer_alloc), FfiConverterTypeSdkClientKind.lower(clientKind, nativeModule().rustbuffer_alloc), callStatus);
         }, 
         /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
     }
-    click(input) {
-        return ((__rb) => {
-            try {
-                return FfiConverterTypeToolResult.lift(__rb);
-            }
-            finally {
-                nativeModule().rustbuffer_free(__rb);
-            }
-        })(uniffiCaller.rustCallWithError(
+    /**
+     * Create a same-process driver runtime. This constructor never launches
+     * `cua-driver` and never opens daemon IPC.
+     */
+    static create(options) {
+        return FfiConverterTypeCuaDriver.lift(uniffiCaller.rustCallWithError(
         /*liftError:*/ FfiConverterTypeDriverError.lift.bind(FfiConverterTypeDriverError), 
         /*caller:*/ (callStatus) => {
-            return nativeModule().uniffi_cua_driver_sdk_fn_method_cuadriver_click(uniffiTypeCuaDriverObjectFactory.clonePointer(this), FfiConverterTypeClickInput.lower(input, nativeModule().rustbuffer_alloc), callStatus);
+            return nativeModule().uniffi_cua_driver_sdk_fn_constructor_cuadriver_create(FfiConverterOptionalTypeDriverOptions.lower(options, nativeModule().rustbuffer_alloc), callStatus);
         }, 
         /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
     }
-    drag(input) {
-        return ((__rb) => {
-            try {
-                return FfiConverterTypeToolResult.lift(__rb);
-            }
-            finally {
-                nativeModule().rustbuffer_free(__rb);
-            }
-        })(uniffiCaller.rustCallWithError(
+    /**
+     * Language-package entry point for the same-process runtime. The wrapper
+     * at each package root selects the client kind automatically.
+     */
+    static createWithClientKind(options, clientKind) {
+        return FfiConverterTypeCuaDriver.lift(uniffiCaller.rustCallWithError(
         /*liftError:*/ FfiConverterTypeDriverError.lift.bind(FfiConverterTypeDriverError), 
         /*caller:*/ (callStatus) => {
-            return nativeModule().uniffi_cua_driver_sdk_fn_method_cuadriver_drag(uniffiTypeCuaDriverObjectFactory.clonePointer(this), FfiConverterTypeDragInput.lower(input, nativeModule().rustbuffer_alloc), callStatus);
+            return nativeModule().uniffi_cua_driver_sdk_fn_constructor_cuadriver_create_with_client_kind(FfiConverterOptionalTypeDriverOptions.lower(options, nativeModule().rustbuffer_alloc), FfiConverterTypeSdkClientKind.lower(clientKind, nativeModule().rustbuffer_alloc), callStatus);
         }, 
         /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
     }
-    endSession(input) {
-        return ((__rb) => {
-            try {
-                return FfiConverterTypeEndSessionOutput.lift(__rb);
-            }
-            finally {
-                nativeModule().rustbuffer_free(__rb);
+    /**
+     * Generic protocol-adapter surface. Ordinary applications should prefer
+     * typed methods; MCP and other open-ended adapters use this method so they
+     * remain downstream of the same public SDK runtime.
+     */
+    async callTool(name, argumentsJson, asyncOpts_) {
+        const __stack = uniffiIsDebug ? new Error().stack : undefined;
+        try {
+            return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller, 
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().uniffi_cua_driver_sdk_fn_method_cuadriver_call_tool(uniffiTypeCuaDriverObjectFactory.clonePointer(this), FfiConverterString.lower(name, nativeModule().rustbuffer_alloc), FfiConverterString.lower(argumentsJson, nativeModule().rustbuffer_alloc));
+            }, 
+            /*pollFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_poll_rust_buffer, 
+            /*cancelFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_cancel_rust_buffer, 
+            /*completeFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_complete_rust_buffer, 
+            /*freeFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_free_rust_buffer, 
+            // Async returns always go through the JS-side converter: the
+            // FFI symbol returns the future handle (u64), and the user-level
+            // RustBuffer comes back via the shared `rust_future_complete_*`
+            // export. The bytes the runtime hands back must be deserialized
+            // here using the per-callable return-type converter.
+            /*liftFunc:*/ FfiConverterTypeToolResult.lift.bind(FfiConverterTypeToolResult), 
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString), 
+            /*asyncOpts:*/ asyncOpts_, 
+            /*errorHandler:*/ FfiConverterTypeDriverError.lift.bind(FfiConverterTypeDriverError));
+        }
+        catch (__error) {
+            if (uniffiIsDebug && __error instanceof Error) {
+                __error.stack = __stack;
             }
-        })(uniffiCaller.rustCallWithError(
-        /*liftError:*/ FfiConverterTypeDriverError.lift.bind(FfiConverterTypeDriverError), 
-        /*caller:*/ (callStatus) => {
-            return nativeModule().uniffi_cua_driver_sdk_fn_method_cuadriver_end_session(uniffiTypeCuaDriverObjectFactory.clonePointer(this), FfiConverterTypeEndSessionInput.lower(input, nativeModule().rustbuffer_alloc), callStatus);
-        }, 
-        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+            throw __error;
+        }
     }
-    escalateSession(input) {
-        return ((__rb) => {
-            try {
-                return FfiConverterTypeSessionStateOutput.lift(__rb);
+    async click(input, asyncOpts_) {
+        const __stack = uniffiIsDebug ? new Error().stack : undefined;
+        try {
+            return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller, 
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().uniffi_cua_driver_sdk_fn_method_cuadriver_click(uniffiTypeCuaDriverObjectFactory.clonePointer(this), FfiConverterTypeClickInput.lower(input, nativeModule().rustbuffer_alloc));
+            }, 
+            /*pollFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_poll_rust_buffer, 
+            /*cancelFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_cancel_rust_buffer, 
+            /*completeFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_complete_rust_buffer, 
+            /*freeFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_free_rust_buffer, 
+            // Async returns always go through the JS-side converter: the
+            // FFI symbol returns the future handle (u64), and the user-level
+            // RustBuffer comes back via the shared `rust_future_complete_*`
+            // export. The bytes the runtime hands back must be deserialized
+            // here using the per-callable return-type converter.
+            /*liftFunc:*/ FfiConverterTypeToolResult.lift.bind(FfiConverterTypeToolResult), 
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString), 
+            /*asyncOpts:*/ asyncOpts_, 
+            /*errorHandler:*/ FfiConverterTypeDriverError.lift.bind(FfiConverterTypeDriverError));
+        }
+        catch (__error) {
+            if (uniffiIsDebug && __error instanceof Error) {
+                __error.stack = __stack;
             }
-            finally {
-                nativeModule().rustbuffer_free(__rb);
+            throw __error;
+        }
+    }
+    async drag(input, asyncOpts_) {
+        const __stack = uniffiIsDebug ? new Error().stack : undefined;
+        try {
+            return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller, 
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().uniffi_cua_driver_sdk_fn_method_cuadriver_drag(uniffiTypeCuaDriverObjectFactory.clonePointer(this), FfiConverterTypeDragInput.lower(input, nativeModule().rustbuffer_alloc));
+            }, 
+            /*pollFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_poll_rust_buffer, 
+            /*cancelFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_cancel_rust_buffer, 
+            /*completeFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_complete_rust_buffer, 
+            /*freeFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_free_rust_buffer, 
+            // Async returns always go through the JS-side converter: the
+            // FFI symbol returns the future handle (u64), and the user-level
+            // RustBuffer comes back via the shared `rust_future_complete_*`
+            // export. The bytes the runtime hands back must be deserialized
+            // here using the per-callable return-type converter.
+            /*liftFunc:*/ FfiConverterTypeToolResult.lift.bind(FfiConverterTypeToolResult), 
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString), 
+            /*asyncOpts:*/ asyncOpts_, 
+            /*errorHandler:*/ FfiConverterTypeDriverError.lift.bind(FfiConverterTypeDriverError));
+        }
+        catch (__error) {
+            if (uniffiIsDebug && __error instanceof Error) {
+                __error.stack = __stack;
             }
-        })(uniffiCaller.rustCallWithError(
-        /*liftError:*/ FfiConverterTypeDriverError.lift.bind(FfiConverterTypeDriverError), 
-        /*caller:*/ (callStatus) => {
-            return nativeModule().uniffi_cua_driver_sdk_fn_method_cuadriver_escalate_session(uniffiTypeCuaDriverObjectFactory.clonePointer(this), FfiConverterTypeEscalateSessionInput.lower(input, nativeModule().rustbuffer_alloc), callStatus);
-        }, 
-        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+            throw __error;
+        }
     }
-    getCursorPosition(input) {
-        return ((__rb) => {
-            try {
-                return FfiConverterTypeToolResult.lift(__rb);
+    async endSession(input, asyncOpts_) {
+        const __stack = uniffiIsDebug ? new Error().stack : undefined;
+        try {
+            return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller, 
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().uniffi_cua_driver_sdk_fn_method_cuadriver_end_session(uniffiTypeCuaDriverObjectFactory.clonePointer(this), FfiConverterTypeEndSessionInput.lower(input, nativeModule().rustbuffer_alloc));
+            }, 
+            /*pollFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_poll_rust_buffer, 
+            /*cancelFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_cancel_rust_buffer, 
+            /*completeFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_complete_rust_buffer, 
+            /*freeFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_free_rust_buffer, 
+            // Async returns always go through the JS-side converter: the
+            // FFI symbol returns the future handle (u64), and the user-level
+            // RustBuffer comes back via the shared `rust_future_complete_*`
+            // export. The bytes the runtime hands back must be deserialized
+            // here using the per-callable return-type converter.
+            /*liftFunc:*/ FfiConverterTypeEndSessionOutput.lift.bind(FfiConverterTypeEndSessionOutput), 
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString), 
+            /*asyncOpts:*/ asyncOpts_, 
+            /*errorHandler:*/ FfiConverterTypeDriverError.lift.bind(FfiConverterTypeDriverError));
+        }
+        catch (__error) {
+            if (uniffiIsDebug && __error instanceof Error) {
+                __error.stack = __stack;
             }
-            finally {
-                nativeModule().rustbuffer_free(__rb);
+            throw __error;
+        }
+    }
+    async escalateSession(input, asyncOpts_) {
+        const __stack = uniffiIsDebug ? new Error().stack : undefined;
+        try {
+            return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller, 
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().uniffi_cua_driver_sdk_fn_method_cuadriver_escalate_session(uniffiTypeCuaDriverObjectFactory.clonePointer(this), FfiConverterTypeEscalateSessionInput.lower(input, nativeModule().rustbuffer_alloc));
+            }, 
+            /*pollFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_poll_rust_buffer, 
+            /*cancelFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_cancel_rust_buffer, 
+            /*completeFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_complete_rust_buffer, 
+            /*freeFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_free_rust_buffer, 
+            // Async returns always go through the JS-side converter: the
+            // FFI symbol returns the future handle (u64), and the user-level
+            // RustBuffer comes back via the shared `rust_future_complete_*`
+            // export. The bytes the runtime hands back must be deserialized
+            // here using the per-callable return-type converter.
+            /*liftFunc:*/ FfiConverterTypeSessionStateOutput.lift.bind(FfiConverterTypeSessionStateOutput), 
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString), 
+            /*asyncOpts:*/ asyncOpts_, 
+            /*errorHandler:*/ FfiConverterTypeDriverError.lift.bind(FfiConverterTypeDriverError));
+        }
+        catch (__error) {
+            if (uniffiIsDebug && __error instanceof Error) {
+                __error.stack = __stack;
             }
-        })(uniffiCaller.rustCallWithError(
-        /*liftError:*/ FfiConverterTypeDriverError.lift.bind(FfiConverterTypeDriverError), 
-        /*caller:*/ (callStatus) => {
-            return nativeModule().uniffi_cua_driver_sdk_fn_method_cuadriver_get_cursor_position(uniffiTypeCuaDriverObjectFactory.clonePointer(this), FfiConverterTypeGetCursorPositionInput.lower(input, nativeModule().rustbuffer_alloc), callStatus);
-        }, 
-        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+            throw __error;
+        }
     }
-    getDesktopState(input) {
+    executionMode() {
         return ((__rb) => {
             try {
-                return FfiConverterTypeToolResult.lift(__rb);
+                return FfiConverterTypeDriverExecutionMode.lift(__rb);
             }
             finally {
                 nativeModule().rustbuffer_free(__rb);
             }
-        })(uniffiCaller.rustCallWithError(
-        /*liftError:*/ FfiConverterTypeDriverError.lift.bind(FfiConverterTypeDriverError), 
+        })(uniffiCaller.rustCall(
         /*caller:*/ (callStatus) => {
-            return nativeModule().uniffi_cua_driver_sdk_fn_method_cuadriver_get_desktop_state(uniffiTypeCuaDriverObjectFactory.clonePointer(this), FfiConverterTypeGetDesktopStateInput.lower(input, nativeModule().rustbuffer_alloc), callStatus);
+            return nativeModule().uniffi_cua_driver_sdk_fn_method_cuadriver_execution_mode(uniffiTypeCuaDriverObjectFactory.clonePointer(this), callStatus);
         }, 
         /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
     }
-    getScreenSize(input) {
-        return ((__rb) => {
-            try {
-                return FfiConverterTypeToolResult.lift(__rb);
-            }
-            finally {
-                nativeModule().rustbuffer_free(__rb);
+    async getCursorPosition(input, asyncOpts_) {
+        const __stack = uniffiIsDebug ? new Error().stack : undefined;
+        try {
+            return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller, 
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().uniffi_cua_driver_sdk_fn_method_cuadriver_get_cursor_position(uniffiTypeCuaDriverObjectFactory.clonePointer(this), FfiConverterTypeGetCursorPositionInput.lower(input, nativeModule().rustbuffer_alloc));
+            }, 
+            /*pollFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_poll_rust_buffer, 
+            /*cancelFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_cancel_rust_buffer, 
+            /*completeFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_complete_rust_buffer, 
+            /*freeFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_free_rust_buffer, 
+            // Async returns always go through the JS-side converter: the
+            // FFI symbol returns the future handle (u64), and the user-level
+            // RustBuffer comes back via the shared `rust_future_complete_*`
+            // export. The bytes the runtime hands back must be deserialized
+            // here using the per-callable return-type converter.
+            /*liftFunc:*/ FfiConverterTypeToolResult.lift.bind(FfiConverterTypeToolResult), 
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString), 
+            /*asyncOpts:*/ asyncOpts_, 
+            /*errorHandler:*/ FfiConverterTypeDriverError.lift.bind(FfiConverterTypeDriverError));
+        }
+        catch (__error) {
+            if (uniffiIsDebug && __error instanceof Error) {
+                __error.stack = __stack;
             }
-        })(uniffiCaller.rustCallWithError(
-        /*liftError:*/ FfiConverterTypeDriverError.lift.bind(FfiConverterTypeDriverError), 
-        /*caller:*/ (callStatus) => {
-            return nativeModule().uniffi_cua_driver_sdk_fn_method_cuadriver_get_screen_size(uniffiTypeCuaDriverObjectFactory.clonePointer(this), FfiConverterTypeGetScreenSizeInput.lower(input, nativeModule().rustbuffer_alloc), callStatus);
-        }, 
-        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+            throw __error;
+        }
     }
-    getSessionState(input) {
-        return ((__rb) => {
-            try {
-                return FfiConverterTypeSessionStateOutput.lift(__rb);
+    async getDesktopState(input, asyncOpts_) {
+        const __stack = uniffiIsDebug ? new Error().stack : undefined;
+        try {
+            return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller, 
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().uniffi_cua_driver_sdk_fn_method_cuadriver_get_desktop_state(uniffiTypeCuaDriverObjectFactory.clonePointer(this), FfiConverterTypeGetDesktopStateInput.lower(input, nativeModule().rustbuffer_alloc));
+            }, 
+            /*pollFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_poll_rust_buffer, 
+            /*cancelFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_cancel_rust_buffer, 
+            /*completeFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_complete_rust_buffer, 
+            /*freeFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_free_rust_buffer, 
+            // Async returns always go through the JS-side converter: the
+            // FFI symbol returns the future handle (u64), and the user-level
+            // RustBuffer comes back via the shared `rust_future_complete_*`
+            // export. The bytes the runtime hands back must be deserialized
+            // here using the per-callable return-type converter.
+            /*liftFunc:*/ FfiConverterTypeToolResult.lift.bind(FfiConverterTypeToolResult), 
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString), 
+            /*asyncOpts:*/ asyncOpts_, 
+            /*errorHandler:*/ FfiConverterTypeDriverError.lift.bind(FfiConverterTypeDriverError));
+        }
+        catch (__error) {
+            if (uniffiIsDebug && __error instanceof Error) {
+                __error.stack = __stack;
             }
-            finally {
-                nativeModule().rustbuffer_free(__rb);
+            throw __error;
+        }
+    }
+    async getScreenSize(input, asyncOpts_) {
+        const __stack = uniffiIsDebug ? new Error().stack : undefined;
+        try {
+            return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller, 
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().uniffi_cua_driver_sdk_fn_method_cuadriver_get_screen_size(uniffiTypeCuaDriverObjectFactory.clonePointer(this), FfiConverterTypeGetScreenSizeInput.lower(input, nativeModule().rustbuffer_alloc));
+            }, 
+            /*pollFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_poll_rust_buffer, 
+            /*cancelFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_cancel_rust_buffer, 
+            /*completeFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_complete_rust_buffer, 
+            /*freeFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_free_rust_buffer, 
+            // Async returns always go through the JS-side converter: the
+            // FFI symbol returns the future handle (u64), and the user-level
+            // RustBuffer comes back via the shared `rust_future_complete_*`
+            // export. The bytes the runtime hands back must be deserialized
+            // here using the per-callable return-type converter.
+            /*liftFunc:*/ FfiConverterTypeToolResult.lift.bind(FfiConverterTypeToolResult), 
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString), 
+            /*asyncOpts:*/ asyncOpts_, 
+            /*errorHandler:*/ FfiConverterTypeDriverError.lift.bind(FfiConverterTypeDriverError));
+        }
+        catch (__error) {
+            if (uniffiIsDebug && __error instanceof Error) {
+                __error.stack = __stack;
             }
-        })(uniffiCaller.rustCallWithError(
-        /*liftError:*/ FfiConverterTypeDriverError.lift.bind(FfiConverterTypeDriverError), 
-        /*caller:*/ (callStatus) => {
-            return nativeModule().uniffi_cua_driver_sdk_fn_method_cuadriver_get_session_state(uniffiTypeCuaDriverObjectFactory.clonePointer(this), FfiConverterTypeGetSessionStateInput.lower(input, nativeModule().rustbuffer_alloc), callStatus);
-        }, 
-        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+            throw __error;
+        }
     }
-    hotkey(input) {
-        return ((__rb) => {
-            try {
-                return FfiConverterTypeToolResult.lift(__rb);
+    async getSessionState(input, asyncOpts_) {
+        const __stack = uniffiIsDebug ? new Error().stack : undefined;
+        try {
+            return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller, 
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().uniffi_cua_driver_sdk_fn_method_cuadriver_get_session_state(uniffiTypeCuaDriverObjectFactory.clonePointer(this), FfiConverterTypeGetSessionStateInput.lower(input, nativeModule().rustbuffer_alloc));
+            }, 
+            /*pollFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_poll_rust_buffer, 
+            /*cancelFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_cancel_rust_buffer, 
+            /*completeFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_complete_rust_buffer, 
+            /*freeFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_free_rust_buffer, 
+            // Async returns always go through the JS-side converter: the
+            // FFI symbol returns the future handle (u64), and the user-level
+            // RustBuffer comes back via the shared `rust_future_complete_*`
+            // export. The bytes the runtime hands back must be deserialized
+            // here using the per-callable return-type converter.
+            /*liftFunc:*/ FfiConverterTypeSessionStateOutput.lift.bind(FfiConverterTypeSessionStateOutput), 
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString), 
+            /*asyncOpts:*/ asyncOpts_, 
+            /*errorHandler:*/ FfiConverterTypeDriverError.lift.bind(FfiConverterTypeDriverError));
+        }
+        catch (__error) {
+            if (uniffiIsDebug && __error instanceof Error) {
+                __error.stack = __stack;
             }
-            finally {
-                nativeModule().rustbuffer_free(__rb);
+            throw __error;
+        }
+    }
+    async hotkey(input, asyncOpts_) {
+        const __stack = uniffiIsDebug ? new Error().stack : undefined;
+        try {
+            return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller, 
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().uniffi_cua_driver_sdk_fn_method_cuadriver_hotkey(uniffiTypeCuaDriverObjectFactory.clonePointer(this), FfiConverterTypeHotkeyInput.lower(input, nativeModule().rustbuffer_alloc));
+            }, 
+            /*pollFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_poll_rust_buffer, 
+            /*cancelFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_cancel_rust_buffer, 
+            /*completeFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_complete_rust_buffer, 
+            /*freeFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_free_rust_buffer, 
+            // Async returns always go through the JS-side converter: the
+            // FFI symbol returns the future handle (u64), and the user-level
+            // RustBuffer comes back via the shared `rust_future_complete_*`
+            // export. The bytes the runtime hands back must be deserialized
+            // here using the per-callable return-type converter.
+            /*liftFunc:*/ FfiConverterTypeToolResult.lift.bind(FfiConverterTypeToolResult), 
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString), 
+            /*asyncOpts:*/ asyncOpts_, 
+            /*errorHandler:*/ FfiConverterTypeDriverError.lift.bind(FfiConverterTypeDriverError));
+        }
+        catch (__error) {
+            if (uniffiIsDebug && __error instanceof Error) {
+                __error.stack = __stack;
             }
-        })(uniffiCaller.rustCallWithError(
-        /*liftError:*/ FfiConverterTypeDriverError.lift.bind(FfiConverterTypeDriverError), 
-        /*caller:*/ (callStatus) => {
-            return nativeModule().uniffi_cua_driver_sdk_fn_method_cuadriver_hotkey(uniffiTypeCuaDriverObjectFactory.clonePointer(this), FfiConverterTypeHotkeyInput.lower(input, nativeModule().rustbuffer_alloc), callStatus);
-        }, 
-        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+            throw __error;
+        }
     }
     isAvailable() {
         return FfiConverterBool.lift(uniffiCaller.rustCall(
@@ -1296,81 +1610,186 @@ export class CuaDriver extends UniffiAbstractObject {
         }, 
         /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
     }
-    listToolsJson() {
-        return ((__rb) => {
-            try {
-                return FfiConverterString.lift(__rb);
-            }
-            finally {
-                nativeModule().rustbuffer_free(__rb);
+    /**
+     * Canonical tool inventory for MCP and other protocol adapters.
+     */
+    async listToolsJson(asyncOpts_) {
+        const __stack = uniffiIsDebug ? new Error().stack : undefined;
+        try {
+            return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller, 
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().uniffi_cua_driver_sdk_fn_method_cuadriver_list_tools_json(uniffiTypeCuaDriverObjectFactory.clonePointer(this));
+            }, 
+            /*pollFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_poll_rust_buffer, 
+            /*cancelFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_cancel_rust_buffer, 
+            /*completeFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_complete_rust_buffer, 
+            /*freeFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_free_rust_buffer, 
+            // Async returns always go through the JS-side converter: the
+            // FFI symbol returns the future handle (u64), and the user-level
+            // RustBuffer comes back via the shared `rust_future_complete_*`
+            // export. The bytes the runtime hands back must be deserialized
+            // here using the per-callable return-type converter.
+            /*liftFunc:*/ FfiConverterString.lift.bind(FfiConverterString), 
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString), 
+            /*asyncOpts:*/ asyncOpts_, 
+            /*errorHandler:*/ FfiConverterTypeDriverError.lift.bind(FfiConverterTypeDriverError));
+        }
+        catch (__error) {
+            if (uniffiIsDebug && __error instanceof Error) {
+                __error.stack = __stack;
             }
-        })(uniffiCaller.rustCallWithError(
-        /*liftError:*/ FfiConverterTypeDriverError.lift.bind(FfiConverterTypeDriverError), 
-        /*caller:*/ (callStatus) => {
-            return nativeModule().uniffi_cua_driver_sdk_fn_method_cuadriver_list_tools_json(uniffiTypeCuaDriverObjectFactory.clonePointer(this), callStatus);
-        }, 
-        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+            throw __error;
+        }
     }
-    metadata() {
-        return ((__rb) => {
-            try {
-                return FfiConverterTypeDriverMetadata.lift(__rb);
-            }
-            finally {
-                nativeModule().rustbuffer_free(__rb);
+    async metadata(asyncOpts_) {
+        const __stack = uniffiIsDebug ? new Error().stack : undefined;
+        try {
+            return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller, 
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().uniffi_cua_driver_sdk_fn_method_cuadriver_metadata(uniffiTypeCuaDriverObjectFactory.clonePointer(this));
+            }, 
+            /*pollFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_poll_rust_buffer, 
+            /*cancelFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_cancel_rust_buffer, 
+            /*completeFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_complete_rust_buffer, 
+            /*freeFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_free_rust_buffer, 
+            // Async returns always go through the JS-side converter: the
+            // FFI symbol returns the future handle (u64), and the user-level
+            // RustBuffer comes back via the shared `rust_future_complete_*`
+            // export. The bytes the runtime hands back must be deserialized
+            // here using the per-callable return-type converter.
+            /*liftFunc:*/ FfiConverterTypeDriverMetadata.lift.bind(FfiConverterTypeDriverMetadata), 
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString), 
+            /*asyncOpts:*/ asyncOpts_, 
+            /*errorHandler:*/ FfiConverterTypeDriverError.lift.bind(FfiConverterTypeDriverError));
+        }
+        catch (__error) {
+            if (uniffiIsDebug && __error instanceof Error) {
+                __error.stack = __stack;
             }
-        })(uniffiCaller.rustCallWithError(
-        /*liftError:*/ FfiConverterTypeDriverError.lift.bind(FfiConverterTypeDriverError), 
-        /*caller:*/ (callStatus) => {
-            return nativeModule().uniffi_cua_driver_sdk_fn_method_cuadriver_metadata(uniffiTypeCuaDriverObjectFactory.clonePointer(this), callStatus);
-        }, 
-        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+            throw __error;
+        }
     }
-    moveCursor(input) {
-        return ((__rb) => {
-            try {
-                return FfiConverterTypeToolResult.lift(__rb);
-            }
-            finally {
-                nativeModule().rustbuffer_free(__rb);
+    async moveCursor(input, asyncOpts_) {
+        const __stack = uniffiIsDebug ? new Error().stack : undefined;
+        try {
+            return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller, 
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().uniffi_cua_driver_sdk_fn_method_cuadriver_move_cursor(uniffiTypeCuaDriverObjectFactory.clonePointer(this), FfiConverterTypeMoveCursorInput.lower(input, nativeModule().rustbuffer_alloc));
+            }, 
+            /*pollFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_poll_rust_buffer, 
+            /*cancelFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_cancel_rust_buffer, 
+            /*completeFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_complete_rust_buffer, 
+            /*freeFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_free_rust_buffer, 
+            // Async returns always go through the JS-side converter: the
+            // FFI symbol returns the future handle (u64), and the user-level
+            // RustBuffer comes back via the shared `rust_future_complete_*`
+            // export. The bytes the runtime hands back must be deserialized
+            // here using the per-callable return-type converter.
+            /*liftFunc:*/ FfiConverterTypeToolResult.lift.bind(FfiConverterTypeToolResult), 
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString), 
+            /*asyncOpts:*/ asyncOpts_, 
+            /*errorHandler:*/ FfiConverterTypeDriverError.lift.bind(FfiConverterTypeDriverError));
+        }
+        catch (__error) {
+            if (uniffiIsDebug && __error instanceof Error) {
+                __error.stack = __stack;
             }
-        })(uniffiCaller.rustCallWithError(
-        /*liftError:*/ FfiConverterTypeDriverError.lift.bind(FfiConverterTypeDriverError), 
-        /*caller:*/ (callStatus) => {
-            return nativeModule().uniffi_cua_driver_sdk_fn_method_cuadriver_move_cursor(uniffiTypeCuaDriverObjectFactory.clonePointer(this), FfiConverterTypeMoveCursorInput.lower(input, nativeModule().rustbuffer_alloc), callStatus);
-        }, 
-        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+            throw __error;
+        }
     }
-    pressKey(input) {
-        return ((__rb) => {
-            try {
-                return FfiConverterTypeToolResult.lift(__rb);
-            }
-            finally {
-                nativeModule().rustbuffer_free(__rb);
+    async pressKey(input, asyncOpts_) {
+        const __stack = uniffiIsDebug ? new Error().stack : undefined;
+        try {
+            return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller, 
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().uniffi_cua_driver_sdk_fn_method_cuadriver_press_key(uniffiTypeCuaDriverObjectFactory.clonePointer(this), FfiConverterTypePressKeyInput.lower(input, nativeModule().rustbuffer_alloc));
+            }, 
+            /*pollFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_poll_rust_buffer, 
+            /*cancelFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_cancel_rust_buffer, 
+            /*completeFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_complete_rust_buffer, 
+            /*freeFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_free_rust_buffer, 
+            // Async returns always go through the JS-side converter: the
+            // FFI symbol returns the future handle (u64), and the user-level
+            // RustBuffer comes back via the shared `rust_future_complete_*`
+            // export. The bytes the runtime hands back must be deserialized
+            // here using the per-callable return-type converter.
+            /*liftFunc:*/ FfiConverterTypeToolResult.lift.bind(FfiConverterTypeToolResult), 
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString), 
+            /*asyncOpts:*/ asyncOpts_, 
+            /*errorHandler:*/ FfiConverterTypeDriverError.lift.bind(FfiConverterTypeDriverError));
+        }
+        catch (__error) {
+            if (uniffiIsDebug && __error instanceof Error) {
+                __error.stack = __stack;
             }
-        })(uniffiCaller.rustCallWithError(
-        /*liftError:*/ FfiConverterTypeDriverError.lift.bind(FfiConverterTypeDriverError), 
-        /*caller:*/ (callStatus) => {
-            return nativeModule().uniffi_cua_driver_sdk_fn_method_cuadriver_press_key(uniffiTypeCuaDriverObjectFactory.clonePointer(this), FfiConverterTypePressKeyInput.lower(input, nativeModule().rustbuffer_alloc), callStatus);
-        }, 
-        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+            throw __error;
+        }
     }
-    scroll(input) {
-        return ((__rb) => {
-            try {
-                return FfiConverterTypeToolResult.lift(__rb);
+    async scroll(input, asyncOpts_) {
+        const __stack = uniffiIsDebug ? new Error().stack : undefined;
+        try {
+            return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller, 
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().uniffi_cua_driver_sdk_fn_method_cuadriver_scroll(uniffiTypeCuaDriverObjectFactory.clonePointer(this), FfiConverterTypeScrollInput.lower(input, nativeModule().rustbuffer_alloc));
+            }, 
+            /*pollFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_poll_rust_buffer, 
+            /*cancelFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_cancel_rust_buffer, 
+            /*completeFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_complete_rust_buffer, 
+            /*freeFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_free_rust_buffer, 
+            // Async returns always go through the JS-side converter: the
+            // FFI symbol returns the future handle (u64), and the user-level
+            // RustBuffer comes back via the shared `rust_future_complete_*`
+            // export. The bytes the runtime hands back must be deserialized
+            // here using the per-callable return-type converter.
+            /*liftFunc:*/ FfiConverterTypeToolResult.lift.bind(FfiConverterTypeToolResult), 
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString), 
+            /*asyncOpts:*/ asyncOpts_, 
+            /*errorHandler:*/ FfiConverterTypeDriverError.lift.bind(FfiConverterTypeDriverError));
+        }
+        catch (__error) {
+            if (uniffiIsDebug && __error instanceof Error) {
+                __error.stack = __stack;
             }
-            finally {
-                nativeModule().rustbuffer_free(__rb);
+            throw __error;
+        }
+    }
+    /**
+     * Stop accepting new embedded operations. Repeated calls are harmless;
+     * daemon compatibility clients do not own the daemon and therefore no-op.
+     */
+    async shutdown(asyncOpts_) {
+        const __stack = uniffiIsDebug ? new Error().stack : undefined;
+        try {
+            return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller, 
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().uniffi_cua_driver_sdk_fn_method_cuadriver_shutdown(uniffiTypeCuaDriverObjectFactory.clonePointer(this));
+            }, 
+            /*pollFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_poll_void, 
+            /*cancelFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_cancel_void, 
+            /*completeFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_complete_void, 
+            /*freeFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_free_void, 
+            /*liftFunc:*/ (_v) => { }, 
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString), 
+            /*asyncOpts:*/ asyncOpts_, 
+            /*errorHandler:*/ FfiConverterTypeDriverError.lift.bind(FfiConverterTypeDriverError));
+        }
+        catch (__error) {
+            if (uniffiIsDebug && __error instanceof Error) {
+                __error.stack = __stack;
             }
-        })(uniffiCaller.rustCallWithError(
-        /*liftError:*/ FfiConverterTypeDriverError.lift.bind(FfiConverterTypeDriverError), 
-        /*caller:*/ (callStatus) => {
-            return nativeModule().uniffi_cua_driver_sdk_fn_method_cuadriver_scroll(uniffiTypeCuaDriverObjectFactory.clonePointer(this), FfiConverterTypeScrollInput.lower(input, nativeModule().rustbuffer_alloc), callStatus);
-        }, 
-        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+            throw __error;
+        }
     }
+    /**
+     * Compatibility accessor. Embedded runtimes have no socket and return an
+     * empty string; new code should branch on [`Self::execution_mode`].
+     */
     socketPath() {
         return ((__rb) => {
             try {
@@ -1385,35 +1804,63 @@ export class CuaDriver extends UniffiAbstractObject {
         }, 
         /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
     }
-    startSession(input) {
-        return ((__rb) => {
-            try {
-                return FfiConverterTypeStartSessionOutput.lift(__rb);
-            }
-            finally {
-                nativeModule().rustbuffer_free(__rb);
+    async startSession(input, asyncOpts_) {
+        const __stack = uniffiIsDebug ? new Error().stack : undefined;
+        try {
+            return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller, 
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().uniffi_cua_driver_sdk_fn_method_cuadriver_start_session(uniffiTypeCuaDriverObjectFactory.clonePointer(this), FfiConverterTypeStartSessionInput.lower(input, nativeModule().rustbuffer_alloc));
+            }, 
+            /*pollFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_poll_rust_buffer, 
+            /*cancelFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_cancel_rust_buffer, 
+            /*completeFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_complete_rust_buffer, 
+            /*freeFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_free_rust_buffer, 
+            // Async returns always go through the JS-side converter: the
+            // FFI symbol returns the future handle (u64), and the user-level
+            // RustBuffer comes back via the shared `rust_future_complete_*`
+            // export. The bytes the runtime hands back must be deserialized
+            // here using the per-callable return-type converter.
+            /*liftFunc:*/ FfiConverterTypeStartSessionOutput.lift.bind(FfiConverterTypeStartSessionOutput), 
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString), 
+            /*asyncOpts:*/ asyncOpts_, 
+            /*errorHandler:*/ FfiConverterTypeDriverError.lift.bind(FfiConverterTypeDriverError));
+        }
+        catch (__error) {
+            if (uniffiIsDebug && __error instanceof Error) {
+                __error.stack = __stack;
             }
-        })(uniffiCaller.rustCallWithError(
-        /*liftError:*/ FfiConverterTypeDriverError.lift.bind(FfiConverterTypeDriverError), 
-        /*caller:*/ (callStatus) => {
-            return nativeModule().uniffi_cua_driver_sdk_fn_method_cuadriver_start_session(uniffiTypeCuaDriverObjectFactory.clonePointer(this), FfiConverterTypeStartSessionInput.lower(input, nativeModule().rustbuffer_alloc), callStatus);
-        }, 
-        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+            throw __error;
+        }
     }
-    typeText(input) {
-        return ((__rb) => {
-            try {
-                return FfiConverterTypeToolResult.lift(__rb);
-            }
-            finally {
-                nativeModule().rustbuffer_free(__rb);
+    async typeText(input, asyncOpts_) {
+        const __stack = uniffiIsDebug ? new Error().stack : undefined;
+        try {
+            return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller, 
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().uniffi_cua_driver_sdk_fn_method_cuadriver_type_text(uniffiTypeCuaDriverObjectFactory.clonePointer(this), FfiConverterTypeTypeTextInput.lower(input, nativeModule().rustbuffer_alloc));
+            }, 
+            /*pollFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_poll_rust_buffer, 
+            /*cancelFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_cancel_rust_buffer, 
+            /*completeFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_complete_rust_buffer, 
+            /*freeFunc:*/ nativeModule().ffi_cua_driver_sdk_rust_future_free_rust_buffer, 
+            // Async returns always go through the JS-side converter: the
+            // FFI symbol returns the future handle (u64), and the user-level
+            // RustBuffer comes back via the shared `rust_future_complete_*`
+            // export. The bytes the runtime hands back must be deserialized
+            // here using the per-callable return-type converter.
+            /*liftFunc:*/ FfiConverterTypeToolResult.lift.bind(FfiConverterTypeToolResult), 
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString), 
+            /*asyncOpts:*/ asyncOpts_, 
+            /*errorHandler:*/ FfiConverterTypeDriverError.lift.bind(FfiConverterTypeDriverError));
+        }
+        catch (__error) {
+            if (uniffiIsDebug && __error instanceof Error) {
+                __error.stack = __stack;
             }
-        })(uniffiCaller.rustCallWithError(
-        /*liftError:*/ FfiConverterTypeDriverError.lift.bind(FfiConverterTypeDriverError), 
-        /*caller:*/ (callStatus) => {
-            return nativeModule().uniffi_cua_driver_sdk_fn_method_cuadriver_type_text(uniffiTypeCuaDriverObjectFactory.clonePointer(this), FfiConverterTypeTypeTextInput.lower(input, nativeModule().rustbuffer_alloc), callStatus);
-        }, 
-        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+            throw __error;
+        }
     }
     uniffiDestroy() {
         const ptr = this[destructorGuardSymbol];
@@ -1723,6 +2170,8 @@ const FfiConverterSequenceTypeImageContent = new FfiConverterArray(FfiConverterT
 const FfiConverterOptionalBoolean = new FfiConverterOptional(FfiConverterBool);
 // FfiConverter for EmbeddedDriverConnection | undefined
 const FfiConverterOptionalTypeEmbeddedDriverConnection = new FfiConverterOptional(FfiConverterTypeEmbeddedDriverConnection);
+// FfiConverter for DriverOptions | undefined
+const FfiConverterOptionalTypeDriverOptions = new FfiConverterOptional(FfiConverterTypeDriverOptions);
 /**
  * This should be called before anything else.
  *
@@ -1750,64 +2199,79 @@ function uniffiEnsureInitialized() {
     if (nativeModule().uniffi_cua_driver_sdk_checksum_func_request_mac_os_permissions() !== 61823) {
         throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_func_request_mac_os_permissions");
     }
-    if (nativeModule().uniffi_cua_driver_sdk_checksum_constructor_cuadriver_connect() !== 42154) {
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_constructor_cuadriver_connect() !== 60859) {
         throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_constructor_cuadriver_connect");
     }
-    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_cuadriver_call_tool() !== 31445) {
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_constructor_cuadriver_connect_with_client_kind() !== 43287) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_constructor_cuadriver_connect_with_client_kind");
+    }
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_constructor_cuadriver_create() !== 15191) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_constructor_cuadriver_create");
+    }
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_constructor_cuadriver_create_with_client_kind() !== 3630) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_constructor_cuadriver_create_with_client_kind");
+    }
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_cuadriver_call_tool() !== 24493) {
         throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_method_cuadriver_call_tool");
     }
-    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_cuadriver_click() !== 34118) {
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_cuadriver_click() !== 56077) {
         throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_method_cuadriver_click");
     }
-    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_cuadriver_drag() !== 35252) {
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_cuadriver_drag() !== 25742) {
         throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_method_cuadriver_drag");
     }
-    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_cuadriver_end_session() !== 33990) {
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_cuadriver_end_session() !== 18486) {
         throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_method_cuadriver_end_session");
     }
-    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_cuadriver_escalate_session() !== 37358) {
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_cuadriver_escalate_session() !== 6924) {
         throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_method_cuadriver_escalate_session");
     }
-    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_cuadriver_get_cursor_position() !== 54043) {
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_cuadriver_execution_mode() !== 2639) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_method_cuadriver_execution_mode");
+    }
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_cuadriver_get_cursor_position() !== 34285) {
         throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_method_cuadriver_get_cursor_position");
     }
-    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_cuadriver_get_desktop_state() !== 32992) {
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_cuadriver_get_desktop_state() !== 65084) {
         throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_method_cuadriver_get_desktop_state");
     }
-    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_cuadriver_get_screen_size() !== 15250) {
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_cuadriver_get_screen_size() !== 55616) {
         throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_method_cuadriver_get_screen_size");
     }
-    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_cuadriver_get_session_state() !== 51055) {
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_cuadriver_get_session_state() !== 49966) {
         throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_method_cuadriver_get_session_state");
     }
-    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_cuadriver_hotkey() !== 3135) {
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_cuadriver_hotkey() !== 53333) {
         throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_method_cuadriver_hotkey");
     }
     if (nativeModule().uniffi_cua_driver_sdk_checksum_method_cuadriver_is_available() !== 42961) {
         throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_method_cuadriver_is_available");
     }
-    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_cuadriver_list_tools_json() !== 43987) {
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_cuadriver_list_tools_json() !== 33039) {
         throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_method_cuadriver_list_tools_json");
     }
-    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_cuadriver_metadata() !== 50371) {
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_cuadriver_metadata() !== 55026) {
         throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_method_cuadriver_metadata");
     }
-    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_cuadriver_move_cursor() !== 11209) {
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_cuadriver_move_cursor() !== 18320) {
         throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_method_cuadriver_move_cursor");
     }
-    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_cuadriver_press_key() !== 17425) {
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_cuadriver_press_key() !== 63712) {
         throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_method_cuadriver_press_key");
     }
-    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_cuadriver_scroll() !== 21614) {
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_cuadriver_scroll() !== 52290) {
         throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_method_cuadriver_scroll");
     }
-    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_cuadriver_socket_path() !== 24461) {
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_cuadriver_shutdown() !== 36331) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_method_cuadriver_shutdown");
+    }
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_cuadriver_socket_path() !== 48126) {
         throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_method_cuadriver_socket_path");
     }
-    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_cuadriver_start_session() !== 53509) {
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_cuadriver_start_session() !== 45055) {
         throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_method_cuadriver_start_session");
     }
-    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_cuadriver_type_text() !== 19673) {
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_cuadriver_type_text() !== 25156) {
         throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_method_cuadriver_type_text");
     }
     if (nativeModule().uniffi_cua_driver_sdk_checksum_constructor_embeddedcuadriverhost_new() !== 10108) {
@@ -1840,7 +2304,9 @@ export default Object.freeze({
     converters: {
         FfiConverterTypeCuaDriver,
         FfiConverterTypeDriverError,
+        FfiConverterTypeDriverExecutionMode,
         FfiConverterTypeDriverMetadata,
+        FfiConverterTypeDriverOptions,
         FfiConverterTypeEmbeddedCuaDriverHost,
         FfiConverterTypeEmbeddedDriverConnection,
         FfiConverterTypeEmbeddedDriverError,
@@ -1852,6 +2318,7 @@ export default Object.freeze({
         FfiConverterTypeEmbeddedPermissionMode,
         FfiConverterTypeImageContent,
         FfiConverterTypeMacOsPermissionStatus,
+        FfiConverterTypeSdkClientKind,
         FfiConverterTypeToolResult,
     }
 });