@trycua/cua-driver 0.12.5 → 0.14.0

package/dist/native/cua_driver_sdk.js

@@ -4,9 +4,9 @@
 /* eslint-disable */
 // @ts-nocheck
 import nativeModule from "./cua_driver_sdk-ffi.js";
-import { AbstractFfiConverterByteArray, FfiConverterArray, FfiConverterBool, FfiConverterInt32, FfiConverterObject, FfiConverterOptional, FfiConverterUInt32, FfiConverterUInt64, UniffiAbstractObject, UniffiError, UniffiInternalError, UniffiRustCaller, destructorGuardSymbol, pointerLiteralSymbol, uniffiCreateFfiConverterString, uniffiCreateRecord, uniffiRustCallAsync, uniffiTypeNameSymbol, } from "@ubjs/core";
+import { AbstractFfiConverterByteArray, FfiConverterArray, FfiConverterBool, FfiConverterInt32, FfiConverterObject, FfiConverterObjectWithCallbacks, FfiConverterOptional, FfiConverterUInt32, FfiConverterUInt64, UniffiAbstractObject, UniffiError, UniffiInternalError, UniffiResult, UniffiRustCaller, destructorGuardSymbol, pointerLiteralSymbol, uniffiCreateFfiConverterString, uniffiCreateRecord, uniffiRustCallAsync, uniffiTraitInterfaceCall, uniffiTraitInterfaceCallAsyncWithError, uniffiTypeNameSymbol, } from "@ubjs/core";
 import uniffiCuaDriverContractModule from "./cua_driver_contract.js";
-const { FfiConverterTypeClickInput, FfiConverterTypeDragInput, FfiConverterTypeEndSessionInput, FfiConverterTypeEndSessionOutput, FfiConverterTypeEscalateSessionInput, FfiConverterTypeGetCursorPositionInput, FfiConverterTypeGetDesktopStateInput, FfiConverterTypeGetScreenSizeInput, FfiConverterTypeGetSessionStateInput, FfiConverterTypeHotkeyInput, FfiConverterTypeMoveCursorInput, FfiConverterTypePressKeyInput, FfiConverterTypeScrollInput, FfiConverterTypeSessionStateOutput, FfiConverterTypeStartSessionInput, FfiConverterTypeStartSessionOutput, FfiConverterTypeTypeTextInput } = uniffiCuaDriverContractModule.converters;
+const { FfiConverterTypeClickInput, FfiConverterTypeDragInput, FfiConverterTypeEndSessionInput, FfiConverterTypeEndSessionOutput, FfiConverterTypeEscalateSessionInput, FfiConverterTypeGetAgentCursorStateInput, FfiConverterTypeGetCursorPositionInput, FfiConverterTypeGetDesktopStateInput, FfiConverterTypeGetScreenSizeInput, FfiConverterTypeGetSessionStateInput, FfiConverterTypeHotkeyInput, FfiConverterTypeMoveCursorInput, FfiConverterTypePressKeyInput, FfiConverterTypeScrollInput, FfiConverterTypeSessionStateOutput, FfiConverterTypeSetAgentCursorEnabledInput, FfiConverterTypeSetAgentCursorMotionInput, FfiConverterTypeSetAgentCursorThemeInput, FfiConverterTypeStartSessionInput, FfiConverterTypeStartSessionOutput, FfiConverterTypeTypeTextInput } = uniffiCuaDriverContractModule.converters;
 const uniffiCaller = new UniffiRustCaller(() => ({ code: 0 }));
 const uniffiIsDebug = 
 // @ts-ignore -- The process global might not be defined
@@ -15,6 +15,21 @@ typeof process !== "object" ||
     process?.env?.NODE_ENV !== "production" ||
     false;
 // Public interface members begin here.
+/**
+ * Generated-language host factory for a session-bound action surface.
+ *
+ * This remains a separate top-level capability instead of adding a required
+ * method to the released `CuaDriverProtocol` / `CuaDriverLike` structural
+ * interfaces.
+ */
+export function createTrustedSession(driver, options) {
+    return FfiConverterTypeCuaDriverSession.lift(uniffiCaller.rustCallWithError(
+    /*liftError:*/ FfiConverterTypeDriverError.lift.bind(FfiConverterTypeDriverError), 
+    /*caller:*/ (callStatus) => {
+        return nativeModule().uniffi_cua_driver_sdk_fn_func_create_trusted_session(FfiConverterTypeCuaDriver.lower(driver, nativeModule().rustbuffer_alloc), FfiConverterTypeTrustedSessionOptions.lower(options, nativeModule().rustbuffer_alloc), callStatus);
+    }, 
+    /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+}
 export function currentMacOsPermissionStatus() {
     return ((__rb) => {
         try {
@@ -51,6 +66,39 @@ export function requestMacOsPermissions() {
     }, 
     /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
 }
+/**
+ * Permission mode chosen by trusted host code for a runtime or session.
+ */
+export var SessionPermissionMode;
+(function (SessionPermissionMode) {
+    SessionPermissionMode[SessionPermissionMode["Standard"] = 0] = "Standard";
+    SessionPermissionMode[SessionPermissionMode["Bounded"] = 1] = "Bounded";
+    SessionPermissionMode[SessionPermissionMode["Unrestricted"] = 2] = "Unrestricted";
+})(SessionPermissionMode || (SessionPermissionMode = {}));
+const FfiConverterTypeSessionPermissionMode = (() => {
+    const ordinalConverter = FfiConverterInt32;
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            switch (ordinalConverter.read(from)) {
+                case 1: return SessionPermissionMode.Standard;
+                case 2: return SessionPermissionMode.Bounded;
+                case 3: return SessionPermissionMode.Unrestricted;
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        write(value, into) {
+            switch (value) {
+                case SessionPermissionMode.Standard: return ordinalConverter.write(1, into);
+                case SessionPermissionMode.Bounded: return ordinalConverter.write(2, into);
+                case SessionPermissionMode.Unrestricted: return ordinalConverter.write(3, into);
+            }
+        }
+        allocationSize(value) {
+            return ordinalConverter.allocationSize(0);
+        }
+    }
+    return new FFIConverter();
+})();
 const stringConverter = (() => {
     const encoder = new TextEncoder();
     const decoder = new TextDecoder();
@@ -66,6 +114,314 @@ const stringConverter = (() => {
     };
 })();
 const FfiConverterString = uniffiCreateFfiConverterString(stringConverter);
+/**
+ * Generated factory for {@link RuntimeAuthorizationOptions} record objects.
+ */
+export const RuntimeAuthorizationOptions = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeRuntimeAuthorizationOptions = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                allowedModes: FfiConverterSequenceTypeSessionPermissionMode.read(from),
+                compatibilityMode: FfiConverterTypeSessionPermissionMode.read(from),
+                compatibilityBoundedManifestPath: FfiConverterOptionalString.read(from),
+                unrestrictedAcknowledged: FfiConverterBool.read(from),
+                maxSessionTtlSeconds: FfiConverterUInt64.read(from),
+                maxIdleTtlSeconds: FfiConverterUInt64.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterSequenceTypeSessionPermissionMode.write(value.allowedModes, into);
+            FfiConverterTypeSessionPermissionMode.write(value.compatibilityMode, into);
+            FfiConverterOptionalString.write(value.compatibilityBoundedManifestPath, into);
+            FfiConverterBool.write(value.unrestrictedAcknowledged, into);
+            FfiConverterUInt64.write(value.maxSessionTtlSeconds, into);
+            FfiConverterUInt64.write(value.maxIdleTtlSeconds, into);
+        }
+        allocationSize(value) {
+            return FfiConverterSequenceTypeSessionPermissionMode.allocationSize(value.allowedModes) +
+                FfiConverterTypeSessionPermissionMode.allocationSize(value.compatibilityMode) +
+                FfiConverterOptionalString.allocationSize(value.compatibilityBoundedManifestPath) +
+                FfiConverterBool.allocationSize(value.unrestrictedAcknowledged) +
+                FfiConverterUInt64.allocationSize(value.maxSessionTtlSeconds) +
+                FfiConverterUInt64.allocationSize(value.maxIdleTtlSeconds);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
+/**
+ * Generated factory for {@link ConfiguredDriverOptions} record objects.
+ */
+export const ConfiguredDriverOptions = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeConfiguredDriverOptions = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                claudeCodeCompatibility: FfiConverterBool.read(from),
+                authorization: FfiConverterTypeRuntimeAuthorizationOptions.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterBool.write(value.claudeCodeCompatibility, into);
+            FfiConverterTypeRuntimeAuthorizationOptions.write(value.authorization, into);
+        }
+        allocationSize(value) {
+            return FfiConverterBool.allocationSize(value.claudeCodeCompatibility) +
+                FfiConverterTypeRuntimeAuthorizationOptions.allocationSize(value.authorization);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
+export var DriverActivityKind;
+(function (DriverActivityKind) {
+    DriverActivityKind[DriverActivityKind["AuthorizedAction"] = 0] = "AuthorizedAction";
+    DriverActivityKind[DriverActivityKind["AuthorizationRefused"] = 1] = "AuthorizationRefused";
+    DriverActivityKind[DriverActivityKind["ActionFailed"] = 2] = "ActionFailed";
+    DriverActivityKind[DriverActivityKind["GrantIssued"] = 3] = "GrantIssued";
+    DriverActivityKind[DriverActivityKind["GrantRevoked"] = 4] = "GrantRevoked";
+    DriverActivityKind[DriverActivityKind["SessionStarted"] = 5] = "SessionStarted";
+    DriverActivityKind[DriverActivityKind["SessionEnded"] = 6] = "SessionEnded";
+})(DriverActivityKind || (DriverActivityKind = {}));
+const FfiConverterTypeDriverActivityKind = (() => {
+    const ordinalConverter = FfiConverterInt32;
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            switch (ordinalConverter.read(from)) {
+                case 1: return DriverActivityKind.AuthorizedAction;
+                case 2: return DriverActivityKind.AuthorizationRefused;
+                case 3: return DriverActivityKind.ActionFailed;
+                case 4: return DriverActivityKind.GrantIssued;
+                case 5: return DriverActivityKind.GrantRevoked;
+                case 6: return DriverActivityKind.SessionStarted;
+                case 7: return DriverActivityKind.SessionEnded;
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        write(value, into) {
+            switch (value) {
+                case DriverActivityKind.AuthorizedAction: return ordinalConverter.write(1, into);
+                case DriverActivityKind.AuthorizationRefused: return ordinalConverter.write(2, into);
+                case DriverActivityKind.ActionFailed: return ordinalConverter.write(3, into);
+                case DriverActivityKind.GrantIssued: return ordinalConverter.write(4, into);
+                case DriverActivityKind.GrantRevoked: return ordinalConverter.write(5, into);
+                case DriverActivityKind.SessionStarted: return ordinalConverter.write(6, into);
+                case DriverActivityKind.SessionEnded: return ordinalConverter.write(7, into);
+            }
+        }
+        allocationSize(value) {
+            return ordinalConverter.allocationSize(0);
+        }
+    }
+    return new FFIConverter();
+})();
+/**
+ * Generated factory for {@link DriverActivityEvent} record objects.
+ */
+export const DriverActivityEvent = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeDriverActivityEvent = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                kind: FfiConverterTypeDriverActivityKind.read(from),
+                unixMs: FfiConverterUInt64.read(from),
+                toolName: FfiConverterString.read(from),
+                adapterIds: FfiConverterSequenceString.read(from),
+                riskClass: FfiConverterString.read(from),
+                publicSession: FfiConverterOptionalString.read(from),
+                refusalCode: FfiConverterOptionalString.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterTypeDriverActivityKind.write(value.kind, into);
+            FfiConverterUInt64.write(value.unixMs, into);
+            FfiConverterString.write(value.toolName, into);
+            FfiConverterSequenceString.write(value.adapterIds, into);
+            FfiConverterString.write(value.riskClass, into);
+            FfiConverterOptionalString.write(value.publicSession, into);
+            FfiConverterOptionalString.write(value.refusalCode, into);
+        }
+        allocationSize(value) {
+            return FfiConverterTypeDriverActivityKind.allocationSize(value.kind) +
+                FfiConverterUInt64.allocationSize(value.unixMs) +
+                FfiConverterString.allocationSize(value.toolName) +
+                FfiConverterSequenceString.allocationSize(value.adapterIds) +
+                FfiConverterString.allocationSize(value.riskClass) +
+                FfiConverterOptionalString.allocationSize(value.publicSession) +
+                FfiConverterOptionalString.allocationSize(value.refusalCode);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
+export var DriverAuthorizationAction;
+(function (DriverAuthorizationAction) {
+    DriverAuthorizationAction[DriverAuthorizationAction["Allow"] = 0] = "Allow";
+    DriverAuthorizationAction[DriverAuthorizationAction["Deny"] = 1] = "Deny";
+    DriverAuthorizationAction[DriverAuthorizationAction["Cancel"] = 2] = "Cancel";
+})(DriverAuthorizationAction || (DriverAuthorizationAction = {}));
+const FfiConverterTypeDriverAuthorizationAction = (() => {
+    const ordinalConverter = FfiConverterInt32;
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            switch (ordinalConverter.read(from)) {
+                case 1: return DriverAuthorizationAction.Allow;
+                case 2: return DriverAuthorizationAction.Deny;
+                case 3: return DriverAuthorizationAction.Cancel;
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        write(value, into) {
+            switch (value) {
+                case DriverAuthorizationAction.Allow: return ordinalConverter.write(1, into);
+                case DriverAuthorizationAction.Deny: return ordinalConverter.write(2, into);
+                case DriverAuthorizationAction.Cancel: return ordinalConverter.write(3, into);
+            }
+        }
+        allocationSize(value) {
+            return ordinalConverter.allocationSize(0);
+        }
+    }
+    return new FFIConverter();
+})();
+/**
+ * Generated factory for {@link DriverAuthorizationDecision} record objects.
+ */
+export const DriverAuthorizationDecision = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeDriverAuthorizationDecision = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                action: FfiConverterTypeDriverAuthorizationAction.read(from),
+                requestDigest: FfiConverterString.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterTypeDriverAuthorizationAction.write(value.action, into);
+            FfiConverterString.write(value.requestDigest, into);
+        }
+        allocationSize(value) {
+            return FfiConverterTypeDriverAuthorizationAction.allocationSize(value.action) +
+                FfiConverterString.allocationSize(value.requestDigest);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
+/**
+ * Generated factory for {@link DriverAuthorizationRequest} record objects.
+ */
+export const DriverAuthorizationRequest = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeDriverAuthorizationRequest = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                schema: FfiConverterString.read(from),
+                nonce: FfiConverterString.read(from),
+                generation: FfiConverterUInt64.read(from),
+                daemonInstance: FfiConverterString.read(from),
+                permissionMode: FfiConverterString.read(from),
+                managedPolicySha256: FfiConverterOptionalString.read(from),
+                userPolicySha256: FfiConverterOptionalString.read(from),
+                adapterId: FfiConverterString.read(from),
+                riskClass: FfiConverterString.read(from),
+                publicSession: FfiConverterString.read(from),
+                transportSession: FfiConverterString.read(from),
+                resourceJson: FfiConverterString.read(from),
+                humanSummary: FfiConverterString.read(from),
+                expiresUnixMs: FfiConverterUInt64.read(from),
+                requestDigest: FfiConverterString.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterString.write(value.schema, into);
+            FfiConverterString.write(value.nonce, into);
+            FfiConverterUInt64.write(value.generation, into);
+            FfiConverterString.write(value.daemonInstance, into);
+            FfiConverterString.write(value.permissionMode, into);
+            FfiConverterOptionalString.write(value.managedPolicySha256, into);
+            FfiConverterOptionalString.write(value.userPolicySha256, into);
+            FfiConverterString.write(value.adapterId, into);
+            FfiConverterString.write(value.riskClass, into);
+            FfiConverterString.write(value.publicSession, into);
+            FfiConverterString.write(value.transportSession, into);
+            FfiConverterString.write(value.resourceJson, into);
+            FfiConverterString.write(value.humanSummary, into);
+            FfiConverterUInt64.write(value.expiresUnixMs, into);
+            FfiConverterString.write(value.requestDigest, into);
+        }
+        allocationSize(value) {
+            return FfiConverterString.allocationSize(value.schema) +
+                FfiConverterString.allocationSize(value.nonce) +
+                FfiConverterUInt64.allocationSize(value.generation) +
+                FfiConverterString.allocationSize(value.daemonInstance) +
+                FfiConverterString.allocationSize(value.permissionMode) +
+                FfiConverterOptionalString.allocationSize(value.managedPolicySha256) +
+                FfiConverterOptionalString.allocationSize(value.userPolicySha256) +
+                FfiConverterString.allocationSize(value.adapterId) +
+                FfiConverterString.allocationSize(value.riskClass) +
+                FfiConverterString.allocationSize(value.publicSession) +
+                FfiConverterString.allocationSize(value.transportSession) +
+                FfiConverterString.allocationSize(value.resourceJson) +
+                FfiConverterString.allocationSize(value.humanSummary) +
+                FfiConverterUInt64.allocationSize(value.expiresUnixMs) +
+                FfiConverterString.allocationSize(value.requestDigest);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
 /**
  * Generated factory for {@link DriverMetadata} record objects.
  */
@@ -465,6 +821,55 @@ const FfiConverterTypeMacOsPermissionStatus = (() => {
     ;
     return new FFIConverter();
 })();
+/**
+ * Generated factory for {@link PrivateWorkerOptions} record objects.
+ */
+export const PrivateWorkerOptions = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypePrivateWorkerOptions = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                binaryPath: FfiConverterString.read(from),
+                hostBundleId: FfiConverterString.read(from),
+                startupTimeoutMs: FfiConverterOptionalUInt64.read(from),
+                shutdownTimeoutMs: FfiConverterOptionalUInt64.read(from),
+                configuredDriver: FfiConverterTypeConfiguredDriverOptions.read(from),
+                environment: FfiConverterSequenceTypeEmbeddedEnvironmentVariable.read(from),
+                inheritStderr: FfiConverterBool.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterString.write(value.binaryPath, into);
+            FfiConverterString.write(value.hostBundleId, into);
+            FfiConverterOptionalUInt64.write(value.startupTimeoutMs, into);
+            FfiConverterOptionalUInt64.write(value.shutdownTimeoutMs, into);
+            FfiConverterTypeConfiguredDriverOptions.write(value.configuredDriver, into);
+            FfiConverterSequenceTypeEmbeddedEnvironmentVariable.write(value.environment, into);
+            FfiConverterBool.write(value.inheritStderr, into);
+        }
+        allocationSize(value) {
+            return FfiConverterString.allocationSize(value.binaryPath) +
+                FfiConverterString.allocationSize(value.hostBundleId) +
+                FfiConverterOptionalUInt64.allocationSize(value.startupTimeoutMs) +
+                FfiConverterOptionalUInt64.allocationSize(value.shutdownTimeoutMs) +
+                FfiConverterTypeConfiguredDriverOptions.allocationSize(value.configuredDriver) +
+                FfiConverterSequenceTypeEmbeddedEnvironmentVariable.allocationSize(value.environment) +
+                FfiConverterBool.allocationSize(value.inheritStderr);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
 /**
  * Generated factory for {@link ToolResult} record objects.
  */
@@ -517,32 +922,185 @@ const FfiConverterTypeToolResult = (() => {
     ;
     return new FFIConverter();
 })();
-// Error type: DriverError
-export var DriverError_Tags;
-(function (DriverError_Tags) {
-    DriverError_Tags["Configuration"] = "Configuration";
-    DriverError_Tags["InvalidArguments"] = "InvalidArguments";
-    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 {
-        /**
-         * @private
-         * This field is private and should not be used, use `tag` instead.
-         */
-        [uniffiTypeNameSymbol] = "DriverError";
-        tag = DriverError_Tags.Configuration;
-        inner;
-        constructor(inner) {
-            super("DriverError", "Configuration");
-            this.inner = Object.freeze(inner);
-        }
-        static new(inner) {
-            return new Configuration_(inner);
-        }
+/**
+ * Generated factory for {@link TrustedSessionOptions} record objects.
+ */
+export const TrustedSessionOptions = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeTrustedSessionOptions = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                publicSession: FfiConverterString.read(from),
+                mode: FfiConverterTypeSessionPermissionMode.read(from),
+                ttlSeconds: FfiConverterUInt64.read(from),
+                idleTtlSeconds: FfiConverterUInt64.read(from),
+                boundedManifestPath: FfiConverterOptionalString.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterString.write(value.publicSession, into);
+            FfiConverterTypeSessionPermissionMode.write(value.mode, into);
+            FfiConverterUInt64.write(value.ttlSeconds, into);
+            FfiConverterUInt64.write(value.idleTtlSeconds, into);
+            FfiConverterOptionalString.write(value.boundedManifestPath, into);
+        }
+        allocationSize(value) {
+            return FfiConverterString.allocationSize(value.publicSession) +
+                FfiConverterTypeSessionPermissionMode.allocationSize(value.mode) +
+                FfiConverterUInt64.allocationSize(value.ttlSeconds) +
+                FfiConverterUInt64.allocationSize(value.idleTtlSeconds) +
+                FfiConverterOptionalString.allocationSize(value.boundedManifestPath);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
+export var ActionCompletion;
+(function (ActionCompletion) {
+    ActionCompletion[ActionCompletion["NotStarted"] = 0] = "NotStarted";
+    ActionCompletion[ActionCompletion["Completed"] = 1] = "Completed";
+    ActionCompletion[ActionCompletion["Unknown"] = 2] = "Unknown";
+})(ActionCompletion || (ActionCompletion = {}));
+const FfiConverterTypeActionCompletion = (() => {
+    const ordinalConverter = FfiConverterInt32;
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            switch (ordinalConverter.read(from)) {
+                case 1: return ActionCompletion.NotStarted;
+                case 2: return ActionCompletion.Completed;
+                case 3: return ActionCompletion.Unknown;
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        write(value, into) {
+            switch (value) {
+                case ActionCompletion.NotStarted: return ordinalConverter.write(1, into);
+                case ActionCompletion.Completed: return ordinalConverter.write(2, into);
+                case ActionCompletion.Unknown: return ordinalConverter.write(3, into);
+            }
+        }
+        allocationSize(value) {
+            return ordinalConverter.allocationSize(0);
+        }
+    }
+    return new FFIConverter();
+})();
+// Error type: DriverAuthorizationHostError
+export var DriverAuthorizationHostError_Tags;
+(function (DriverAuthorizationHostError_Tags) {
+    DriverAuthorizationHostError_Tags["Failed"] = "Failed";
+})(DriverAuthorizationHostError_Tags || (DriverAuthorizationHostError_Tags = {}));
+export const DriverAuthorizationHostError = (() => {
+    class Failed_ extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "DriverAuthorizationHostError";
+        tag = DriverAuthorizationHostError_Tags.Failed;
+        inner;
+        constructor(inner) {
+            super("DriverAuthorizationHostError", "Failed");
+            this.inner = Object.freeze(inner);
+        }
+        static new(inner) {
+            return new Failed_(inner);
+        }
+        static instanceOf(obj) {
+            return obj.tag === DriverAuthorizationHostError_Tags.Failed;
+        }
+        static hasInner(obj) {
+            return Failed_.instanceOf(obj);
+        }
+        static getInner(obj) {
+            return obj.inner;
+        }
+    }
+    function instanceOf(obj) {
+        return obj[uniffiTypeNameSymbol] === "DriverAuthorizationHostError";
+    }
+    return Object.freeze({
+        instanceOf,
+        Failed: Failed_
+    });
+})();
+// FfiConverter for enum DriverAuthorizationHostError
+const FfiConverterTypeDriverAuthorizationHostError = (() => {
+    const ordinalConverter = FfiConverterInt32;
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            switch (ordinalConverter.read(from)) {
+                case 1: return new DriverAuthorizationHostError.Failed({ reason: FfiConverterString.read(from) });
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        write(value, into) {
+            switch (value.tag) {
+                case DriverAuthorizationHostError_Tags.Failed: {
+                    ordinalConverter.write(1, into);
+                    const inner = value.inner;
+                    FfiConverterString.write(inner.reason, into);
+                    return;
+                }
+                default:
+                    // Throwing from here means that DriverAuthorizationHostError_Tags hasn't matched an ordinal.
+                    throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        allocationSize(value) {
+            switch (value.tag) {
+                case DriverAuthorizationHostError_Tags.Failed: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(1);
+                    size += FfiConverterString.allocationSize(inner.reason);
+                    return size;
+                }
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+    }
+    return new FFIConverter();
+})();
+// Error type: DriverError
+export var DriverError_Tags;
+(function (DriverError_Tags) {
+    DriverError_Tags["Configuration"] = "Configuration";
+    DriverError_Tags["InvalidArguments"] = "InvalidArguments";
+    DriverError_Tags["Transport"] = "Transport";
+    DriverError_Tags["Protocol"] = "Protocol";
+    DriverError_Tags["Tool"] = "Tool";
+    DriverError_Tags["Shutdown"] = "Shutdown";
+    DriverError_Tags["RuntimeAlreadyExists"] = "RuntimeAlreadyExists";
+    DriverError_Tags["Worker"] = "Worker";
+    DriverError_Tags["Remote"] = "Remote";
+    DriverError_Tags["ActionInterrupted"] = "ActionInterrupted";
+})(DriverError_Tags || (DriverError_Tags = {}));
+export const DriverError = (() => {
+    class Configuration_ extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "DriverError";
+        tag = DriverError_Tags.Configuration;
+        inner;
+        constructor(inner) {
+            super("DriverError", "Configuration");
+            this.inner = Object.freeze(inner);
+        }
+        static new(inner) {
+            return new Configuration_(inner);
+        }
         static instanceOf(obj) {
             return obj.tag === DriverError_Tags.Configuration;
         }
@@ -673,6 +1231,101 @@ export const DriverError = (() => {
             return false;
         }
     }
+    class RuntimeAlreadyExists_ extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "DriverError";
+        tag = DriverError_Tags.RuntimeAlreadyExists;
+        constructor() {
+            super("DriverError", "RuntimeAlreadyExists");
+        }
+        static new() {
+            return new RuntimeAlreadyExists_();
+        }
+        static instanceOf(obj) {
+            return obj.tag === DriverError_Tags.RuntimeAlreadyExists;
+        }
+        static hasInner(obj) {
+            return false;
+        }
+    }
+    class Worker_ extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "DriverError";
+        tag = DriverError_Tags.Worker;
+        inner;
+        constructor(inner) {
+            super("DriverError", "Worker");
+            this.inner = Object.freeze(inner);
+        }
+        static new(inner) {
+            return new Worker_(inner);
+        }
+        static instanceOf(obj) {
+            return obj.tag === DriverError_Tags.Worker;
+        }
+        static hasInner(obj) {
+            return Worker_.instanceOf(obj);
+        }
+        static getInner(obj) {
+            return obj.inner;
+        }
+    }
+    class Remote_ extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "DriverError";
+        tag = DriverError_Tags.Remote;
+        inner;
+        constructor(inner) {
+            super("DriverError", "Remote");
+            this.inner = Object.freeze(inner);
+        }
+        static new(inner) {
+            return new Remote_(inner);
+        }
+        static instanceOf(obj) {
+            return obj.tag === DriverError_Tags.Remote;
+        }
+        static hasInner(obj) {
+            return Remote_.instanceOf(obj);
+        }
+        static getInner(obj) {
+            return obj.inner;
+        }
+    }
+    class ActionInterrupted_ extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "DriverError";
+        tag = DriverError_Tags.ActionInterrupted;
+        inner;
+        constructor(inner) {
+            super("DriverError", "ActionInterrupted");
+            this.inner = Object.freeze(inner);
+        }
+        static new(inner) {
+            return new ActionInterrupted_(inner);
+        }
+        static instanceOf(obj) {
+            return obj.tag === DriverError_Tags.ActionInterrupted;
+        }
+        static hasInner(obj) {
+            return ActionInterrupted_.instanceOf(obj);
+        }
+        static getInner(obj) {
+            return obj.inner;
+        }
+    }
     function instanceOf(obj) {
         return obj[uniffiTypeNameSymbol] === "DriverError";
     }
@@ -683,7 +1336,11 @@ export const DriverError = (() => {
         Transport: Transport_,
         Protocol: Protocol_,
         Tool: Tool_,
-        Shutdown: Shutdown_
+        Shutdown: Shutdown_,
+        RuntimeAlreadyExists: RuntimeAlreadyExists_,
+        Worker: Worker_,
+        Remote: Remote_,
+        ActionInterrupted: ActionInterrupted_
     });
 })();
 // FfiConverter for enum DriverError
@@ -698,6 +1355,10 @@ const FfiConverterTypeDriverError = (() => {
                 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();
+                case 7: return new DriverError.RuntimeAlreadyExists();
+                case 8: return new DriverError.Worker({ reason: FfiConverterString.read(from) });
+                case 9: return new DriverError.Remote({ reason: FfiConverterString.read(from) });
+                case 10: return new DriverError.ActionInterrupted({ completion: FfiConverterTypeActionCompletion.read(from), reason: FfiConverterString.read(from) });
                 default: throw new UniffiInternalError.UnexpectedEnumCase();
             }
         }
@@ -741,6 +1402,29 @@ const FfiConverterTypeDriverError = (() => {
                     ordinalConverter.write(6, into);
                     return;
                 }
+                case DriverError_Tags.RuntimeAlreadyExists: {
+                    ordinalConverter.write(7, into);
+                    return;
+                }
+                case DriverError_Tags.Worker: {
+                    ordinalConverter.write(8, into);
+                    const inner = value.inner;
+                    FfiConverterString.write(inner.reason, into);
+                    return;
+                }
+                case DriverError_Tags.Remote: {
+                    ordinalConverter.write(9, into);
+                    const inner = value.inner;
+                    FfiConverterString.write(inner.reason, into);
+                    return;
+                }
+                case DriverError_Tags.ActionInterrupted: {
+                    ordinalConverter.write(10, into);
+                    const inner = value.inner;
+                    FfiConverterTypeActionCompletion.write(inner.completion, into);
+                    FfiConverterString.write(inner.reason, into);
+                    return;
+                }
                 default:
                     // Throwing from here means that DriverError_Tags hasn't matched an ordinal.
                     throw new UniffiInternalError.UnexpectedEnumCase();
@@ -785,6 +1469,28 @@ const FfiConverterTypeDriverError = (() => {
                 case DriverError_Tags.Shutdown: {
                     return ordinalConverter.allocationSize(6);
                 }
+                case DriverError_Tags.RuntimeAlreadyExists: {
+                    return ordinalConverter.allocationSize(7);
+                }
+                case DriverError_Tags.Worker: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(8);
+                    size += FfiConverterString.allocationSize(inner.reason);
+                    return size;
+                }
+                case DriverError_Tags.Remote: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(9);
+                    size += FfiConverterString.allocationSize(inner.reason);
+                    return size;
+                }
+                case DriverError_Tags.ActionInterrupted: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(10);
+                    size += FfiConverterTypeActionCompletion.allocationSize(inner.completion);
+                    size += FfiConverterString.allocationSize(inner.reason);
+                    return size;
+                }
                 default: throw new UniffiInternalError.UnexpectedEnumCase();
             }
         }
@@ -798,6 +1504,8 @@ export var DriverExecutionMode;
 (function (DriverExecutionMode) {
     DriverExecutionMode[DriverExecutionMode["Embedded"] = 0] = "Embedded";
     DriverExecutionMode[DriverExecutionMode["Daemon"] = 1] = "Daemon";
+    DriverExecutionMode[DriverExecutionMode["PrivateWorker"] = 2] = "PrivateWorker";
+    DriverExecutionMode[DriverExecutionMode["Remote"] = 3] = "Remote";
 })(DriverExecutionMode || (DriverExecutionMode = {}));
 const FfiConverterTypeDriverExecutionMode = (() => {
     const ordinalConverter = FfiConverterInt32;
@@ -806,6 +1514,8 @@ const FfiConverterTypeDriverExecutionMode = (() => {
             switch (ordinalConverter.read(from)) {
                 case 1: return DriverExecutionMode.Embedded;
                 case 2: return DriverExecutionMode.Daemon;
+                case 3: return DriverExecutionMode.PrivateWorker;
+                case 4: return DriverExecutionMode.Remote;
                 default: throw new UniffiInternalError.UnexpectedEnumCase();
             }
         }
@@ -813,6 +1523,8 @@ const FfiConverterTypeDriverExecutionMode = (() => {
             switch (value) {
                 case DriverExecutionMode.Embedded: return ordinalConverter.write(1, into);
                 case DriverExecutionMode.Daemon: return ordinalConverter.write(2, into);
+                case DriverExecutionMode.PrivateWorker: return ordinalConverter.write(3, into);
+                case DriverExecutionMode.Remote: return ordinalConverter.write(4, into);
             }
         }
         allocationSize(value) {
@@ -1283,46 +1995,170 @@ export class CuaDriver extends UniffiAbstractObject {
         /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
     }
     /**
-     * Language-package entry point for the same-process runtime. The wrapper
-     * at each package root selects the client kind automatically.
+     * Create a same-process runtime with an explicit immutable authorization
+     * ceiling. This is a trusted host constructor and is not exposed as an
+     * agent tool. Existing `create()` callers remain unchanged.
      */
-    static createWithClientKind(options, clientKind) {
+    static createConfigured(options) {
         return FfiConverterTypeCuaDriver.lift(uniffiCaller.rustCallWithError(
         /*liftError:*/ FfiConverterTypeDriverError.lift.bind(FfiConverterTypeDriverError), 
         /*caller:*/ (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);
+            return nativeModule().uniffi_cua_driver_sdk_fn_constructor_cuadriver_create_configured(FfiConverterTypeConfiguredDriverOptions.lower(options, nativeModule().rustbuffer_alloc), callStatus);
         }, 
         /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
     }
     /**
-     * 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.
+     * Create a configured same-process runtime with a content-free activity
+     * observer supplied by trusted embedding-host code.
      */
-    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) {
+    static createConfiguredWithActivityObserver(options, observer) {
+        return FfiConverterTypeCuaDriver.lift(uniffiCaller.rustCallWithError(
+        /*liftError:*/ FfiConverterTypeDriverError.lift.bind(FfiConverterTypeDriverError), 
+        /*caller:*/ (callStatus) => {
+            return nativeModule().uniffi_cua_driver_sdk_fn_constructor_cuadriver_create_configured_with_activity_observer(FfiConverterTypeConfiguredDriverOptions.lower(options, nativeModule().rustbuffer_alloc), FfiConverterTypeDriverActivityObserver.lower(observer, nativeModule().rustbuffer_alloc), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    /**
+     * Language-package entry point for a configured activity-observer runtime.
+     */
+    static createConfiguredWithActivityObserverAndClientKind(options, observer, clientKind) {
+        return FfiConverterTypeCuaDriver.lift(uniffiCaller.rustCallWithError(
+        /*liftError:*/ FfiConverterTypeDriverError.lift.bind(FfiConverterTypeDriverError), 
+        /*caller:*/ (callStatus) => {
+            return nativeModule().uniffi_cua_driver_sdk_fn_constructor_cuadriver_create_configured_with_activity_observer_and_client_kind(FfiConverterTypeConfiguredDriverOptions.lower(options, nativeModule().rustbuffer_alloc), FfiConverterTypeDriverActivityObserver.lower(observer, nativeModule().rustbuffer_alloc), FfiConverterTypeSdkClientKind.lower(clientKind, nativeModule().rustbuffer_alloc), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    /**
+     * Create a configured same-process runtime with an optional residual
+     * authorization callback supplied by trusted embedding-host code.
+     *
+     * The callback object is immutable runtime configuration. Applications
+     * must not expose it to an agent or implement it using ordinary MCP
+     * elicitation, model-visible stdio, or an auto-accepting callback.
+     */
+    static createConfiguredWithAuthorizationHost(options, host) {
+        return FfiConverterTypeCuaDriver.lift(uniffiCaller.rustCallWithError(
+        /*liftError:*/ FfiConverterTypeDriverError.lift.bind(FfiConverterTypeDriverError), 
+        /*caller:*/ (callStatus) => {
+            return nativeModule().uniffi_cua_driver_sdk_fn_constructor_cuadriver_create_configured_with_authorization_host(FfiConverterTypeConfiguredDriverOptions.lower(options, nativeModule().rustbuffer_alloc), FfiConverterTypeDriverAuthorizationHost.lower(host, nativeModule().rustbuffer_alloc), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    /**
+     * Language-package entry point for a configured protected-host runtime.
+     */
+    static createConfiguredWithAuthorizationHostAndClientKind(options, host, clientKind) {
+        return FfiConverterTypeCuaDriver.lift(uniffiCaller.rustCallWithError(
+        /*liftError:*/ FfiConverterTypeDriverError.lift.bind(FfiConverterTypeDriverError), 
+        /*caller:*/ (callStatus) => {
+            return nativeModule().uniffi_cua_driver_sdk_fn_constructor_cuadriver_create_configured_with_authorization_host_and_client_kind(FfiConverterTypeConfiguredDriverOptions.lower(options, nativeModule().rustbuffer_alloc), FfiConverterTypeDriverAuthorizationHost.lower(host, nativeModule().rustbuffer_alloc), FfiConverterTypeSdkClientKind.lower(clientKind, nativeModule().rustbuffer_alloc), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    /**
+     * Language-package entry point for an explicitly configured runtime.
+     */
+    static createConfiguredWithClientKind(options, clientKind) {
+        return FfiConverterTypeCuaDriver.lift(uniffiCaller.rustCallWithError(
+        /*liftError:*/ FfiConverterTypeDriverError.lift.bind(FfiConverterTypeDriverError), 
+        /*caller:*/ (callStatus) => {
+            return nativeModule().uniffi_cua_driver_sdk_fn_constructor_cuadriver_create_configured_with_client_kind(FfiConverterTypeConfiguredDriverOptions.lower(options, nativeModule().rustbuffer_alloc), FfiConverterTypeSdkClientKind.lower(clientKind, nativeModule().rustbuffer_alloc), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    /**
+     * Create a configured same-process runtime with both residual
+     * authorization and content-free activity callbacks.
+     */
+    static createConfiguredWithHostIntegrations(options, host, observer) {
+        return FfiConverterTypeCuaDriver.lift(uniffiCaller.rustCallWithError(
+        /*liftError:*/ FfiConverterTypeDriverError.lift.bind(FfiConverterTypeDriverError), 
+        /*caller:*/ (callStatus) => {
+            return nativeModule().uniffi_cua_driver_sdk_fn_constructor_cuadriver_create_configured_with_host_integrations(FfiConverterTypeConfiguredDriverOptions.lower(options, nativeModule().rustbuffer_alloc), FfiConverterTypeDriverAuthorizationHost.lower(host, nativeModule().rustbuffer_alloc), FfiConverterTypeDriverActivityObserver.lower(observer, nativeModule().rustbuffer_alloc), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    /**
+     * Language-package entry point for both trusted host callbacks.
+     */
+    static createConfiguredWithHostIntegrationsAndClientKind(options, host, observer, clientKind) {
+        return FfiConverterTypeCuaDriver.lift(uniffiCaller.rustCallWithError(
+        /*liftError:*/ FfiConverterTypeDriverError.lift.bind(FfiConverterTypeDriverError), 
+        /*caller:*/ (callStatus) => {
+            return nativeModule().uniffi_cua_driver_sdk_fn_constructor_cuadriver_create_configured_with_host_integrations_and_client_kind(FfiConverterTypeConfiguredDriverOptions.lower(options, nativeModule().rustbuffer_alloc), FfiConverterTypeDriverAuthorizationHost.lower(host, nativeModule().rustbuffer_alloc), FfiConverterTypeDriverActivityObserver.lower(observer, nativeModule().rustbuffer_alloc), FfiConverterTypeSdkClientKind.lower(clientKind, nativeModule().rustbuffer_alloc), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    /**
+     * Create a process-isolated runtime owned by this SDK object.
+     *
+     * This constructor directly spawns the supplied Cua Driver binary and
+     * communicates only over inherited stdio. No daemon or reusable endpoint
+     * is created.
+     */
+    static createPrivateWorker(options) {
+        return FfiConverterTypeCuaDriver.lift(uniffiCaller.rustCallWithError(
+        /*liftError:*/ FfiConverterTypeDriverError.lift.bind(FfiConverterTypeDriverError), 
+        /*caller:*/ (callStatus) => {
+            return nativeModule().uniffi_cua_driver_sdk_fn_constructor_cuadriver_create_private_worker(FfiConverterTypePrivateWorkerOptions.lower(options, nativeModule().rustbuffer_alloc), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    /**
+     * Language-package entry point that preserves the worker constructor
+     * while attaching the importing SDK runtime category.
+     */
+    static createPrivateWorkerWithClientKind(options, clientKind) {
+        return FfiConverterTypeCuaDriver.lift(uniffiCaller.rustCallWithError(
+        /*liftError:*/ FfiConverterTypeDriverError.lift.bind(FfiConverterTypeDriverError), 
+        /*caller:*/ (callStatus) => {
+            return nativeModule().uniffi_cua_driver_sdk_fn_constructor_cuadriver_create_private_worker_with_client_kind(FfiConverterTypePrivateWorkerOptions.lower(options, nativeModule().rustbuffer_alloc), FfiConverterTypeSdkClientKind.lower(clientKind, nativeModule().rustbuffer_alloc), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    /**
+     * 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_constructor_cuadriver_create_with_client_kind(FfiConverterOptionalTypeDriverOptions.lower(options, nativeModule().rustbuffer_alloc), FfiConverterTypeSdkClientKind.lower(clientKind, nativeModule().rustbuffer_alloc), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    /**
+     * 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;
             }
             throw __error;
@@ -1458,6 +2294,35 @@ export class CuaDriver extends UniffiAbstractObject {
         }, 
         /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
     }
+    async getAgentCursorState(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_agent_cursor_state(uniffiTypeCuaDriverObjectFactory.clonePointer(this), FfiConverterTypeGetAgentCursorStateInput.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;
+            }
+            throw __error;
+        }
+    }
     async getCursorPosition(input, asyncOpts_) {
         const __stack = uniffiIsDebug ? new Error().stack : undefined;
         try {
@@ -1610,16 +2475,801 @@ export class CuaDriver extends UniffiAbstractObject {
         }, 
         /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
     }
-    /**
-     * Canonical tool inventory for MCP and other protocol adapters.
-     */
-    async listToolsJson(asyncOpts_) {
+    /**
+     * 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;
+            }
+            throw __error;
+        }
+    }
+    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;
+            }
+            throw __error;
+        }
+    }
+    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;
+            }
+            throw __error;
+        }
+    }
+    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;
+            }
+            throw __error;
+        }
+    }
+    runtimeScopePrefix() {
+        return ((__rb) => {
+            try {
+                return FfiConverterOptionalString.lift(__rb);
+            }
+            finally {
+                nativeModule().rustbuffer_free(__rb);
+            }
+        })(uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().uniffi_cua_driver_sdk_fn_method_cuadriver_runtime_scope_prefix(uniffiTypeCuaDriverObjectFactory.clonePointer(this), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    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;
+            }
+            throw __error;
+        }
+    }
+    async setAgentCursorEnabled(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_set_agent_cursor_enabled(uniffiTypeCuaDriverObjectFactory.clonePointer(this), FfiConverterTypeSetAgentCursorEnabledInput.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;
+            }
+            throw __error;
+        }
+    }
+    async setAgentCursorMotion(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_set_agent_cursor_motion(uniffiTypeCuaDriverObjectFactory.clonePointer(this), FfiConverterTypeSetAgentCursorMotionInput.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;
+            }
+            throw __error;
+        }
+    }
+    async setAgentCursorTheme(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_set_agent_cursor_theme(uniffiTypeCuaDriverObjectFactory.clonePointer(this), FfiConverterTypeSetAgentCursorThemeInput.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;
+            }
+            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;
+            }
+            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 {
+                return FfiConverterString.lift(__rb);
+            }
+            finally {
+                nativeModule().rustbuffer_free(__rb);
+            }
+        })(uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().uniffi_cua_driver_sdk_fn_method_cuadriver_socket_path(uniffiTypeCuaDriverObjectFactory.clonePointer(this), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    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;
+            }
+            throw __error;
+        }
+    }
+    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;
+            }
+            throw __error;
+        }
+    }
+    uniffiDestroy() {
+        const ptr = this[destructorGuardSymbol];
+        if (ptr !== undefined) {
+            const pointer = uniffiTypeCuaDriverObjectFactory.pointer(this);
+            uniffiTypeCuaDriverObjectFactory.freePointer(pointer);
+            uniffiTypeCuaDriverObjectFactory.unbless(ptr);
+            delete this[destructorGuardSymbol];
+        }
+    }
+    static instanceOf(obj_) {
+        return uniffiTypeCuaDriverObjectFactory.isConcreteType(obj_);
+    }
+}
+const uniffiTypeCuaDriverObjectFactory = (() => {
+    /// <reference lib="es2021" />
+    const registry = typeof FinalizationRegistry !== 'undefined' ? new FinalizationRegistry((heldValue) => {
+        uniffiTypeCuaDriverObjectFactory.freePointer(heldValue);
+    }) : null;
+    return {
+        create(pointer) {
+            const instance = Object.create(CuaDriver.prototype);
+            instance[pointerLiteralSymbol] = pointer;
+            instance[destructorGuardSymbol] = this.bless(pointer);
+            instance[uniffiTypeNameSymbol] = "CuaDriver";
+            return instance;
+        },
+        bless(p) {
+            const ptr = {
+                p, // make sure this object doesn't get optimized away.
+                markDestroyed: () => undefined,
+            };
+            if (registry) {
+                registry.register(ptr, p, ptr);
+            }
+            return ptr;
+        },
+        unbless(ptr_) {
+            if (registry) {
+                registry.unregister(ptr_);
+            }
+        },
+        pointer(obj_) {
+            if (obj_[destructorGuardSymbol] === undefined) {
+                throw new UniffiInternalError.UnexpectedNullPointer();
+            }
+            return obj_[pointerLiteralSymbol];
+        },
+        clonePointer(obj_) {
+            const pointer = this.pointer(obj_);
+            return uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().uniffi_cua_driver_sdk_fn_clone_cuadriver(pointer, callStatus), 
+            /*liftString:*/ FfiConverterString.lift);
+        },
+        freePointer(pointer) {
+            uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().uniffi_cua_driver_sdk_fn_free_cuadriver(pointer, callStatus), 
+            /*liftString:*/ FfiConverterString.lift);
+        },
+        isConcreteType(obj_) {
+            return obj_[destructorGuardSymbol] && obj_[uniffiTypeNameSymbol] === "CuaDriver";
+        },
+    };
+})();
+const FfiConverterTypeCuaDriver = new FfiConverterObject(uniffiTypeCuaDriverObjectFactory);
+export class CuaDriverSession extends UniffiAbstractObject {
+    [uniffiTypeNameSymbol] = "CuaDriverSession";
+    [destructorGuardSymbol];
+    [pointerLiteralSymbol];
+    // No primary constructor declared for this class.
+    constructor(pointer) {
+        super();
+        this[pointerLiteralSymbol] = pointer;
+        this[destructorGuardSymbol] = uniffiTypeCuaDriverSessionObjectFactory.bless(pointer);
+    }
+    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_cuadriversession_call_tool(uniffiTypeCuaDriverSessionObjectFactory.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;
+            }
+            throw __error;
+        }
+    }
+    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_cuadriversession_click(uniffiTypeCuaDriverSessionObjectFactory.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;
+            }
+            throw __error;
+        }
+    }
+    /**
+     * Revoke the session-bound authority and release its native handle.
+     *
+     * This operation is idempotent. Dropping the object performs the same
+     * cleanup, but trusted hosts should call it at their lifecycle boundary.
+     */
+    close() {
+        uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            nativeModule().uniffi_cua_driver_sdk_fn_method_cuadriversession_close(uniffiTypeCuaDriverSessionObjectFactory.clonePointer(this), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString));
+    }
+    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_cuadriversession_drag(uniffiTypeCuaDriverSessionObjectFactory.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;
+            }
+            throw __error;
+        }
+    }
+    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_cuadriversession_end_session(uniffiTypeCuaDriverSessionObjectFactory.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;
+            }
+            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_cuadriversession_escalate_session(uniffiTypeCuaDriverSessionObjectFactory.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;
+            }
+            throw __error;
+        }
+    }
+    async getAgentCursorState(input, asyncOpts_) {
+        const __stack = uniffiIsDebug ? new Error().stack : undefined;
+        try {
+            return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller, 
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().uniffi_cua_driver_sdk_fn_method_cuadriversession_get_agent_cursor_state(uniffiTypeCuaDriverSessionObjectFactory.clonePointer(this), FfiConverterTypeGetAgentCursorStateInput.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;
+            }
+            throw __error;
+        }
+    }
+    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_cuadriversession_get_cursor_position(uniffiTypeCuaDriverSessionObjectFactory.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;
+            }
+            throw __error;
+        }
+    }
+    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_cuadriversession_get_desktop_state(uniffiTypeCuaDriverSessionObjectFactory.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;
+            }
+            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_cuadriversession_get_screen_size(uniffiTypeCuaDriverSessionObjectFactory.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;
+            }
+            throw __error;
+        }
+    }
+    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_cuadriversession_get_session_state(uniffiTypeCuaDriverSessionObjectFactory.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;
+            }
+            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_cuadriversession_hotkey(uniffiTypeCuaDriverSessionObjectFactory.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;
+            }
+            throw __error;
+        }
+    }
+    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_cuadriversession_move_cursor(uniffiTypeCuaDriverSessionObjectFactory.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;
+            }
+            throw __error;
+        }
+    }
+    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_list_tools_json(uniffiTypeCuaDriverObjectFactory.clonePointer(this));
+                return nativeModule().uniffi_cua_driver_sdk_fn_method_cuadriversession_press_key(uniffiTypeCuaDriverSessionObjectFactory.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, 
@@ -1630,7 +3280,7 @@ export class CuaDriver extends UniffiAbstractObject {
             // 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), 
+            /*liftFunc:*/ FfiConverterTypeToolResult.lift.bind(FfiConverterTypeToolResult), 
             /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString), 
             /*asyncOpts:*/ asyncOpts_, 
             /*errorHandler:*/ FfiConverterTypeDriverError.lift.bind(FfiConverterTypeDriverError));
@@ -1642,13 +3292,13 @@ export class CuaDriver extends UniffiAbstractObject {
             throw __error;
         }
     }
-    async metadata(asyncOpts_) {
+    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_metadata(uniffiTypeCuaDriverObjectFactory.clonePointer(this));
+                return nativeModule().uniffi_cua_driver_sdk_fn_method_cuadriversession_scroll(uniffiTypeCuaDriverSessionObjectFactory.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, 
@@ -1659,7 +3309,7 @@ export class CuaDriver extends UniffiAbstractObject {
             // 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), 
+            /*liftFunc:*/ FfiConverterTypeToolResult.lift.bind(FfiConverterTypeToolResult), 
             /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString), 
             /*asyncOpts:*/ asyncOpts_, 
             /*errorHandler:*/ FfiConverterTypeDriverError.lift.bind(FfiConverterTypeDriverError));
@@ -1671,13 +3321,13 @@ export class CuaDriver extends UniffiAbstractObject {
             throw __error;
         }
     }
-    async moveCursor(input, asyncOpts_) {
+    async setAgentCursorEnabled(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));
+                return nativeModule().uniffi_cua_driver_sdk_fn_method_cuadriversession_set_agent_cursor_enabled(uniffiTypeCuaDriverSessionObjectFactory.clonePointer(this), FfiConverterTypeSetAgentCursorEnabledInput.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, 
@@ -1700,13 +3350,13 @@ export class CuaDriver extends UniffiAbstractObject {
             throw __error;
         }
     }
-    async pressKey(input, asyncOpts_) {
+    async setAgentCursorMotion(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));
+                return nativeModule().uniffi_cua_driver_sdk_fn_method_cuadriversession_set_agent_cursor_motion(uniffiTypeCuaDriverSessionObjectFactory.clonePointer(this), FfiConverterTypeSetAgentCursorMotionInput.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, 
@@ -1729,13 +3379,13 @@ export class CuaDriver extends UniffiAbstractObject {
             throw __error;
         }
     }
-    async scroll(input, asyncOpts_) {
+    async setAgentCursorTheme(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));
+                return nativeModule().uniffi_cua_driver_sdk_fn_method_cuadriversession_set_agent_cursor_theme(uniffiTypeCuaDriverSessionObjectFactory.clonePointer(this), FfiConverterTypeSetAgentCursorThemeInput.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, 
@@ -1758,23 +3408,24 @@ export class CuaDriver extends UniffiAbstractObject {
             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_) {
+    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_shutdown(uniffiTypeCuaDriverObjectFactory.clonePointer(this));
+                return nativeModule().uniffi_cua_driver_sdk_fn_method_cuadriversession_start_session(uniffiTypeCuaDriverSessionObjectFactory.clonePointer(this), FfiConverterTypeStartSessionInput.lower(input, nativeModule().rustbuffer_alloc));
             }, 
-            /*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) => { }, 
+            /*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));
@@ -1786,31 +3437,13 @@ export class CuaDriver extends UniffiAbstractObject {
             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 {
-                return FfiConverterString.lift(__rb);
-            }
-            finally {
-                nativeModule().rustbuffer_free(__rb);
-            }
-        })(uniffiCaller.rustCall(
-        /*caller:*/ (callStatus) => {
-            return nativeModule().uniffi_cua_driver_sdk_fn_method_cuadriver_socket_path(uniffiTypeCuaDriverObjectFactory.clonePointer(this), callStatus);
-        }, 
-        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
-    }
-    async startSession(input, asyncOpts_) {
+    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_start_session(uniffiTypeCuaDriverObjectFactory.clonePointer(this), FfiConverterTypeStartSessionInput.lower(input, nativeModule().rustbuffer_alloc));
+                return nativeModule().uniffi_cua_driver_sdk_fn_method_cuadriversession_type_text(uniffiTypeCuaDriverSessionObjectFactory.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, 
@@ -1821,7 +3454,7 @@ export class CuaDriver extends UniffiAbstractObject {
             // 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), 
+            /*liftFunc:*/ FfiConverterTypeToolResult.lift.bind(FfiConverterTypeToolResult), 
             /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString), 
             /*asyncOpts:*/ asyncOpts_, 
             /*errorHandler:*/ FfiConverterTypeDriverError.lift.bind(FfiConverterTypeDriverError));
@@ -1833,13 +3466,217 @@ export class CuaDriver extends UniffiAbstractObject {
             throw __error;
         }
     }
-    async typeText(input, asyncOpts_) {
+    uniffiDestroy() {
+        const ptr = this[destructorGuardSymbol];
+        if (ptr !== undefined) {
+            const pointer = uniffiTypeCuaDriverSessionObjectFactory.pointer(this);
+            uniffiTypeCuaDriverSessionObjectFactory.freePointer(pointer);
+            uniffiTypeCuaDriverSessionObjectFactory.unbless(ptr);
+            delete this[destructorGuardSymbol];
+        }
+    }
+    static instanceOf(obj_) {
+        return uniffiTypeCuaDriverSessionObjectFactory.isConcreteType(obj_);
+    }
+}
+const uniffiTypeCuaDriverSessionObjectFactory = (() => {
+    /// <reference lib="es2021" />
+    const registry = typeof FinalizationRegistry !== 'undefined' ? new FinalizationRegistry((heldValue) => {
+        uniffiTypeCuaDriverSessionObjectFactory.freePointer(heldValue);
+    }) : null;
+    return {
+        create(pointer) {
+            const instance = Object.create(CuaDriverSession.prototype);
+            instance[pointerLiteralSymbol] = pointer;
+            instance[destructorGuardSymbol] = this.bless(pointer);
+            instance[uniffiTypeNameSymbol] = "CuaDriverSession";
+            return instance;
+        },
+        bless(p) {
+            const ptr = {
+                p, // make sure this object doesn't get optimized away.
+                markDestroyed: () => undefined,
+            };
+            if (registry) {
+                registry.register(ptr, p, ptr);
+            }
+            return ptr;
+        },
+        unbless(ptr_) {
+            if (registry) {
+                registry.unregister(ptr_);
+            }
+        },
+        pointer(obj_) {
+            if (obj_[destructorGuardSymbol] === undefined) {
+                throw new UniffiInternalError.UnexpectedNullPointer();
+            }
+            return obj_[pointerLiteralSymbol];
+        },
+        clonePointer(obj_) {
+            const pointer = this.pointer(obj_);
+            return uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().uniffi_cua_driver_sdk_fn_clone_cuadriversession(pointer, callStatus), 
+            /*liftString:*/ FfiConverterString.lift);
+        },
+        freePointer(pointer) {
+            uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().uniffi_cua_driver_sdk_fn_free_cuadriversession(pointer, callStatus), 
+            /*liftString:*/ FfiConverterString.lift);
+        },
+        isConcreteType(obj_) {
+            return obj_[destructorGuardSymbol] && obj_[uniffiTypeNameSymbol] === "CuaDriverSession";
+        },
+    };
+})();
+const FfiConverterTypeCuaDriverSession = new FfiConverterObject(uniffiTypeCuaDriverSessionObjectFactory);
+/**
+ * Optional observer implemented by trusted embedding-host code.
+ *
+ * Observations are informational and cannot grant authority or change a tool
+ * result. Implementations should return quickly and hand off expensive work.
+ */
+export class DriverActivityObserverImpl extends UniffiAbstractObject {
+    [uniffiTypeNameSymbol] = "DriverActivityObserverImpl";
+    [destructorGuardSymbol];
+    [pointerLiteralSymbol];
+    // No primary constructor declared for this class.
+    constructor(pointer) {
+        super();
+        this[pointerLiteralSymbol] = pointer;
+        this[destructorGuardSymbol] = uniffiTypeDriverActivityObserverImplObjectFactory.bless(pointer);
+    }
+    onActivity(event) {
+        uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            nativeModule().uniffi_cua_driver_sdk_fn_method_driveractivityobserver_on_activity(uniffiTypeDriverActivityObserverImplObjectFactory.clonePointer(this), FfiConverterTypeDriverActivityEvent.lower(event, nativeModule().rustbuffer_alloc), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString));
+    }
+    uniffiDestroy() {
+        const ptr = this[destructorGuardSymbol];
+        if (ptr !== undefined) {
+            const pointer = uniffiTypeDriverActivityObserverImplObjectFactory.pointer(this);
+            uniffiTypeDriverActivityObserverImplObjectFactory.freePointer(pointer);
+            uniffiTypeDriverActivityObserverImplObjectFactory.unbless(ptr);
+            delete this[destructorGuardSymbol];
+        }
+    }
+    static instanceOf(obj_) {
+        return uniffiTypeDriverActivityObserverImplObjectFactory.isConcreteType(obj_);
+    }
+}
+const uniffiTypeDriverActivityObserverImplObjectFactory = (() => {
+    /// <reference lib="es2021" />
+    const registry = typeof FinalizationRegistry !== 'undefined' ? new FinalizationRegistry((heldValue) => {
+        uniffiTypeDriverActivityObserverImplObjectFactory.freePointer(heldValue);
+    }) : null;
+    return {
+        create(pointer) {
+            const instance = Object.create(DriverActivityObserverImpl.prototype);
+            instance[pointerLiteralSymbol] = pointer;
+            instance[destructorGuardSymbol] = this.bless(pointer);
+            instance[uniffiTypeNameSymbol] = "DriverActivityObserverImpl";
+            return instance;
+        },
+        bless(p) {
+            const ptr = {
+                p, // make sure this object doesn't get optimized away.
+                markDestroyed: () => undefined,
+            };
+            if (registry) {
+                registry.register(ptr, p, ptr);
+            }
+            return ptr;
+        },
+        unbless(ptr_) {
+            if (registry) {
+                registry.unregister(ptr_);
+            }
+        },
+        pointer(obj_) {
+            if (obj_[destructorGuardSymbol] === undefined) {
+                throw new UniffiInternalError.UnexpectedNullPointer();
+            }
+            return obj_[pointerLiteralSymbol];
+        },
+        clonePointer(obj_) {
+            const pointer = this.pointer(obj_);
+            return uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().uniffi_cua_driver_sdk_fn_clone_driveractivityobserver(pointer, callStatus), 
+            /*liftString:*/ FfiConverterString.lift);
+        },
+        freePointer(pointer) {
+            uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().uniffi_cua_driver_sdk_fn_free_driveractivityobserver(pointer, callStatus), 
+            /*liftString:*/ FfiConverterString.lift);
+        },
+        isConcreteType(obj_) {
+            return obj_[destructorGuardSymbol] && obj_[uniffiTypeNameSymbol] === "DriverActivityObserverImpl";
+        },
+    };
+})();
+const FfiConverterTypeDriverActivityObserver = new FfiConverterObjectWithCallbacks(uniffiTypeDriverActivityObserverImplObjectFactory);
+// Add a vtable for the callbacks that go in DriverActivityObserver.
+// Put the implementation in a struct so we don't pollute the top-level namespace
+const uniffiCallbackInterfaceDriverActivityObserver = {
+    // Create the VTable using a series of closures.
+    // ts automatically converts these into C callback functions.
+    vtable: {
+        on_activity: (uniffiHandle, event) => {
+            const uniffiMakeCall = () => {
+                const jsCallback = FfiConverterTypeDriverActivityObserver.lift(uniffiHandle);
+                return jsCallback.onActivity(FfiConverterTypeDriverActivityEvent.lift(event));
+            };
+            const uniffiResult = UniffiResult.ready();
+            const uniffiHandleSuccess = (obj) => { };
+            const uniffiHandleError = (code, errBuf) => {
+                UniffiResult.writeError(uniffiResult, code, errBuf);
+            };
+            uniffiTraitInterfaceCall(
+            /*makeCall:*/ uniffiMakeCall, 
+            /*handleSuccess:*/ uniffiHandleSuccess, 
+            /*handleError:*/ uniffiHandleError, 
+            /*lowerString:*/ FfiConverterString.lower.bind(FfiConverterString), 
+            /*alloc:*/ nativeModule().rustbuffer_alloc);
+            return uniffiResult;
+        },
+        uniffi_free: (uniffiHandle) => {
+            // this will throw a stale handle error if the handle isn't found.
+            FfiConverterTypeDriverActivityObserver.drop(uniffiHandle);
+        },
+        uniffi_clone: (uniffiHandle) => {
+            return FfiConverterTypeDriverActivityObserver.clone(uniffiHandle);
+        }
+    },
+    register: () => {
+        nativeModule().uniffi_cua_driver_sdk_fn_init_callback_vtable_driveractivityobserver(uniffiCallbackInterfaceDriverActivityObserver.vtable);
+    },
+};
+/**
+ * Optional callback implemented by a trusted embedding application.
+ *
+ * Cua invokes this only for a residual boundary whose active permission mode
+ * requires a host grant. Routine standard-mode automation and every
+ * in-manifest bounded operation bypass it.
+ */
+export class DriverAuthorizationHostImpl extends UniffiAbstractObject {
+    [uniffiTypeNameSymbol] = "DriverAuthorizationHostImpl";
+    [destructorGuardSymbol];
+    [pointerLiteralSymbol];
+    // No primary constructor declared for this class.
+    constructor(pointer) {
+        super();
+        this[pointerLiteralSymbol] = pointer;
+        this[destructorGuardSymbol] = uniffiTypeDriverAuthorizationHostImplObjectFactory.bless(pointer);
+    }
+    async authorize(request, 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));
+                return nativeModule().uniffi_cua_driver_sdk_fn_method_driverauthorizationhost_authorize(uniffiTypeDriverAuthorizationHostImplObjectFactory.clonePointer(this), FfiConverterTypeDriverAuthorizationRequest.lower(request, 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, 
@@ -1850,10 +3687,10 @@ export class CuaDriver extends UniffiAbstractObject {
             // 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), 
+            /*liftFunc:*/ FfiConverterTypeDriverAuthorizationDecision.lift.bind(FfiConverterTypeDriverAuthorizationDecision), 
             /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString), 
             /*asyncOpts:*/ asyncOpts_, 
-            /*errorHandler:*/ FfiConverterTypeDriverError.lift.bind(FfiConverterTypeDriverError));
+            /*errorHandler:*/ FfiConverterTypeDriverAuthorizationHostError.lift.bind(FfiConverterTypeDriverAuthorizationHostError));
         }
         catch (__error) {
             if (uniffiIsDebug && __error instanceof Error) {
@@ -1865,27 +3702,27 @@ export class CuaDriver extends UniffiAbstractObject {
     uniffiDestroy() {
         const ptr = this[destructorGuardSymbol];
         if (ptr !== undefined) {
-            const pointer = uniffiTypeCuaDriverObjectFactory.pointer(this);
-            uniffiTypeCuaDriverObjectFactory.freePointer(pointer);
-            uniffiTypeCuaDriverObjectFactory.unbless(ptr);
+            const pointer = uniffiTypeDriverAuthorizationHostImplObjectFactory.pointer(this);
+            uniffiTypeDriverAuthorizationHostImplObjectFactory.freePointer(pointer);
+            uniffiTypeDriverAuthorizationHostImplObjectFactory.unbless(ptr);
             delete this[destructorGuardSymbol];
         }
     }
     static instanceOf(obj_) {
-        return uniffiTypeCuaDriverObjectFactory.isConcreteType(obj_);
+        return uniffiTypeDriverAuthorizationHostImplObjectFactory.isConcreteType(obj_);
     }
 }
-const uniffiTypeCuaDriverObjectFactory = (() => {
+const uniffiTypeDriverAuthorizationHostImplObjectFactory = (() => {
     /// <reference lib="es2021" />
     const registry = typeof FinalizationRegistry !== 'undefined' ? new FinalizationRegistry((heldValue) => {
-        uniffiTypeCuaDriverObjectFactory.freePointer(heldValue);
+        uniffiTypeDriverAuthorizationHostImplObjectFactory.freePointer(heldValue);
     }) : null;
     return {
         create(pointer) {
-            const instance = Object.create(CuaDriver.prototype);
+            const instance = Object.create(DriverAuthorizationHostImpl.prototype);
             instance[pointerLiteralSymbol] = pointer;
             instance[destructorGuardSymbol] = this.bless(pointer);
-            instance[uniffiTypeNameSymbol] = "CuaDriver";
+            instance[uniffiTypeNameSymbol] = "DriverAuthorizationHostImpl";
             return instance;
         },
         bless(p) {
@@ -1912,20 +3749,68 @@ const uniffiTypeCuaDriverObjectFactory = (() => {
         clonePointer(obj_) {
             const pointer = this.pointer(obj_);
             return uniffiCaller.rustCall(
-            /*caller:*/ (callStatus) => nativeModule().uniffi_cua_driver_sdk_fn_clone_cuadriver(pointer, callStatus), 
+            /*caller:*/ (callStatus) => nativeModule().uniffi_cua_driver_sdk_fn_clone_driverauthorizationhost(pointer, callStatus), 
             /*liftString:*/ FfiConverterString.lift);
         },
         freePointer(pointer) {
             uniffiCaller.rustCall(
-            /*caller:*/ (callStatus) => nativeModule().uniffi_cua_driver_sdk_fn_free_cuadriver(pointer, callStatus), 
+            /*caller:*/ (callStatus) => nativeModule().uniffi_cua_driver_sdk_fn_free_driverauthorizationhost(pointer, callStatus), 
             /*liftString:*/ FfiConverterString.lift);
         },
         isConcreteType(obj_) {
-            return obj_[destructorGuardSymbol] && obj_[uniffiTypeNameSymbol] === "CuaDriver";
+            return obj_[destructorGuardSymbol] && obj_[uniffiTypeNameSymbol] === "DriverAuthorizationHostImpl";
         },
     };
 })();
-const FfiConverterTypeCuaDriver = new FfiConverterObject(uniffiTypeCuaDriverObjectFactory);
+const FfiConverterTypeDriverAuthorizationHost = new FfiConverterObjectWithCallbacks(uniffiTypeDriverAuthorizationHostImplObjectFactory);
+// Add a vtable for the callbacks that go in DriverAuthorizationHost.
+// Put the implementation in a struct so we don't pollute the top-level namespace
+const uniffiCallbackInterfaceDriverAuthorizationHost = {
+    // Create the VTable using a series of closures.
+    // ts automatically converts these into C callback functions.
+    vtable: {
+        authorize: (uniffiHandle, request, uniffiFutureCallback, uniffiCallbackData) => {
+            const uniffiMakeCall = async (signal) => {
+                const jsCallback = FfiConverterTypeDriverAuthorizationHost.lift(uniffiHandle);
+                return await jsCallback.authorize(FfiConverterTypeDriverAuthorizationRequest.lift(request), { signal });
+            };
+            const uniffiHandleSuccess = (returnValue) => {
+                uniffiFutureCallback.call(uniffiFutureCallback, uniffiCallbackData, 
+                /* UniffiForeignFutureResultRustBuffer */ {
+                    return_value: FfiConverterTypeDriverAuthorizationDecision.lower(returnValue, nativeModule().rustbuffer_alloc),
+                    call_status: uniffiCaller.createCallStatus()
+                });
+            };
+            const uniffiHandleError = (code, errorBuf) => {
+                uniffiFutureCallback.call(uniffiFutureCallback, uniffiCallbackData, 
+                /* UniffiForeignFutureResultRustBuffer */ {
+                    return_value: /*empty*/ new Uint8Array(0),
+                    // TODO create callstatus with error.
+                    call_status: uniffiCaller.createErrorStatus(code, errorBuf),
+                });
+            };
+            const uniffiForeignFuture = uniffiTraitInterfaceCallAsyncWithError(
+            /*makeCall:*/ uniffiMakeCall, 
+            /*handleSuccess:*/ uniffiHandleSuccess, 
+            /*handleError:*/ uniffiHandleError, 
+            /*isErrorType:*/ DriverAuthorizationHostError.instanceOf, 
+            /*lowerError:*/ FfiConverterTypeDriverAuthorizationHostError.lower.bind(FfiConverterTypeDriverAuthorizationHostError), 
+            /*lowerString:*/ FfiConverterString.lower.bind(FfiConverterString), 
+            /*alloc:*/ nativeModule().rustbuffer_alloc);
+            return uniffiForeignFuture;
+        },
+        uniffi_free: (uniffiHandle) => {
+            // this will throw a stale handle error if the handle isn't found.
+            FfiConverterTypeDriverAuthorizationHost.drop(uniffiHandle);
+        },
+        uniffi_clone: (uniffiHandle) => {
+            return FfiConverterTypeDriverAuthorizationHost.clone(uniffiHandle);
+        }
+    },
+    register: () => {
+        nativeModule().uniffi_cua_driver_sdk_fn_init_callback_vtable_driverauthorizationhost(uniffiCallbackInterfaceDriverAuthorizationHost.vtable);
+    },
+};
 export class EmbeddedCuaDriverHost extends UniffiAbstractObject {
     [uniffiTypeNameSymbol] = "EmbeddedCuaDriverHost";
     [destructorGuardSymbol];
@@ -2152,6 +4037,8 @@ const uniffiTypeEmbeddedCuaDriverHostObjectFactory = (() => {
     };
 })();
 const FfiConverterTypeEmbeddedCuaDriverHost = new FfiConverterObject(uniffiTypeEmbeddedCuaDriverHostObjectFactory);
+// FfiConverter for Array<SessionPermissionMode>
+const FfiConverterSequenceTypeSessionPermissionMode = new FfiConverterArray(FfiConverterTypeSessionPermissionMode);
 // FfiConverter for string | undefined
 const FfiConverterOptionalString = new FfiConverterOptional(FfiConverterString);
 // FfiConverter for Array<string>
@@ -2190,6 +4077,9 @@ function uniffiEnsureInitialized() {
     if (bindingsContractVersion !== scaffoldingContractVersion) {
         throw new UniffiInternalError.ContractVersionMismatch(scaffoldingContractVersion, bindingsContractVersion);
     }
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_func_create_trusted_session() !== 50573) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_func_create_trusted_session");
+    }
     if (nativeModule().uniffi_cua_driver_sdk_checksum_func_current_mac_os_permission_status() !== 22890) {
         throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_func_current_mac_os_permission_status");
     }
@@ -2208,6 +4098,36 @@ function uniffiEnsureInitialized() {
     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_configured() !== 58596) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_constructor_cuadriver_create_configured");
+    }
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_constructor_cuadriver_create_configured_with_activity_observer() !== 37471) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_constructor_cuadriver_create_configured_with_activity_observer");
+    }
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_constructor_cuadriver_create_configured_with_activity_observer_and_client_kind() !== 50814) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_constructor_cuadriver_create_configured_with_activity_observer_and_client_kind");
+    }
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_constructor_cuadriver_create_configured_with_authorization_host() !== 28087) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_constructor_cuadriver_create_configured_with_authorization_host");
+    }
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_constructor_cuadriver_create_configured_with_authorization_host_and_client_kind() !== 17837) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_constructor_cuadriver_create_configured_with_authorization_host_and_client_kind");
+    }
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_constructor_cuadriver_create_configured_with_client_kind() !== 23819) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_constructor_cuadriver_create_configured_with_client_kind");
+    }
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_constructor_cuadriver_create_configured_with_host_integrations() !== 2578) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_constructor_cuadriver_create_configured_with_host_integrations");
+    }
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_constructor_cuadriver_create_configured_with_host_integrations_and_client_kind() !== 25294) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_constructor_cuadriver_create_configured_with_host_integrations_and_client_kind");
+    }
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_constructor_cuadriver_create_private_worker() !== 8571) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_constructor_cuadriver_create_private_worker");
+    }
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_constructor_cuadriver_create_private_worker_with_client_kind() !== 31571) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_constructor_cuadriver_create_private_worker_with_client_kind");
+    }
     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");
     }
@@ -2229,6 +4149,9 @@ function uniffiEnsureInitialized() {
     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_agent_cursor_state() !== 45642) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_method_cuadriver_get_agent_cursor_state");
+    }
     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");
     }
@@ -2259,9 +4182,21 @@ function uniffiEnsureInitialized() {
     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_runtime_scope_prefix() !== 2453) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_method_cuadriver_runtime_scope_prefix");
+    }
     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_set_agent_cursor_enabled() !== 26268) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_method_cuadriver_set_agent_cursor_enabled");
+    }
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_cuadriver_set_agent_cursor_motion() !== 12578) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_method_cuadriver_set_agent_cursor_motion");
+    }
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_cuadriver_set_agent_cursor_theme() !== 53908) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_method_cuadriver_set_agent_cursor_theme");
+    }
     if (nativeModule().uniffi_cua_driver_sdk_checksum_method_cuadriver_shutdown() !== 36331) {
         throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_method_cuadriver_shutdown");
     }
@@ -2274,6 +4209,72 @@ function uniffiEnsureInitialized() {
     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_method_cuadriversession_call_tool() !== 52859) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_method_cuadriversession_call_tool");
+    }
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_cuadriversession_click() !== 22303) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_method_cuadriversession_click");
+    }
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_cuadriversession_close() !== 58108) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_method_cuadriversession_close");
+    }
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_cuadriversession_drag() !== 5854) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_method_cuadriversession_drag");
+    }
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_cuadriversession_end_session() !== 42785) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_method_cuadriversession_end_session");
+    }
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_cuadriversession_escalate_session() !== 34392) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_method_cuadriversession_escalate_session");
+    }
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_cuadriversession_get_agent_cursor_state() !== 60344) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_method_cuadriversession_get_agent_cursor_state");
+    }
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_cuadriversession_get_cursor_position() !== 54838) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_method_cuadriversession_get_cursor_position");
+    }
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_cuadriversession_get_desktop_state() !== 26695) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_method_cuadriversession_get_desktop_state");
+    }
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_cuadriversession_get_screen_size() !== 9763) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_method_cuadriversession_get_screen_size");
+    }
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_cuadriversession_get_session_state() !== 55370) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_method_cuadriversession_get_session_state");
+    }
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_cuadriversession_hotkey() !== 12820) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_method_cuadriversession_hotkey");
+    }
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_cuadriversession_move_cursor() !== 35768) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_method_cuadriversession_move_cursor");
+    }
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_cuadriversession_press_key() !== 36768) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_method_cuadriversession_press_key");
+    }
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_cuadriversession_scroll() !== 8013) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_method_cuadriversession_scroll");
+    }
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_cuadriversession_set_agent_cursor_enabled() !== 37153) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_method_cuadriversession_set_agent_cursor_enabled");
+    }
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_cuadriversession_set_agent_cursor_motion() !== 26144) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_method_cuadriversession_set_agent_cursor_motion");
+    }
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_cuadriversession_set_agent_cursor_theme() !== 29734) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_method_cuadriversession_set_agent_cursor_theme");
+    }
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_cuadriversession_start_session() !== 13118) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_method_cuadriversession_start_session");
+    }
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_cuadriversession_type_text() !== 63241) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_method_cuadriversession_type_text");
+    }
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_driveractivityobserver_on_activity() !== 9786) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_method_driveractivityobserver_on_activity");
+    }
+    if (nativeModule().uniffi_cua_driver_sdk_checksum_method_driverauthorizationhost_authorize() !== 10089) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_method_driverauthorizationhost_authorize");
+    }
     if (nativeModule().uniffi_cua_driver_sdk_checksum_constructor_embeddedcuadriverhost_new() !== 10108) {
         throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_constructor_embeddedcuadriverhost_new");
     }
@@ -2298,11 +4299,24 @@ function uniffiEnsureInitialized() {
     if (nativeModule().uniffi_cua_driver_sdk_checksum_method_embeddedcuadriverhost_wait_for_exit() !== 21124) {
         throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cua_driver_sdk_checksum_method_embeddedcuadriverhost_wait_for_exit");
     }
+    uniffiCallbackInterfaceDriverActivityObserver.register();
+    uniffiCallbackInterfaceDriverAuthorizationHost.register();
 }
 export default Object.freeze({
     initialize: uniffiEnsureInitialized,
     converters: {
+        FfiConverterTypeActionCompletion,
+        FfiConverterTypeConfiguredDriverOptions,
         FfiConverterTypeCuaDriver,
+        FfiConverterTypeCuaDriverSession,
+        FfiConverterTypeDriverActivityEvent,
+        FfiConverterTypeDriverActivityKind,
+        FfiConverterTypeDriverActivityObserver,
+        FfiConverterTypeDriverAuthorizationAction,
+        FfiConverterTypeDriverAuthorizationDecision,
+        FfiConverterTypeDriverAuthorizationHost,
+        FfiConverterTypeDriverAuthorizationHostError,
+        FfiConverterTypeDriverAuthorizationRequest,
         FfiConverterTypeDriverError,
         FfiConverterTypeDriverExecutionMode,
         FfiConverterTypeDriverMetadata,
@@ -2318,7 +4332,11 @@ export default Object.freeze({
         FfiConverterTypeEmbeddedPermissionMode,
         FfiConverterTypeImageContent,
         FfiConverterTypeMacOsPermissionStatus,
+        FfiConverterTypePrivateWorkerOptions,
+        FfiConverterTypeRuntimeAuthorizationOptions,
         FfiConverterTypeSdkClientKind,
+        FfiConverterTypeSessionPermissionMode,
         FfiConverterTypeToolResult,
+        FfiConverterTypeTrustedSessionOptions,
     }
 });