wuying-agentbay-sdk 0.10.2 → 0.11.0

package/dist/index.d.ts

@@ -5,27 +5,6 @@ interface Config {
     endpoint: string;
     timeout_ms: number;
 }
-/**
- * Load .env file into process.env if it exists
- * This function should be called early to ensure .env variables are available
- * @deprecated Use loadDotEnvWithFallback instead
- */
-declare function loadDotEnv(): void;
-/**
- * The SDK uses the following precedence order for configuration (highest to lowest):
- * 1. Explicitly passed configuration in code.
- * 2. Environment variables.
- * 3. .env file.
- * 4. Default configuration.
- */
-/**
- * Load configuration with improved .env file search.
- *
- * @param customConfig Configuration object (if provided, skips env loading)
- * @param customEnvPath Custom path to .env file (optional)
- * @returns Configuration object
- */
-declare function loadConfig(customConfig?: Config, customEnvPath?: string): Config;
 
 /**
  * Version information for the AgentBay SDK
@@ -817,6 +796,137 @@ declare class GetLinkResponse extends $dara.Model {
     });
 }
 
+declare class GetCdpLinkRequest extends $dara.Model {
+    authorization?: string;
+    sessionId?: string;
+    static names(): {
+        [key: string]: string;
+    };
+    static types(): {
+        [key: string]: any;
+    };
+    validate(): void;
+    constructor(map?: {
+        [key: string]: any;
+    });
+}
+
+declare class GetCdpLinkResponseBodyData extends $dara.Model {
+    url?: string;
+    static names(): {
+        [key: string]: string;
+    };
+    static types(): {
+        [key: string]: any;
+    };
+    validate(): void;
+    constructor(map?: {
+        [key: string]: any;
+    });
+}
+declare class GetCdpLinkResponseBody extends $dara.Model {
+    code?: string;
+    data?: GetCdpLinkResponseBodyData;
+    httpStatusCode?: number;
+    message?: string;
+    requestId?: string;
+    success?: boolean;
+    static names(): {
+        [key: string]: string;
+    };
+    static types(): {
+        [key: string]: any;
+    };
+    validate(): void;
+    constructor(map?: {
+        [key: string]: any;
+    });
+}
+
+declare class GetCdpLinkResponse extends $dara.Model {
+    headers?: {
+        [key: string]: string;
+    };
+    statusCode?: number;
+    body?: GetCdpLinkResponseBody;
+    static names(): {
+        [key: string]: string;
+    };
+    static types(): {
+        [key: string]: any;
+    };
+    validate(): void;
+    constructor(map?: {
+        [key: string]: any;
+    });
+}
+
+declare class GetAdbLinkRequest extends $dara.Model {
+    authorization?: string;
+    option?: string;
+    sessionId?: string;
+    static names(): {
+        [key: string]: string;
+    };
+    static types(): {
+        [key: string]: any;
+    };
+    validate(): void;
+    constructor(map?: {
+        [key: string]: any;
+    });
+}
+
+declare class GetAdbLinkResponseBodyData extends $dara.Model {
+    url?: string;
+    static names(): {
+        [key: string]: string;
+    };
+    static types(): {
+        [key: string]: any;
+    };
+    validate(): void;
+    constructor(map?: {
+        [key: string]: any;
+    });
+}
+declare class GetAdbLinkResponseBody extends $dara.Model {
+    code?: string;
+    data?: GetAdbLinkResponseBodyData;
+    httpStatusCode?: number;
+    message?: string;
+    requestId?: string;
+    success?: boolean;
+    static names(): {
+        [key: string]: string;
+    };
+    static types(): {
+        [key: string]: any;
+    };
+    validate(): void;
+    constructor(map?: {
+        [key: string]: any;
+    });
+}
+
+declare class GetAdbLinkResponse extends $dara.Model {
+    headers?: {
+        [key: string]: string;
+    };
+    statusCode?: number;
+    body?: GetAdbLinkResponseBody;
+    static names(): {
+        [key: string]: string;
+    };
+    static types(): {
+        [key: string]: any;
+    };
+    validate(): void;
+    constructor(map?: {
+        [key: string]: any;
+    });
+}
+
 declare class GetMcpResourceRequest extends $dara.Model {
     authorization?: string;
     sessionId?: string;
@@ -1929,6 +2039,36 @@ declare class Client extends OpenApi {
      * @returns GetContextFileUploadUrlResponse
      */
     getContextFileUploadUrl(request: GetContextFileUploadUrlRequest): Promise<GetContextFileUploadUrlResponse>;
+    /**
+     * Get CDP link
+     *
+     * @param request - GetCdpLinkRequest
+     * @param runtime - runtime options for this request RuntimeOptions
+     * @returns GetCdpLinkResponse
+     */
+    getCdpLinkWithOptions(request: GetCdpLinkRequest, runtime: $dara.RuntimeOptions): Promise<GetCdpLinkResponse>;
+    /**
+     * Get CDP link
+     *
+     * @param request - GetCdpLinkRequest
+     * @returns GetCdpLinkResponse
+     */
+    getCdpLink(request: GetCdpLinkRequest): Promise<GetCdpLinkResponse>;
+    /**
+     * Get ADB link
+     *
+     * @param request - GetAdbLinkRequest
+     * @param runtime - runtime options for this request RuntimeOptions
+     * @returns GetAdbLinkResponse
+     */
+    getAdbLinkWithOptions(request: GetAdbLinkRequest, runtime: $dara.RuntimeOptions): Promise<GetAdbLinkResponse>;
+    /**
+     * Get ADB link
+     *
+     * @param request - GetAdbLinkRequest
+     * @returns GetAdbLinkResponse
+     */
+    getAdbLink(request: GetAdbLinkRequest): Promise<GetAdbLinkResponse>;
 }
 
 /**
@@ -2028,46 +2168,6 @@ interface OperationResult extends ApiResponse {
     /** Optional error message if the operation failed */
     errorMessage?: string;
 }
-/**
- * Interface for process list operation responses
- * Corresponds to Python's ProcessListResult type
- */
-interface ProcessListResult extends ApiResponse {
-    /** Request identifier for tracking API calls */
-    requestId: string;
-    /** Whether the operation was successful */
-    success: boolean;
-    /** The list of process objects */
-    data: any[];
-    /** Optional error message if the operation failed */
-    errorMessage?: string;
-}
-/**
- * Interface for installed app list operation responses
- * Corresponds to Python's InstalledAppListResult type
- */
-interface InstalledAppListResult extends ApiResponse {
-    /** Request identifier for tracking API calls */
-    requestId: string;
-    /** Whether the operation was successful */
-    success: boolean;
-    /** The list of installed app objects */
-    data: any[];
-    /** Optional error message if the operation failed */
-    errorMessage?: string;
-}
-/**
- * Interface for application operation responses
- * Corresponds to Python's AppOperationResult type
- */
-interface AppOperationResult extends ApiResponse {
-    /** Request identifier for tracking API calls */
-    requestId: string;
-    /** Whether the operation was successful */
-    success: boolean;
-    /** Optional error message if the operation failed */
-    errorMessage?: string;
-}
 /**
  * Interface for command execution operation responses
  * Corresponds to Python's CommandResult type
@@ -2222,20 +2322,6 @@ interface OSSDownloadResult extends ApiResponse {
     /** Optional error message if the operation failed */
     errorMessage?: string;
 }
-/**
- * Interface for UI element list operation responses
- * Corresponds to Python's UIElementListResult type
- */
-interface UIElementListResult extends ApiResponse {
-    /** Request identifier for tracking API calls */
-    requestId: string;
-    /** Whether the operation was successful */
-    success: boolean;
-    /** UI elements */
-    elements: Record<string, any>[];
-    /** Optional error message if the operation failed */
-    errorMessage?: string;
-}
 /**
  * Interface for window list operation responses
  * Corresponds to Python's WindowListResult type
@@ -2380,10 +2466,6 @@ declare class Context {
      * The name of the context.
      */
     name: string;
-    /**
-     * @deprecated This field is no longer used and will be removed in a future version.
-     */
-    state: string;
     /**
      * Date and time when the Context was created.
      */
@@ -2392,21 +2474,15 @@ declare class Context {
      * Date and time when the Context was last used.
      */
     lastUsedAt?: string;
-    /**
-     * @deprecated This field is no longer used and will be removed in a future version.
-     */
-    osType?: string;
     /**
      * Initialize a Context object.
      *
      * @param id - The unique identifier of the context.
      * @param name - The name of the context.
-     * @param state - **Deprecated.** This parameter is no longer used.
      * @param createdAt - Date and time when the Context was created.
      * @param lastUsedAt - Date and time when the Context was last used.
-     * @param osType - **Deprecated.** This parameter is no longer used.
      */
-    constructor(id: string, name: string, state?: string, createdAt?: string, lastUsedAt?: string, osType?: string);
+    constructor(id: string, name: string, createdAt?: string, lastUsedAt?: string);
 }
 /**
  * Parameters for listing contexts with pagination support.
@@ -2439,15 +2515,37 @@ declare class ContextService {
      *
      * @param params - Optional parameters for listing contexts.
      * @returns ContextListResult with contexts list and pagination information
+     *
+     * @example
+     * ```typescript
+     * const agentBay = new AgentBay({ apiKey: 'your_api_key' });
+     * const result = await agentBay.context.list({ maxResults: 10 });
+     * if (result.success) {
+     *   console.log(`Total contexts: ${result.totalCount}`);
+     *   console.log(`Page has ${result.contexts.length} contexts`);
+     * }
+     * ```
      */
     list(params?: ContextListParams): Promise<ContextListResult>;
     /**
-     * Gets a context by name. Optionally creates it if it doesn't exist.
-     * Corresponds to Python's get() method
+     * Retrieves an existing context or creates a new one.
+     *
+     * @param name - The name of the context to retrieve or create.
+     * @param create - If true, creates the context if it doesn't exist. Defaults to false.
+     *
+     * @returns Promise resolving to ContextResult containing the Context object.
+     *
+     * @example
+     * ```typescript
+     * const agentBay = new AgentBay({ apiKey: 'your_api_key' });
+     * const result = await agentBay.context.get('my-context', true);
+     * if (result.success) {
+     *   console.log(`Context ID: ${result.context.id}`);
+     *   console.log(`Context Name: ${result.context.name}`);
+     * }
+     * ```
      *
-     * @param name - The name of the context to get.
-     * @param create - Whether to create the context if it doesn't exist.
-     * @returns ContextResult with context data and requestId
+     * @see {@link update}, {@link list}
      */
     get(name: string, create?: boolean): Promise<ContextResult>;
     /**
@@ -2456,14 +2554,37 @@ declare class ContextService {
      *
      * @param name - The name for the new context.
      * @returns ContextResult with created context data and requestId
+     *
+     * @example
+     * ```typescript
+     * const agentBay = new AgentBay({ apiKey: 'your_api_key' });
+     * const result = await agentBay.context.create('my-new-context');
+     * if (result.success) {
+     *   console.log(`Context ID: ${result.context.id}`);
+     *   console.log(`Context Name: ${result.context.name}`);
+     * }
+     * ```
      */
     create(name: string): Promise<ContextResult>;
     /**
-     * Updates the specified context.
-     * Corresponds to Python's update() method
+     * Updates a context's name.
+     *
+     * @param context - The Context object with updated name.
+     *
+     * @returns Promise resolving to OperationResult with success status.
+     *
+     * @example
+     * ```typescript
+     * const agentBay = new AgentBay({ apiKey: 'your_api_key' });
+     * const getResult = await agentBay.context.get('old-name');
+     * if (getResult.success && getResult.context) {
+     *   getResult.context.name = 'new-name';
+     *   const updateResult = await agentBay.context.update(getResult.context);
+     *   console.log('Context updated:', updateResult.success);
+     * }
+     * ```
      *
-     * @param context - The Context object to update.
-     * @returns OperationResult with updated context data and requestId
+     * @see {@link get}, {@link list}
      */
     update(context: Context): Promise<OperationResult>;
     /**
@@ -2472,22 +2593,93 @@ declare class ContextService {
      *
      * @param context - The Context object to delete.
      * @returns OperationResult with requestId
+     *
+     * @example
+     * ```typescript
+     * const agentBay = new AgentBay({ apiKey: 'your_api_key' });
+     * const getResult = await agentBay.context.get('my-context');
+     * if (getResult.success && getResult.context) {
+     *   const deleteResult = await agentBay.context.delete(getResult.context);
+     *   console.log('Context deleted:', deleteResult.success);
+     * }
+     * ```
      */
     delete(context: Context): Promise<OperationResult>;
     /**
      * Get a presigned upload URL for a file in a context.
+     *
+     * @param contextId - The ID of the context.
+     * @param filePath - The path to the file in the context.
+     * @returns FileUrlResult with the presigned URL and expiration time.
+     *
+     * @example
+     * ```typescript
+     * const agentBay = new AgentBay({ apiKey: 'your_api_key' });
+     * const contextResult = await agentBay.context.get('my-context', true);
+     * if (contextResult.success) {
+     *   const urlResult = await agentBay.context.getFileUploadUrl(contextResult.context.id, '/data/file.txt');
+     *   console.log('Upload URL:', urlResult.url);
+     *   console.log('Expires at:', urlResult.expireTime);
+     * }
+     * ```
      */
     getFileUploadUrl(contextId: string, filePath: string): Promise<FileUrlResult>;
     /**
      * Get a presigned download URL for a file in a context.
+     *
+     * @param contextId - The ID of the context.
+     * @param filePath - The path to the file in the context.
+     * @returns FileUrlResult with the presigned URL and expiration time.
+     *
+     * @example
+     * ```typescript
+     * const agentBay = new AgentBay({ apiKey: 'your_api_key' });
+     * const contextResult = await agentBay.context.get('my-context');
+     * if (contextResult.success) {
+     *   const urlResult = await agentBay.context.getFileDownloadUrl(contextResult.context.id, '/data/file.txt');
+     *   console.log('Download URL:', urlResult.url);
+     *   console.log('Expires at:', urlResult.expireTime);
+     * }
+     * ```
      */
     getFileDownloadUrl(contextId: string, filePath: string): Promise<FileUrlResult>;
     /**
      * Delete a file in a context.
+     *
+     * @param contextId - The ID of the context.
+     * @param filePath - The path to the file to delete.
+     * @returns OperationResult indicating success or failure.
+     *
+     * @example
+     * ```typescript
+     * const agentBay = new AgentBay({ apiKey: 'your_api_key' });
+     * const contextResult = await agentBay.context.get('my-context');
+     * if (contextResult.success) {
+     *   const deleteResult = await agentBay.context.deleteFile(contextResult.context.id, '/data/file.txt');
+     *   console.log('File deleted:', deleteResult.success);
+     * }
+     * ```
      */
     deleteFile(contextId: string, filePath: string): Promise<OperationResult>;
     /**
      * List files under a specific folder path in a context.
+     *
+     * @param contextId - The ID of the context.
+     * @param parentFolderPath - The parent folder path to list files from.
+     * @param pageNumber - Page number for pagination (default: 1).
+     * @param pageSize - Number of files per page (default: 50).
+     * @returns ContextFileListResult with file entries and total count.
+     *
+     * @example
+     * ```typescript
+     * const agentBay = new AgentBay({ apiKey: 'your_api_key' });
+     * const contextResult = await agentBay.context.get('my-context');
+     * if (contextResult.success) {
+     *   const listResult = await agentBay.context.listFiles(contextResult.context.id, '/data');
+     *   console.log(`Found ${listResult.entries.length} files`);
+     *   console.log(`Total count: ${listResult.count}`);
+     * }
+     * ```
      */
     listFiles(contextId: string, parentFolderPath: string, pageNumber?: number, pageSize?: number): Promise<ContextFileListResult>;
     /**
@@ -2501,6 +2693,17 @@ declare class ContextService {
      * @returns A ClearContextResult object indicating the task has been successfully started,
      *          with status field set to "clearing".
      * @throws APIError - If the backend API rejects the clearing request (e.g., invalid ID).
+     *
+     * @example
+     * ```typescript
+     * const agentBay = new AgentBay({ apiKey: 'your_api_key' });
+     * const getResult = await agentBay.context.get('my-context');
+     * if (getResult.success) {
+     *   const clearResult = await agentBay.context.clearAsync(getResult.context.id);
+     *   console.log('Clear task started:', clearResult.success);
+     *   console.log('Status:', clearResult.status);
+     * }
+     * ```
      */
     clearAsync(contextId: string): Promise<ClearContextResult>;
     /**
@@ -2511,6 +2714,16 @@ declare class ContextService {
      *
      * @param contextId - ID of the context.
      * @returns ClearContextResult object containing the current task status.
+     *
+     * @example
+     * ```typescript
+     * const agentBay = new AgentBay({ apiKey: 'your_api_key' });
+     * const getResult = await agentBay.context.get('my-context');
+     * if (getResult.success) {
+     *   const statusResult = await agentBay.context.getClearStatus(getResult.context.id);
+     *   console.log('Current status:', statusResult.status);
+     * }
+     * ```
      */
     getClearStatus(contextId: string): Promise<ClearContextResult>;
     /**
@@ -2529,6 +2742,17 @@ declare class ContextService {
      * @returns A ClearContextResult object containing the final task result.
      *          The status field will be "available" on success, or other states if interrupted.
      * @throws APIError - If the task fails to complete within the specified timeout.
+     *
+     * @example
+     * ```typescript
+     * const agentBay = new AgentBay({ apiKey: 'your_api_key' });
+     * const getResult = await agentBay.context.get('my-context');
+     * if (getResult.success) {
+     *   const clearResult = await agentBay.context.clear(getResult.context.id);
+     *   console.log('Context cleared:', clearResult.success);
+     *   console.log('Final status:', clearResult.status);
+     * }
+     * ```
      */
     clear(contextId: string, timeout?: number, pollInterval?: number): Promise<ClearContextResult>;
 }
@@ -2601,6 +2825,9 @@ declare class WhiteListValidator {
 interface BWList {
     whiteLists?: WhiteList[];
 }
+interface MappingPolicy {
+    path: string;
+}
 interface SyncPolicy {
     uploadPolicy?: UploadPolicy;
     downloadPolicy?: DownloadPolicy;
@@ -2608,6 +2835,7 @@ interface SyncPolicy {
     extractPolicy?: ExtractPolicy;
     recyclePolicy?: RecyclePolicy;
     bwList?: BWList;
+    mappingPolicy?: MappingPolicy;
 }
 declare class SyncPolicyImpl implements SyncPolicy {
     uploadPolicy?: UploadPolicy;
@@ -2632,8 +2860,8 @@ declare function newDownloadPolicy(): DownloadPolicy;
 declare function newDeletePolicy(): DeletePolicy;
 declare function newExtractPolicy(): ExtractPolicy;
 declare function newRecyclePolicy(): RecyclePolicy;
+declare function newMappingPolicy(): MappingPolicy;
 declare function newSyncPolicy(): SyncPolicy;
-declare function validateSyncPolicy(policy?: SyncPolicy): void;
 declare function newSyncPolicyWithDefaults(policy?: Partial<SyncPolicy>): SyncPolicy;
 declare function newContextSync(contextId: string, path: string, policy?: SyncPolicy): ContextSync;
 
@@ -2688,13 +2916,36 @@ declare class Agent {
      * @param task - Task description in human language.
      * @param maxTryTimes - Maximum number of retry attempts.
      * @returns ExecutionResult containing success status, task output, and error message if any.
-     */
-    executeTask(task: string, maxTryTimes: number): Promise<ExecutionResult>;
+     *
+     * @example
+     * ```typescript
+     * const agentBay = new AgentBay({ apiKey: 'your_api_key' });
+     * const result = await agentBay.create({ imageId: 'windows_latest' });
+     * if (result.success) {
+     *   const taskResult = await result.session.agent.executeTask('Open notepad', 10);
+     *   console.log(`Task status: ${taskResult.taskStatus}`);
+     *   await result.session.delete();
+     * }
+     * ```
+     */
+    executeTask(task: string, maxTryTimes: number): Promise<ExecutionResult>;
     /**
      * Get the status of the task with the given task ID.
      *
      * @param taskId - Task ID
      * @returns QueryResult containing the task status
+     *
+     * @example
+     * ```typescript
+     * const agentBay = new AgentBay({ apiKey: 'your_api_key' });
+     * const result = await agentBay.create({ imageId: 'windows_latest' });
+     * if (result.success) {
+     *   const taskResult = await result.session.agent.executeTask('Open calculator', 10);
+     *   const statusResult = await result.session.agent.getTaskStatus(taskResult.taskId);
+     *   console.log(`Status: ${JSON.parse(statusResult.output).status}`);
+     *   await result.session.delete();
+     * }
+     * ```
      */
     getTaskStatus(taskId: string): Promise<QueryResult>;
     /**
@@ -2702,137 +2953,20 @@ declare class Agent {
      *
      * @param taskId - The ID of the running task.
      * @returns ExecutionResult containing success status, task output, and error message if any.
-     */
-    terminateTask(taskId: string): Promise<ExecutionResult>;
-}
-
-/**
- * Represents an installed application
- */
-interface InstalledApp$1 {
-    name: string;
-    start_cmd: string;
-    stop_cmd?: string;
-    work_directory?: string;
-}
-/**
- * Represents a running process
- */
-interface Process$1 {
-    pname: string;
-    pid: number;
-    cmdline?: string;
-    path?: string;
-}
-/**
- * Handles application operations in the AgentBay cloud environment.
- *
- * @deprecated This module is deprecated. Use Computer or Mobile modules instead.
- * - For desktop applications, use session.computer
- * - For mobile applications, use session.mobile
- */
-declare class Application {
-    private session;
-    /**
-     * Initialize an Application object.
-     *
-     * @param session - The Session instance that this Application belongs to.
-     */
-    constructor(session: {
-        getAPIKey(): string;
-        getClient(): Client;
-        getSessionId(): string;
-        callMcpTool(toolName: string, args: any): Promise<{
-            success: boolean;
-            data: string;
-            errorMessage: string;
-            requestId: string;
-        }>;
-    });
-    /**
-     * Sanitizes error messages to remove sensitive information like API keys.
-     *
-     * @param error - The error to sanitize
-     * @returns The sanitized error
-     */
-    private sanitizeError;
-    /**
-     * Helper method to parse JSON string into objects
-     */
-    private parseJSON;
-    /**
-     * Get a list of installed applications.
-     *
-     * @param startMenu - Whether to include start menu applications.
-     * @param desktop - Whether to include desktop applications.
-     * @param ignoreSystemApps - Whether to ignore system applications.
-     * @returns A promise that resolves to the list of installed applications.
-     *
-     * @deprecated Use session.computer.getInstalledApps() for desktop or session.mobile.getInstalledApps() for mobile instead.
-     */
-    getInstalledApps(startMenu?: boolean, desktop?: boolean, ignoreSystemApps?: boolean): Promise<InstalledAppListResult>;
-    /**
-     * Start an application.
-     *
-     * @param startCmd - The command to start the application.
-     * @param workDirectory - The working directory for the application.
-     * @param activity - The activity to start (for mobile applications).
-     * @returns A promise that resolves to the result of starting the application.
-     *
-     * @deprecated Use session.computer.startApp() for desktop or session.mobile.startApp() for mobile instead.
-     */
-    startApp(startCmd: string, workDirectory?: string, activity?: string): Promise<ProcessListResult>;
-    /**
-     * Stop an application by process name.
-     *
-     * @param pname - The process name of the application to stop.
-     * @returns A promise that resolves to the result of stopping the application.
      *
-     * @deprecated Use session.computer.stopAppByPName() for desktop or session.mobile.stopAppByPName() for mobile instead.
-     */
-    stopAppByPName(pname: string): Promise<AppOperationResult>;
-    /**
-     * Stops an application by process ID.
-     * Corresponds to Python's stop_app_by_pid() method
-     *
-     * @param pid - The process ID to stop.
-     * @returns AppOperationResult with operation result and requestId
-     * @throws Error if the operation fails.
-     */
-    stopAppByPID(pid: number): Promise<AppOperationResult>;
-    /**
-     * Stop an application by command.
-     *
-     * @param cmd - The command to stop the application.
-     * @returns A promise that resolves to the result of stopping the application.
-     *
-     * @deprecated Use session.computer.stopAppByCmd() for desktop or session.mobile.stopAppByCmd() for mobile instead.
-     */
-    stopAppByCmd(cmd: string): Promise<AppOperationResult>;
-    /**
-     * Returns a list of currently visible applications.
-     * Corresponds to Python's list_visible_apps() method
-     *
-     * @returns ProcessListResult with visible apps and requestId
-     * @throws Error if the operation fails.
-     */
-    listVisibleApps(): Promise<ProcessListResult>;
-    /**
-     * Get a list of running processes.
-     *
-     * @returns A promise that resolves to the list of running processes.
-     *
-     * @deprecated Use session.computer.getRunningProcesses() for desktop or session.mobile.getRunningProcesses() for mobile instead.
-     */
-    getRunningProcesses(): Promise<ProcessListResult>;
-    /**
-     * Get a list of visible applications.
-     *
-     * @returns A promise that resolves to the list of visible applications.
-     *
-     * @deprecated Use session.computer.getVisibleApps() for desktop instead. This API is not available for mobile.
+     * @example
+     * ```typescript
+     * const agentBay = new AgentBay({ apiKey: 'your_api_key' });
+     * const result = await agentBay.create({ imageId: 'windows_latest' });
+     * if (result.success) {
+     *   const taskResult = await result.session.agent.executeTask('Open notepad', 5);
+     *   const terminateResult = await result.session.agent.terminateTask(taskResult.taskId);
+     *   console.log(`Terminated: ${terminateResult.taskStatus}`);
+     *   await result.session.delete();
+     * }
+     * ```
      */
-    getVisibleApps(): Promise<InstalledAppListResult>;
+    terminateTask(taskId: string): Promise<ExecutionResult>;
 }
 
 interface ActOptions {
@@ -2889,6 +3023,187 @@ declare class BrowserAgent {
     private _delay;
 }
 
+/**
+ * Screen fingerprint data structure.
+ */
+interface ScreenFingerprint {
+    availHeight: number;
+    availWidth: number;
+    availTop: number;
+    availLeft: number;
+    colorDepth: number;
+    height: number;
+    pixelDepth: number;
+    width: number;
+    devicePixelRatio: number;
+    pageXOffset: number;
+    pageYOffset: number;
+    innerHeight: number;
+    outerHeight: number;
+    outerWidth: number;
+    innerWidth: number;
+    screenX: number;
+    clientWidth: number;
+    clientHeight: number;
+    hasHDR: boolean;
+}
+/**
+ * Brand information data structure.
+ */
+interface Brand {
+    brand: string;
+    version: string;
+}
+/**
+ * User agent data structure.
+ */
+interface UserAgentData {
+    brands: Brand[];
+    mobile: boolean;
+    platform: string;
+    architecture: string;
+    bitness: string;
+    fullVersionList: Brand[];
+    model: string;
+    platformVersion: string;
+    uaFullVersion: string;
+}
+/**
+ * Navigator extra properties data structure.
+ */
+interface ExtraProperties {
+    vendorFlavors: string[];
+    isBluetoothSupported: boolean;
+    globalPrivacyControl?: any;
+    pdfViewerEnabled: boolean;
+    installedApps: any[];
+}
+/**
+ * Navigator fingerprint data structure.
+ */
+interface NavigatorFingerprint {
+    userAgent: string;
+    userAgentData: UserAgentData;
+    doNotTrack: string;
+    appCodeName: string;
+    appName: string;
+    appVersion: string;
+    oscpu: string;
+    webdriver: string;
+    language: string;
+    languages: string[];
+    platform: string;
+    deviceMemory?: number;
+    hardwareConcurrency: number;
+    product: string;
+    productSub: string;
+    vendor: string;
+    vendorSub: string;
+    maxTouchPoints?: number;
+    extraProperties: ExtraProperties;
+}
+/**
+ * Video card information data structure.
+ */
+interface VideoCard {
+    renderer: string;
+    vendor: string;
+}
+/**
+ * Main fingerprint data structure.
+ */
+interface Fingerprint {
+    screen: ScreenFingerprint;
+    navigator: NavigatorFingerprint;
+    videoCodecs: Record<string, string>;
+    audioCodecs: Record<string, string>;
+    pluginsData: Record<string, string>;
+    battery?: Record<string, string>;
+    videoCard: VideoCard;
+    multimediaDevices: string[];
+    fonts: string[];
+    mockWebRTC: boolean;
+    slim?: boolean;
+}
+/**
+ * Complete fingerprint format including fingerprint data and headers.
+ */
+declare class FingerprintFormat {
+    fingerprint: Fingerprint;
+    headers: Record<string, string>;
+    constructor(fingerprint: Fingerprint, headers: Record<string, string>);
+    /**
+     * Load fingerprint format from dict or JSON string.
+     *
+     * @param data - Dictionary or JSON string containing fingerprint data
+     * @returns FingerprintFormat instance
+     *
+     * @example
+     * ```typescript
+     * // From dict
+     * const fp = FingerprintFormat.load({fingerprint: {...}, headers: {...}});
+     * // From JSON file
+     * const data = fs.readFileSync('fingerprint.json', 'utf8');
+     * const fp2 = FingerprintFormat.load(data);
+     * ```
+     */
+    static load(data: string | Record<string, any>): FingerprintFormat;
+    /**
+     * Convert to dictionary format.
+     * Note: Used internally by SDK modules.
+     */
+    toDict(): Record<string, any>;
+    /**
+     * Convert to JSON string format.
+     * Note: Used internally by SDK modules.
+     */
+    toJson(indent?: number): string;
+    /**
+     * Create FingerprintFormat from dictionary data.
+     * Note: Used internally by SDK modules.
+     */
+    static fromDict(data: Record<string, any>): FingerprintFormat;
+    /**
+     * Create FingerprintFormat from JSON string.
+     */
+    static fromJson(jsonStr: string): FingerprintFormat;
+    /**
+     * Create FingerprintFormat directly using component interfaces.
+     */
+    static create(screen: ScreenFingerprint, navigator: NavigatorFingerprint, videoCard: VideoCard, headers: Record<string, string>, videoCodecs?: Record<string, string>, audioCodecs?: Record<string, string>, pluginsData?: Record<string, string>, battery?: Record<string, string>, multimediaDevices?: string[], fonts?: string[], mockWebRTC?: boolean, slim?: boolean): FingerprintFormat;
+}
+/**
+ * Browser fingerprint generator class.
+ */
+declare class BrowserFingerprintGenerator {
+    private headless;
+    private useChromeChannel;
+    constructor(options?: {
+        headless?: boolean;
+        useChromeChannel?: boolean;
+    });
+    /**
+     * Extract comprehensive browser fingerprint using Playwright.
+     */
+    generateFingerprint(): Promise<FingerprintFormat | null>;
+    /**
+     * Extract comprehensive browser fingerprint and save to file.
+     */
+    generateFingerprintToFile(outputFilename?: string): Promise<boolean>;
+    /**
+     * Extract fingerprint data from the page.
+     */
+    private extractFingerprintData;
+    /**
+     * Extract headers data from httpbin.
+     */
+    private extractHeadersData;
+    /**
+     * Save JSON string data to a file.
+     */
+    private saveToFile;
+}
+
 interface BrowserViewport {
     width: number;
     height: number;
@@ -2902,6 +3217,21 @@ interface BrowserFingerprint {
     operatingSystems?: Array<'windows' | 'macos' | 'linux' | 'android' | 'ios'>;
     locales?: string[];
 }
+/**
+ * Browser fingerprint context configuration.
+ */
+declare class BrowserFingerprintContext {
+    /** ID of the fingerprint context for browser fingerprint */
+    fingerprintContextId: string;
+    /**
+     * Initialize BrowserFingerprintContext with context id.
+     *
+     * @param fingerprintContextId - ID of the fingerprint context for browser fingerprint.
+     *
+     * @throws {Error} If fingerprintContextId is empty.
+     */
+    constructor(fingerprintContextId: string);
+}
 interface BrowserProxy {
     type: 'custom' | 'wuying';
     server?: string;
@@ -2929,6 +3259,10 @@ interface BrowserOption {
     viewport?: BrowserViewport;
     screen?: BrowserScreen;
     fingerprint?: BrowserFingerprint;
+    /** Browser fingerprint format data for detailed fingerprint configuration */
+    fingerprintFormat?: FingerprintFormat;
+    /** Whether to enable fingerprint persistence across sessions */
+    fingerprintPersistent?: boolean;
     solveCaptchas?: boolean;
     proxies?: BrowserProxy[];
     /** Path to the extensions directory. Defaults to "/tmp/extensions/" */
@@ -2947,13 +3281,16 @@ declare class BrowserOptionClass implements BrowserOption {
     viewport?: BrowserViewport;
     screen?: BrowserScreen;
     fingerprint?: BrowserFingerprint;
+    fingerprintFormat?: FingerprintFormat;
+    fingerprintPersistent?: boolean;
+    fingerprintPersistPath?: string;
     solveCaptchas?: boolean;
     proxies?: BrowserProxy[];
     extensionPath?: string;
     cmdArgs?: string[];
     defaultNavigateUrl?: string;
     browserType?: 'chrome' | 'chromium' | undefined;
-    constructor(useStealth?: boolean, userAgent?: string, viewport?: BrowserViewport, screen?: BrowserScreen, fingerprint?: BrowserFingerprint, solveCaptchas?: boolean, proxies?: BrowserProxy[], cmdArgs?: string[], defaultNavigateUrl?: string, browserType?: 'chrome' | 'chromium');
+    constructor(useStealth?: boolean, userAgent?: string, viewport?: BrowserViewport, screen?: BrowserScreen, fingerprint?: BrowserFingerprint, fingerprintFormat?: FingerprintFormat, fingerprintPersistent?: boolean, solveCaptchas?: boolean, proxies?: BrowserProxy[], cmdArgs?: string[], defaultNavigateUrl?: string, browserType?: 'chrome' | 'chromium');
     toMap(): Record<string, any>;
     fromMap(m: Record<string, any> | null | undefined): BrowserOptionClass;
 }
@@ -2972,6 +3309,20 @@ declare class Browser {
     /**
      * Initialize the browser instance with the given options asynchronously.
      * Returns true if successful, false otherwise.
+     *
+     * @param option - Browser configuration options
+     * @returns Promise resolving to true if successful, false otherwise
+     *
+     * @example
+     * ```typescript
+     * const agentBay = new AgentBay({ apiKey: process.env.AGENTBAY_API_KEY });
+     * const result = await agentBay.create({ imageId: 'browser_latest' });
+     * if (result.success) {
+     *   const success = await result.session.browser.initializeAsync(new BrowserOptionClass());
+     *   console.log('Browser initialized:', success);
+     *   await result.session.delete();
+     * }
+     * ```
      */
     initializeAsync(option: BrowserOptionClass | BrowserOption): Promise<boolean>;
     /**
@@ -2981,6 +3332,22 @@ declare class Browser {
     /**
      * Returns the endpoint URL if the browser is initialized, otherwise throws an exception.
      * When initialized, always fetches the latest CDP url from session.getLink().
+     *
+     * @returns Promise resolving to the CDP endpoint URL
+     * @throws {BrowserError} If browser is not initialized
+     *
+     * @example
+     * ```typescript
+     * const agentBay = new AgentBay({ apiKey: process.env.AGENTBAY_API_KEY });
+     * const result = await agentBay.create({ imageId: 'browser_latest' });
+     * if (result.success) {
+     *   await result.session.browser.initializeAsync(new BrowserOptionClass());
+     *   const endpointUrl = await result.session.browser.getEndpointUrl();
+     *   const browser = await chromium.connectOverCDP(endpointUrl);
+     *   await browser.close();
+     *   await result.session.delete();
+     * }
+     * ```
      */
     getEndpointUrl(): Promise<string>;
     /**
@@ -2995,6 +3362,50 @@ declare class Browser {
      * Stop the browser instance, internal use only.
      */
     private _stopBrowser;
+    /**
+     * Takes a screenshot of the specified page with enhanced options and error handling.
+     * This method requires the caller to connect to the browser via Playwright or similar
+     * and pass the page object to this method.
+     *
+     * Note: This is a placeholder method that indicates where screenshot functionality
+     * should be implemented. In a complete implementation, this would use Playwright's
+     * page.screenshot() method or similar browser automation API.
+     *
+     * @param page The Playwright Page object to take a screenshot of. This is a required parameter.
+     * @param fullPage Whether to capture the full scrollable page. Defaults to false.
+     * @param options Additional screenshot options that will override defaults.
+     *                Common options include:
+     *                - type: Image type, either 'png' or 'jpeg' (default: 'png')
+     *                - quality: Quality of the image, between 0-100 (jpeg only)
+     *                - timeout: Maximum time in milliseconds (default: 60000)
+     *                - animations: How to handle animations (default: 'disabled')
+     *                - caret: How to handle the caret (default: 'hide')
+     *                - scale: Scale setting (default: 'css')
+     * @returns Screenshot data as Uint8Array.
+     * @throws BrowserError If browser is not initialized.
+     * @throws Error If screenshot capture fails.
+     *
+     * @example
+     * ```typescript
+     * const agentBay = new AgentBay({ apiKey: process.env.AGENTBAY_API_KEY });
+     * const result = await agentBay.create({ imageId: 'browser_latest' });
+     * if (result.success) {
+     *   await result.session.browser.initializeAsync(new BrowserOptionClass());
+     *   const browser = await chromium.connectOverCDP(await result.session.browser.getEndpointUrl());
+     *   const page = await browser.contexts()[0].newPage();
+     *   await page.goto('https://example.com');
+     *   const screenshot = await result.session.browser.screenshot(page);
+     *   await writeFile('screenshot.png', Buffer.from(screenshot));
+     *   await browser.close();
+     *   await result.session.delete();
+     * }
+     * ```
+     */
+    screenshot(page: any, fullPage?: boolean, options?: Record<string, any>): Promise<Uint8Array>;
+    /**
+     * Scrolls the page to load all content (especially for lazy-loaded elements)
+     */
+    private _scrollToLoadAllContent;
 }
 
 /**
@@ -3027,6 +3438,17 @@ declare class Code {
      *                   Note: Due to gateway limitations, each request cannot exceed 60 seconds.
      * @returns CodeExecutionResult with code execution output and requestId
      * @throws Error if an unsupported language is specified.
+     *
+     * @example
+     * ```typescript
+     * const agentBay = new AgentBay({ apiKey: 'your_api_key' });
+     * const result = await agentBay.create({ imageId: "code_latest" });
+     * if (result.success) {
+     *   const codeResult = await result.session.code.runCode('print("Hello")', "python");
+     *   console.log(codeResult.result);
+     *   await result.session.delete();
+     * }
+     * ```
      */
     runCode(code: string, language: string, timeoutS?: number): Promise<CodeExecutionResult>;
 }
@@ -3050,13 +3472,36 @@ declare class Command {
      */
     private sanitizeError;
     /**
-     * Execute a command in the session environment.
-     * Corresponds to Python's execute_command() method
+     * Executes a shell command in the session environment.
      *
-     * @param command - The command to execute
-     * @param timeoutMs - The timeout in milliseconds. Default is 1000ms.
-     * @returns CommandResult with command output and requestId
-     * @throws APIError if the operation fails.
+     * @param command - The shell command to execute.
+     * @param timeoutMs - Timeout in milliseconds. Defaults to 1000ms.
+     *
+     * @returns Promise resolving to CommandResult containing:
+     *          - success: Whether the command executed successfully
+     *          - output: Combined stdout and stderr output
+     *          - requestId: Unique identifier for this API request
+     *          - errorMessage: Error description if execution failed
+     *
+     * @example
+     * ```typescript
+     * const agentBay = new AgentBay({ apiKey: 'your_api_key' });
+     * const result = await agentBay.create();
+     * if (result.success) {
+     *   const cmdResult = await result.session.command.executeCommand('echo "Hello"', 3000);
+     *   console.log('Command output:', cmdResult.output);
+     *   await result.session.delete();
+     * }
+     * ```
+     *
+     * @remarks
+     * **Behavior:**
+     * - Executes in a Linux shell environment
+     * - Combines stdout and stderr in the output
+     * - Default timeout is 1000ms (1 second)
+     * - Command runs with session user permissions
+     *
+     * @see {@link FileSystem.readFile}, {@link FileSystem.writeFile}
      */
     executeCommand(command: string, timeoutMs?: number): Promise<CommandResult>;
 }
@@ -3108,9 +3553,10 @@ declare const SHOW_NAVIGATION_BAR_TEMPLATE = "setprop persist.wy.hasnavibar true
 /**
  * Uninstall blacklist template
  * Parameters:
- *   package_list (string): Semicolon-separated list of package names
+ *   package_list (string): Newline-separated list of package names
+ *   timestamp (string): Current timestamp for trigger property
  */
-declare const UNINSTALL_BLACKLIST_TEMPLATE = "setprop persist.wy.pm_lock \"{package_list}\"";
+declare const UNINSTALL_BLACKLIST_TEMPLATE = "cat > /data/system/pm_lock.conf << 'EOF'\n{package_list}\nEOF\nchmod 644 /data/system/pm_lock.conf\nsetprop persist.wy.pm_lock.trigger {timestamp}";
 /**
  * Mobile command templates mapping for easy access
  */
@@ -3181,106 +3627,490 @@ declare class Computer {
     constructor(session: ComputerSession);
     /**
      * Click mouse at specified coordinates.
+     *
+     * @param x - X coordinate for the click
+     * @param y - Y coordinate for the click
+     * @param button - Mouse button to click (default: 'left'). Valid values: 'left', 'right', 'middle', 'double_left'
+     * @returns Promise resolving to result with success status
+     *
+     * @example
+     * ```typescript
+     * const agentBay = new AgentBay({ apiKey: 'your_api_key' });
+     * const result = await agentBay.create({ imageId: 'windows_latest' });
+     * if (result.success) {
+     *   const clickResult = await result.session.computer.clickMouse(100, 100, 'left');
+     *   console.log('Clicked:', clickResult.success);
+     *   await result.session.delete();
+     * }
+     * ```
      */
     clickMouse(x: number, y: number, button?: MouseButton | string): Promise<BoolResult$1>;
     /**
      * Move mouse to specified coordinates.
+     *
+     * @param x - X coordinate to move to
+     * @param y - Y coordinate to move to
+     * @returns Promise resolving to result with success status
+     *
+     * @example
+     * ```typescript
+     * const agentBay = new AgentBay({ apiKey: process.env.AGENTBAY_API_KEY });
+     * const result = await agentBay.create({ imageId: 'windows_latest' });
+     * if (result.success) {
+     *   await result.session.computer.moveMouse(300, 400);
+     *   const pos = await result.session.computer.getCursorPosition();
+     *   console.log(`Position: (${pos.x}, ${pos.y})`);
+     *   await result.session.delete();
+     * }
+     * ```
      */
     moveMouse(x: number, y: number): Promise<BoolResult$1>;
     /**
      * Drag mouse from one position to another.
+     *
+     * @param fromX - Starting X coordinate
+     * @param fromY - Starting Y coordinate
+     * @param toX - Ending X coordinate
+     * @param toY - Ending Y coordinate
+     * @param button - Mouse button to use for drag (default: 'left'). Valid values: 'left', 'right', 'middle'
+     * @returns Promise resolving to result with success status
+     *
+     * @example
+     * ```typescript
+     * const agentBay = new AgentBay({ apiKey: process.env.AGENTBAY_API_KEY });
+     * const result = await agentBay.create({ imageId: 'windows_latest' });
+     * if (result.success) {
+     *   const dragResult = await result.session.computer.dragMouse(100, 100, 300, 300, 'left');
+     *   console.log('Dragged:', dragResult.success);
+     *   await result.session.delete();
+     * }
+     * ```
      */
     dragMouse(fromX: number, fromY: number, toX: number, toY: number, button?: MouseButton | string): Promise<BoolResult$1>;
     /**
      * Scroll at specified coordinates.
+     *
+     * @param x - X coordinate to scroll at
+     * @param y - Y coordinate to scroll at
+     * @param direction - Scroll direction (default: 'up'). Valid values: 'up', 'down', 'left', 'right'
+     * @param amount - Scroll amount (default: 1)
+     * @returns Promise resolving to result with success status
+     *
+     * @example
+     * ```typescript
+     * const agentBay = new AgentBay({ apiKey: process.env.AGENTBAY_API_KEY });
+     * const result = await agentBay.create({ imageId: 'windows_latest' });
+     * if (result.success) {
+     *   await result.session.computer.scroll(400, 300, 'up', 3);
+     *   await result.session.delete();
+     * }
+     * ```
      */
     scroll(x: number, y: number, direction?: ScrollDirection | string, amount?: number): Promise<BoolResult$1>;
     /**
-     * Input text.
+     * Input text at the current cursor position.
+     *
+     * @param text - Text to input
+     * @returns Promise resolving to result with success status
+     *
+     * @example
+     * ```typescript
+     * const agentBay = new AgentBay({ apiKey: process.env.AGENTBAY_API_KEY });
+     * const result = await agentBay.create({ imageId: 'windows_latest' });
+     * if (result.success) {
+     *   await result.session.computer.inputText('Hello AgentBay!');
+     *   await result.session.delete();
+     * }
+     * ```
      */
     inputText(text: string): Promise<BoolResult$1>;
     /**
-     * Press keys.
+     * Press one or more keys.
+     *
+     * @param keys - Array of key names to press
+     * @param hold - Whether to hold the keys down (default: false)
+     * @returns Promise resolving to result with success status
+     *
+     * @example
+     * ```typescript
+     * const agentBay = new AgentBay({ apiKey: process.env.AGENTBAY_API_KEY });
+     * const result = await agentBay.create({ imageId: 'windows_latest' });
+     * if (result.success) {
+     *   await result.session.computer.pressKeys(['Ctrl', 'c'], true);
+     *   await result.session.computer.releaseKeys(['Ctrl', 'c']);
+     *   await result.session.delete();
+     * }
+     * ```
      */
     pressKeys(keys: string[], hold?: boolean): Promise<BoolResult$1>;
     /**
-     * Release keys.
+     * Release previously pressed keys.
+     *
+     * @param keys - Array of key names to release
+     * @returns Promise resolving to result with success status
+     *
+     * @example
+     * ```typescript
+     * const agentBay = new AgentBay({ apiKey: process.env.AGENTBAY_API_KEY });
+     * const result = await agentBay.create({ imageId: 'windows_latest' });
+     * if (result.success) {
+     *   await result.session.computer.pressKeys(['Ctrl'], true);
+     *   await result.session.computer.releaseKeys(['Ctrl']);
+     *   await result.session.delete();
+     * }
+     * ```
      */
     releaseKeys(keys: string[]): Promise<BoolResult$1>;
     /**
      * Get cursor position.
+     *
+     * @returns Promise resolving to result containing cursor coordinates
+     *
+     * @example
+     * ```typescript
+     * const agentBay = new AgentBay({ apiKey: process.env.AGENTBAY_API_KEY });
+     * const result = await agentBay.create({ imageId: 'windows_latest' });
+     * if (result.success) {
+     *   const pos = await result.session.computer.getCursorPosition();
+     *   console.log(`Cursor: (${pos.x}, ${pos.y})`);
+     *   await result.session.delete();
+     * }
+     * ```
      */
     getCursorPosition(): Promise<CursorPosition>;
     /**
      * Get screen size.
-     */
-    getScreenSize(): Promise<ScreenSize>;
+     *
+     * @returns Promise resolving to result containing screen dimensions and DPI scaling
+     *
+     * @example
+     * ```typescript
+     * const agentBay = new AgentBay({ apiKey: process.env.AGENTBAY_API_KEY });
+     * const result = await agentBay.create({ imageId: 'windows_latest' });
+     * if (result.success) {
+     *   const size = await result.session.computer.getScreenSize();
+     *   console.log(`Screen: ${size.width}x${size.height}`);
+     *   await result.session.delete();
+     * }
+     * ```
+     */
+    getScreenSize(): Promise<ScreenSize>;
     /**
      * Take a screenshot.
+     *
+     * @returns Promise resolving to result containing screenshot URL
+     *
+     * @example
+     * ```typescript
+     * const agentBay = new AgentBay({ apiKey: process.env.AGENTBAY_API_KEY });
+     * const result = await agentBay.create({ imageId: 'windows_latest' });
+     * if (result.success) {
+     *   const screenshot = await result.session.computer.screenshot();
+     *   console.log('Screenshot URL:', screenshot.data);
+     *   await result.session.delete();
+     * }
+     * ```
      */
     screenshot(): Promise<ScreenshotResult$1>;
     /**
      * Lists all root windows.
+     *
+     * @param timeoutMs - Timeout in milliseconds (default: 3000)
+     * @returns Promise resolving to result containing array of root windows
+     *
+     * @example
+     * ```typescript
+     * const agentBay = new AgentBay({ apiKey: process.env.AGENTBAY_API_KEY });
+     * const result = await agentBay.create({ imageId: 'windows_latest' });
+     * if (result.success) {
+     *   const windows = await result.session.computer.listRootWindows();
+     *   console.log(`Found ${windows.windows.length} windows`);
+     *   await result.session.delete();
+     * }
+     * ```
      */
     listRootWindows(timeoutMs?: number): Promise<WindowListResult>;
     /**
      * Gets the currently active window.
+     *
+     * @param timeoutMs - Timeout in milliseconds (default: 3000)
+     * @returns Promise resolving to result containing active window information
+     *
+     * @example
+     * ```typescript
+     * const agentBay = new AgentBay({ apiKey: process.env.AGENTBAY_API_KEY });
+     * const result = await agentBay.create({ imageId: 'windows_latest' });
+     * if (result.success) {
+     *   const activeWindow = await result.session.computer.getActiveWindow();
+     *   console.log(`Active: ${activeWindow.window?.title}`);
+     *   await result.session.delete();
+     * }
+     * ```
      */
     getActiveWindow(timeoutMs?: number): Promise<WindowInfoResult>;
     /**
      * Activates the specified window.
+     *
+     * @param windowId - ID of the window to activate
+     * @returns Promise resolving to result with success status
+     *
+     * @example
+     * ```typescript
+     * const agentBay = new AgentBay({ apiKey: 'your_api_key' });
+     * const result = await agentBay.create({ imageId: 'windows_latest' });
+     * if (result.success) {
+     *   const windows = await result.session.computer.listRootWindows();
+     *   await result.session.computer.activateWindow(windows.windows[0].id);
+     *   await result.session.delete();
+     * }
+     * ```
      */
     activateWindow(windowId: number): Promise<BoolResult$2>;
     /**
      * Closes the specified window.
+     *
+     * @param windowId - ID of the window to close
+     * @returns Promise resolving to result with success status
+     *
+     * @example
+     * ```typescript
+     * const agentBay = new AgentBay({ apiKey: process.env.AGENTBAY_API_KEY });
+     * const result = await agentBay.create({ imageId: 'windows_latest' });
+     * if (result.success) {
+     *   await result.session.computer.startApp('notepad.exe');
+     *   const win = await result.session.computer.getActiveWindow();
+     *   await result.session.computer.closeWindow(win.window!.id);
+     *   await result.session.delete();
+     * }
+     * ```
      */
     closeWindow(windowId: number): Promise<BoolResult$2>;
     /**
      * Maximizes the specified window.
+     *
+     * @param windowId - ID of the window to maximize
+     * @returns Promise resolving to result with success status
+     *
+     * @example
+     * ```typescript
+     * const agentBay = new AgentBay({ apiKey: process.env.AGENTBAY_API_KEY });
+     * const result = await agentBay.create({ imageId: 'windows_latest' });
+     * if (result.success) {
+     *   await result.session.computer.startApp('notepad.exe');
+     *   const win = await result.session.computer.getActiveWindow();
+     *   await result.session.computer.maximizeWindow(win.window!.id);
+     *   await result.session.delete();
+     * }
+     * ```
      */
     maximizeWindow(windowId: number): Promise<BoolResult$2>;
     /**
      * Minimizes the specified window.
+     *
+     * @param windowId - ID of the window to minimize
+     * @returns Promise resolving to result with success status
+     *
+     * @example
+     * ```typescript
+     * const agentBay = new AgentBay({ apiKey: process.env.AGENTBAY_API_KEY });
+     * const result = await agentBay.create({ imageId: 'windows_latest' });
+     * if (result.success) {
+     *   await result.session.computer.startApp('notepad.exe');
+     *   const win = await result.session.computer.getActiveWindow();
+     *   await result.session.computer.minimizeWindow(win.window!.id);
+     *   await result.session.delete();
+     * }
+     * ```
      */
     minimizeWindow(windowId: number): Promise<BoolResult$2>;
     /**
      * Restores the specified window.
+     *
+     * @param windowId - ID of the window to restore
+     * @returns Promise resolving to result with success status
+     *
+     * @example
+     * ```typescript
+     * const agentBay = new AgentBay({ apiKey: process.env.AGENTBAY_API_KEY });
+     * const result = await agentBay.create({ imageId: 'windows_latest' });
+     * if (result.success) {
+     *   await result.session.computer.startApp('notepad.exe');
+     *   const win = await result.session.computer.getActiveWindow();
+     *   await result.session.computer.minimizeWindow(win.window!.id);
+     *   await result.session.computer.restoreWindow(win.window!.id);
+     *   await result.session.delete();
+     * }
+     * ```
      */
     restoreWindow(windowId: number): Promise<BoolResult$2>;
     /**
      * Resizes the specified window.
+     *
+     * @param windowId - ID of the window to resize
+     * @param width - New width of the window
+     * @param height - New height of the window
+     * @returns Promise resolving to result with success status
+     *
+     * @example
+     * ```typescript
+     * const agentBay = new AgentBay({ apiKey: process.env.AGENTBAY_API_KEY });
+     * const result = await agentBay.create({ imageId: 'windows_latest' });
+     * if (result.success) {
+     *   await result.session.computer.startApp('notepad.exe');
+     *   const win = await result.session.computer.getActiveWindow();
+     *   await result.session.computer.resizeWindow(win.window!.id, 800, 600);
+     *   await result.session.delete();
+     * }
+     * ```
      */
     resizeWindow(windowId: number, width: number, height: number): Promise<BoolResult$2>;
     /**
      * Makes the specified window fullscreen.
+     *
+     * @param windowId - ID of the window to make fullscreen
+     * @returns Promise resolving to result with success status
+     *
+     * @example
+     * ```typescript
+     * const agentBay = new AgentBay({ apiKey: process.env.AGENTBAY_API_KEY });
+     * const result = await agentBay.create({ imageId: 'windows_latest' });
+     * if (result.success) {
+     *   await result.session.computer.startApp('notepad.exe');
+     *   const win = await result.session.computer.getActiveWindow();
+     *   await result.session.computer.fullscreenWindow(win.window!.id);
+     *   await result.session.delete();
+     * }
+     * ```
      */
     fullscreenWindow(windowId: number): Promise<BoolResult$2>;
     /**
      * Toggles focus mode on or off.
+     *
+     * @param on - Whether to enable (true) or disable (false) focus mode
+     * @returns Promise resolving to result with success status
+     *
+     * @example
+     * ```typescript
+     * const agentBay = new AgentBay({ apiKey: process.env.AGENTBAY_API_KEY });
+     * const result = await agentBay.create({ imageId: 'windows_latest' });
+     * if (result.success) {
+     *   await result.session.computer.focusMode(true);
+     *   await result.session.computer.focusMode(false);
+     *   await result.session.delete();
+     * }
+     * ```
      */
     focusMode(on: boolean): Promise<BoolResult$2>;
     /**
      * Gets the list of installed applications.
+     *
+     * @param startMenu - Whether to include applications from start menu (default: true)
+     * @param desktop - Whether to include applications from desktop (default: false)
+     * @param ignoreSystemApps - Whether to exclude system applications (default: true)
+     * @returns Promise resolving to result containing array of installed applications
+     *
+     * @example
+     * ```typescript
+     * const agentBay = new AgentBay({ apiKey: 'your_api_key' });
+     * const result = await agentBay.create({ imageId: 'windows_latest' });
+     * if (result.success) {
+     *   const apps = await result.session.computer.getInstalledApps();
+     *   console.log(`Found ${apps.data.length} apps`);
+     *   await result.session.delete();
+     * }
+     * ```
      */
-    getInstalledApps(): Promise<any>;
+    getInstalledApps(startMenu?: boolean, desktop?: boolean, ignoreSystemApps?: boolean): Promise<any>;
     /**
      * Starts the specified application.
+     *
+     * @param startCmd - The command to start the application (e.g., 'notepad.exe', 'calculator:')
+     * @param workDirectory - The working directory for the application (optional)
+     * @param activity - The activity parameter (optional, primarily for mobile use)
+     * @returns Promise resolving to result containing array of started processes
+     *
+     * @example
+     * ```typescript
+     * const agentBay = new AgentBay({ apiKey: 'your_api_key' });
+     * const result = await agentBay.create({ imageId: 'windows_latest' });
+     * if (result.success) {
+     *   const startResult = await result.session.computer.startApp('notepad.exe');
+     *   console.log(`Started ${startResult.data.length} process(es)`);
+     *   await result.session.delete();
+     * }
+     * ```
      */
-    startApp(startCmd: string, workDirectory?: string): Promise<any>;
+    startApp(startCmd: string, workDirectory?: string, activity?: string): Promise<any>;
     /**
      * Stops an application by process name.
+     *
+     * @param pname - The process name to stop (e.g., 'notepad.exe', 'chrome.exe')
+     * @returns Promise resolving to result with success status
+     *
+     * @example
+     * ```typescript
+     * const agentBay = new AgentBay({ apiKey: 'your_api_key' });
+     * const result = await agentBay.create({ imageId: 'windows_latest' });
+     * if (result.success) {
+     *   await result.session.computer.startApp('notepad.exe');
+     *   await result.session.computer.stopAppByPName('notepad.exe');
+     *   await result.session.delete();
+     * }
+     * ```
      */
     stopAppByPName(pname: string): Promise<any>;
     /**
      * Stops an application by process ID.
+     *
+     * @param pid - The process ID to stop
+     * @returns Promise resolving to result with success status
+     *
+     * @example
+     * ```typescript
+     * const agentBay = new AgentBay({ apiKey: 'your_api_key' });
+     * const result = await agentBay.create({ imageId: 'windows_latest' });
+     * if (result.success) {
+     *   const startResult = await result.session.computer.startApp('notepad.exe');
+     *   const pid = startResult.data[0].pid;
+     *   await result.session.computer.stopAppByPID(pid);
+     *   await result.session.delete();
+     * }
+     * ```
      */
     stopAppByPID(pid: number): Promise<any>;
     /**
      * Stops an application by stop command.
+     *
+     * @param cmd - The command to stop the application
+     * @returns Promise resolving to result with success status
+     *
+     * @example
+     * ```typescript
+     * const agentBay = new AgentBay({ apiKey: 'your_api_key' });
+     * const result = await agentBay.create({ imageId: 'windows_latest' });
+     * if (result.success) {
+     *   await result.session.computer.startApp('notepad.exe');
+     *   await result.session.computer.stopAppByCmd('taskkill /IM notepad.exe /F');
+     *   await result.session.delete();
+     * }
+     * ```
      */
     stopAppByCmd(cmd: string): Promise<any>;
     /**
      * Lists all visible applications.
+     *
+     * @returns Promise resolving to result containing array of visible application processes
+     *
+     * @example
+     * ```typescript
+     * const agentBay = new AgentBay({ apiKey: 'your_api_key' });
+     * const result = await agentBay.create({ imageId: 'windows_latest' });
+     * if (result.success) {
+     *   const apps = await result.session.computer.listVisibleApps();
+     *   console.log(`Found ${apps.data.length} visible apps`);
+     *   await result.session.delete();
+     * }
+     * ```
      */
     listVisibleApps(): Promise<any>;
 }
@@ -3316,8 +4146,69 @@ interface SessionInterface {
 declare class ContextManager {
     private session;
     constructor(session: SessionInterface);
+    /**
+     * Gets information about context synchronization status for the current session.
+     *
+     * @returns Promise resolving to ContextInfoResult containing context status data and request ID
+     * @throws Error if the API call fails
+     *
+     * @example
+     * ```typescript
+     * const agentBay = new AgentBay({ apiKey: 'your_api_key' });
+     * const result = await agentBay.create();
+     * if (result.success) {
+     *   const info = await result.session.context.info();
+     *   console.log(`Context count: ${info.contextStatusData.length}`);
+     *   await result.session.delete();
+     * }
+     * ```
+     */
     info(): Promise<ContextInfoResult>;
+    /**
+     * Gets information about context synchronization status with optional filter parameters.
+     *
+     * @param contextId - Optional context ID to filter results
+     * @param path - Optional path to filter results
+     * @param taskType - Optional task type to filter results (e.g., "upload", "download")
+     * @returns Promise resolving to ContextInfoResult containing filtered context status data and request ID
+     * @throws Error if the API call fails
+     *
+     * @example
+     * ```typescript
+     * const agentBay = new AgentBay({ apiKey: 'your_api_key' });
+     * const result = await agentBay.create();
+     * if (result.success) {
+     *   const info = await result.session.context.infoWithParams('SdkCtx-xxx', '/mnt/persistent');
+     *   console.log(`Context status: ${info.contextStatusData[0]?.status}`);
+     *   await result.session.delete();
+     * }
+     * ```
+     */
     infoWithParams(contextId?: string, path?: string, taskType?: string): Promise<ContextInfoResult>;
+    /**
+     * Synchronizes a context with the session. Supports both async and callback modes.
+     *
+     * @param contextId - Optional context ID to synchronize
+     * @param path - Optional path where the context should be mounted
+     * @param mode - Optional synchronization mode (e.g., "upload", "download")
+     * @param callback - Optional callback function. If provided, runs in background and calls callback when complete
+     * @param maxRetries - Maximum number of retries for polling completion status (default: 150)
+     * @param retryInterval - Milliseconds to wait between retries (default: 1500)
+     * @returns Promise resolving to ContextSyncResult with success status and request ID
+     * @throws Error if the API call fails
+     *
+     * @example
+     * ```typescript
+     * const agentBay = new AgentBay({ apiKey: 'your_api_key' });
+     * const result = await agentBay.create();
+     * if (result.success) {
+     *   const ctxResult = await agentBay.context.get('my-context', true);
+     *   const syncResult = await result.session.context.sync(ctxResult.context!.id, '/mnt/persistent', 'upload');
+     *   console.log(`Sync: ${syncResult.success}`);
+     *   await result.session.delete();
+     * }
+     * ```
+     */
     sync(contextId?: string, path?: string, mode?: string, callback?: SyncCallback, maxRetries?: number, retryInterval?: number): Promise<ContextSyncResult>;
     /**
      * Polls the info interface to check if sync is completed and calls callback.
@@ -3410,6 +4301,17 @@ declare class FileSystem {
      *
      * @param path - Path to the directory to create.
      * @returns BoolResult with creation result and requestId
+     *
+     * @example
+     * ```typescript
+     * const agentBay = new AgentBay({ apiKey: 'your_api_key' });
+     * const result = await agentBay.create();
+     * if (result.success) {
+     *   const createResult = await result.session.fileSystem.createDirectory('/tmp/mydir');
+     *   console.log('Directory created:', createResult.success);
+     *   await result.session.delete();
+     * }
+     * ```
      */
     createDirectory(path: string): Promise<BoolResult$2>;
     /**
@@ -3420,6 +4322,19 @@ declare class FileSystem {
      * @param edits - Array of edit operations, each containing oldText and newText.
      * @param dryRun - Optional: If true, preview changes without applying them.
      * @returns BoolResult with edit result and requestId
+     *
+     * @example
+     * ```typescript
+     * const agentBay = new AgentBay({ apiKey: 'your_api_key' });
+     * const result = await agentBay.create();
+     * if (result.success) {
+     *   await result.session.fileSystem.writeFile('/tmp/config.txt', 'DEBUG=false');
+     *   const edits = [{ oldText: 'DEBUG=false', newText: 'DEBUG=true' }];
+     *   const editResult = await result.session.fileSystem.editFile('/tmp/config.txt', edits);
+     *   console.log('File edited:', editResult.success);
+     *   await result.session.delete();
+     * }
+     * ```
      */
     editFile(path: string, edits: Array<{
         oldText: string;
@@ -3431,6 +4346,18 @@ declare class FileSystem {
      *
      * @param path - Path to the file or directory to inspect.
      * @returns FileInfoResult with file info and requestId
+     *
+     * @example
+     * ```typescript
+     * const agentBay = new AgentBay({ apiKey: 'your_api_key' });
+     * const result = await agentBay.create();
+     * if (result.success) {
+     *   await result.session.fileSystem.writeFile('/tmp/test.txt', 'Sample content');
+     *   const infoResult = await result.session.fileSystem.getFileInfo('/tmp/test.txt');
+     *   console.log(`Size: ${infoResult.fileInfo.size} bytes`);
+     *   await result.session.delete();
+     * }
+     * ```
      */
     getFileInfo(path: string): Promise<FileInfoResult>;
     /**
@@ -3440,6 +4367,38 @@ declare class FileSystem {
      * @param path - Path to the directory to list.
      * @returns DirectoryListResult with directory entries and requestId
      */
+    /**
+     * Lists the contents of a directory.
+     *
+     * @param path - Absolute path to the directory to list.
+     *
+     * @returns Promise resolving to DirectoryListResult containing array of entries.
+     *
+     * @example
+     * ```typescript
+     * import { AgentBay } from 'wuying-agentbay-sdk';
+     *
+     * const agentBay = new AgentBay({ apiKey: 'your_api_key' });
+     * const result = await agentBay.create();
+     *
+     * if (result.success) {
+     *   const session = result.session;
+     *
+     *   // List directory contents
+     *   const listResult = await session.fileSystem.listDirectory('/tmp');
+     *   if (listResult.success) {
+     *     console.log(`Found ${listResult.entries.length} entries`);
+     *     for (const entry of listResult.entries) {
+     *       console.log(`${entry.name} (${entry.isDirectory ? 'dir' : 'file'})`);
+     *     }
+     *   }
+     *
+     *   await session.delete();
+     * }
+     * ```
+     *
+     * @see {@link readFile}, {@link writeFile}
+     */
     listDirectory(path: string): Promise<DirectoryListResult>;
     /**
      * Moves a file or directory from source to destination.
@@ -3448,6 +4407,18 @@ declare class FileSystem {
      * @param source - Path to the source file or directory.
      * @param destination - Path to the destination file or directory.
      * @returns BoolResult with move result and requestId
+     *
+     * @example
+     * ```typescript
+     * const agentBay = new AgentBay({ apiKey: 'your_api_key' });
+     * const result = await agentBay.create();
+     * if (result.success) {
+     *   await result.session.fileSystem.writeFile('/tmp/original.txt', 'Test content');
+     *   const moveResult = await result.session.fileSystem.moveFile('/tmp/original.txt', '/tmp/moved.txt');
+     *   console.log('File moved:', moveResult.success);
+     *   await result.session.delete();
+     * }
+     * ```
      */
     moveFile(source: string, destination: string): Promise<BoolResult$2>;
     /**
@@ -3465,16 +4436,43 @@ declare class FileSystem {
      *
      * @param paths - Array of file paths to read.
      * @returns MultipleFileContentResult with file contents and requestId
+     *
+     * @example
+     * ```typescript
+     * const agentBay = new AgentBay({ apiKey: 'your_api_key' });
+     * const result = await agentBay.create();
+     * if (result.success) {
+     *   await result.session.fileSystem.writeFile('/tmp/file1.txt', 'Content 1');
+     *   await result.session.fileSystem.writeFile('/tmp/file2.txt', 'Content 2');
+     *   const readResult = await result.session.fileSystem.readMultipleFiles(['/tmp/file1.txt', '/tmp/file2.txt']);
+     *   console.log(`Read ${Object.keys(readResult.contents).length} files`);
+     *   await result.session.delete();
+     * }
+     * ```
      */
     readMultipleFiles(paths: string[]): Promise<MultipleFileContentResult>;
     /**
-     * Searches for files in a directory that match a pattern.
+     * Searches for files in a directory that match a wildcard pattern.
      * Corresponds to Python's search_files() method
      *
      * @param path - Path to the directory to search in.
-     * @param pattern - Pattern to search for. Supports glob patterns.
-     * @param excludePatterns - Optional: Array of patterns to exclude.
+     * @param pattern - Wildcard pattern to match against file names. Supports * (any characters)
+     *                  and ? (single character). Examples: "*.py", "test_*", "*config*".
+     * @param excludePatterns - Optional: Array of wildcard patterns to exclude.
      * @returns FileSearchResult with search results and requestId
+     *
+     * @example
+     * ```typescript
+     * const agentBay = new AgentBay({ apiKey: 'your_api_key' });
+     * const result = await agentBay.create();
+     * if (result.success) {
+     *   await result.session.fileSystem.createDirectory('/tmp/test');
+     *   await result.session.fileSystem.writeFile('/tmp/test/file1.py', "print('hello')");
+     *   const searchResult = await result.session.fileSystem.searchFiles('/tmp/test', '*.py');
+     *   console.log(`Found ${searchResult.matches.length} Python files`);
+     *   await result.session.delete();
+     * }
+     * ```
      */
     searchFiles(path: string, pattern: string, excludePatterns?: string[]): Promise<FileSearchResult>;
     /**
@@ -3492,6 +4490,49 @@ declare class FileSystem {
      * @param path - Path to the file to read.
      * @returns FileContentResult with complete file content and requestId
      */
+    /**
+     * Reads the entire content of a file.
+     *
+     * @param path - Absolute path to the file to read.
+     *
+     * @returns Promise resolving to FileContentResult containing:
+     *          - success: Whether the read operation succeeded
+     *          - content: String content of the file
+     *          - requestId: Unique identifier for this API request
+     *          - errorMessage: Error description if read failed
+     *
+     * @throws Error if the API call fails.
+     *
+     * @example
+     * ```typescript
+     * import { AgentBay } from 'wuying-agentbay-sdk';
+     *
+     * const agentBay = new AgentBay({ apiKey: 'your_api_key' });
+     * const result = await agentBay.create();
+     *
+     * if (result.success) {
+     *   const session = result.session;
+     *
+     *   // Read a text file
+     *   const fileResult = await session.fileSystem.readFile('/etc/hostname');
+     *   if (fileResult.success) {
+     *     console.log(`Content: ${fileResult.content}`);
+     *     // Output: Content: agentbay-session-xyz
+     *   }
+     *
+     *   await session.delete();
+     * }
+     * ```
+     *
+     * @remarks
+     * **Behavior:**
+     * - Automatically handles large files by reading in 60KB chunks
+     * - Returns empty string for empty files
+     * - Fails if path is a directory or doesn't exist
+     * - Content is returned as UTF-8 string
+     *
+     * @see {@link writeFile}, {@link listDirectory}
+     */
     readFile(path: string): Promise<FileContentResult>;
     /**
      * Writes content to a file. Automatically handles large files by chunking.
@@ -3501,9 +4542,72 @@ declare class FileSystem {
      * @param mode - Optional: Write mode. One of "overwrite", "append", or "create_new". Default is "overwrite".
      * @returns BoolResult indicating success or failure with requestId
      */
+    /**
+     * Writes content to a file.
+     *
+     * @param path - Absolute path to the file to write.
+     * @param content - String content to write to the file.
+     * @param mode - Write mode: "overwrite" (default) or "append".
+     *
+     * @returns Promise resolving to BoolResult with success status.
+     *
+     * @example
+     * ```typescript
+     * import { AgentBay } from 'wuying-agentbay-sdk';
+     *
+     * const agentBay = new AgentBay({ apiKey: 'your_api_key' });
+     * const result = await agentBay.create();
+     *
+     * if (result.success) {
+     *   const session = result.session;
+     *
+     *   // Write to a file (overwrite mode)
+     *   const writeResult = await session.fileSystem.writeFile(
+     *     '/tmp/test.txt',
+     *     'Hello, AgentBay!'
+     *   );
+     *   if (writeResult.success) {
+     *     console.log('File written successfully');
+     *   }
+     *
+     *   // Append to a file
+     *   const appendResult = await session.fileSystem.writeFile(
+     *     '/tmp/test.txt',
+     *     '\nNew line',
+     *     'append'
+     *   );
+     *
+     *   await session.delete();
+     * }
+     * ```
+     *
+     * @remarks
+     * **Behavior:**
+     * - Automatically handles large files by writing in 60KB chunks
+     * - Creates parent directories if they don't exist
+     * - "overwrite" mode replaces existing file content
+     * - "append" mode adds content to the end of the file
+     *
+     * @see {@link readFile}, {@link listDirectory}
+     */
     writeFile(path: string, content: string, mode?: string): Promise<BoolResult$2>;
     /**
      * Get file change information for the specified directory path
+     *
+     * @param path - Directory path to monitor
+     * @returns Promise resolving to result containing detected file changes
+     *
+     * @example
+     * ```typescript
+     * const agentBay = new AgentBay({ apiKey: 'your_api_key' });
+     * const result = await agentBay.create();
+     * if (result.success) {
+     *   await result.session.fileSystem.createDirectory('/tmp/watch_dir');
+     *   const changeResult = await result.session.fileSystem.getFileChange('/tmp/watch_dir');
+     *   console.log(`Detected ${changeResult.events.length} changes`);
+     *   await result.session.delete();
+     * }
+     * ```
      */
     getFileChange(path: string): Promise<FileChangeResult>;
     /**
@@ -3512,6 +4616,26 @@ declare class FileSystem {
     private parseFileChangeData;
     /**
      * Watch a directory for file changes and call the callback function when changes occur
+     *
+     * @param path - Directory path to monitor
+     * @param callback - Function called when changes are detected
+     * @param interval - Polling interval in milliseconds (default: 500, minimum: 100)
+     * @param signal - Signal to abort the monitoring
+     * @returns Promise that resolves when monitoring stops
+     *
+     * @example
+     * ```typescript
+     * const agentBay = new AgentBay({ apiKey: 'your_api_key' });
+     * const result = await agentBay.create();
+     * if (result.success) {
+     *   const testDir = '/tmp/watch_test';
+     *   await result.session.fileSystem.createDirectory(testDir);
+     *   const controller = new AbortController();
+     *   const callback = (events) => console.log(`Detected ${events.length} changes`);
+     *   await result.session.fileSystem.watchDirectory(testDir, callback, 1000, controller.signal);
+     *   await result.session.delete();
+     * }
+     * ```
      */
     watchDirectory(path: string, callback: (events: FileChangeEvent[]) => void, interval?: number, signal?: AbortSignal): Promise<void>;
     /**
@@ -3522,6 +4646,17 @@ declare class FileSystem {
      * @param remotePath - Remote file path to upload to
      * @param options - Optional parameters
      * @returns UploadResult with upload result and requestId
+     *
+     * @example
+     * ```typescript
+     * const agentBay = new AgentBay({ apiKey: 'your_api_key' });
+     * const result = await agentBay.create({ imageId: 'code_latest' });
+     * if (result.success) {
+     *   const uploadResult = await result.session.fileSystem.uploadFile('/tmp/local.txt', '/workspace/remote.txt');
+     *   console.log('Upload success:', uploadResult.success);
+     *   await result.session.delete();
+     * }
+     * ```
      */
     uploadFile(localPath: string, remotePath: string, options?: {
         contentType?: string;
@@ -3538,6 +4673,18 @@ declare class FileSystem {
      * @param localPath - Local file path to download to
      * @param options - Optional parameters
      * @returns DownloadResult with download result and requestId
+     *
+     * @example
+     * ```typescript
+     * const agentBay = new AgentBay({ apiKey: 'your_api_key' });
+     * const result = await agentBay.create({ imageId: 'code_latest' });
+     * if (result.success) {
+     *   await result.session.fileSystem.writeFile('/workspace/remote.txt', 'Content to download');
+     *   const downloadResult = await result.session.fileSystem.downloadFile('/workspace/remote.txt', '/tmp/local.txt');
+     *   console.log('Download success:', downloadResult.success);
+     *   await result.session.delete();
+     * }
+     * ```
      */
     downloadFile(remotePath: string, localPath: string, options?: {
         overwrite?: boolean;
@@ -3662,13 +4809,13 @@ interface UIBounds {
     right: number;
     bottom: number;
 }
-interface UIElement$1 {
+interface UIElement {
     text: string;
     className: string;
     bounds: UIBounds | string;
 }
 interface UIElementsResult extends OperationResult {
-    elements: UIElement$1[];
+    elements: UIElement[];
 }
 interface InstalledApp {
     name: string;
@@ -3696,6 +4843,7 @@ interface MobileSession {
     callMcpTool(toolName: string, args: Record<string, any>): Promise<any>;
     sessionId: string;
     getAPIKey(): string;
+    getAgentBay(): any;
     imageId?: string;
     getLink(protocolType?: string, port?: number, options?: string): Promise<any>;
 }
@@ -3703,19 +4851,80 @@ declare class Mobile {
     private session;
     constructor(session: MobileSession);
     /**
-     * Tap at specified coordinates.
+     * Tap at specified coordinates on the mobile screen.
+     *
+     * @param x - X coordinate for the tap
+     * @param y - Y coordinate for the tap
+     * @returns Promise resolving to BoolResult with success status
+     *
+     * @example
+     * ```typescript
+     * const agentBay = new AgentBay({ apiKey: process.env.AGENTBAY_API_KEY });
+     * const result = await agentBay.create({ imageId: 'mobile_latest' });
+     * if (result.success) {
+     *   const tapResult = await result.session.mobile.tap(100, 100);
+     *   console.log('Tap success:', tapResult.success);
+     *   await result.session.delete();
+     * }
+     * ```
      */
     tap(x: number, y: number): Promise<BoolResult>;
     /**
-     * Swipe from one position to another.
+     * Swipe from one position to another on the mobile screen.
+     *
+     * @param startX - Starting X coordinate
+     * @param startY - Starting Y coordinate
+     * @param endX - Ending X coordinate
+     * @param endY - Ending Y coordinate
+     * @param durationMs - Swipe duration in milliseconds. Default is 300
+     * @returns Promise resolving to BoolResult with success status
+     *
+     * @example
+     * ```typescript
+     * const agentBay = new AgentBay({ apiKey: process.env.AGENTBAY_API_KEY });
+     * const result = await agentBay.create({ imageId: 'mobile_latest' });
+     * if (result.success) {
+     *   const swipeResult = await result.session.mobile.swipe(200, 400, 200, 100, 300);
+     *   console.log('Swipe success:', swipeResult.success);
+     *   await result.session.delete();
+     * }
+     * ```
      */
     swipe(startX: number, startY: number, endX: number, endY: number, durationMs?: number): Promise<BoolResult>;
     /**
-     * Input text.
+     * Input text at the current focus position.
+     *
+     * @param text - Text to input
+     * @returns Promise resolving to BoolResult with success status
+     *
+     * @example
+     * ```typescript
+     * const agentBay = new AgentBay({ apiKey: process.env.AGENTBAY_API_KEY });
+     * const result = await agentBay.create({ imageId: 'mobile_latest' });
+     * if (result.success) {
+     *   const inputResult = await result.session.mobile.inputText('Hello Mobile');
+     *   console.log('Text input successfully:', inputResult.success);
+     *   await result.session.delete();
+     * }
+     * ```
      */
     inputText(text: string): Promise<BoolResult>;
     /**
      * Send Android key code.
+     *
+     * @param key - Android key code (e.g., 4 for BACK, 3 for HOME, 24 for VOLUME_UP)
+     * @returns Promise resolving to BoolResult with success status
+     *
+     * @example
+     * ```typescript
+     * const agentBay = new AgentBay({ apiKey: process.env.AGENTBAY_API_KEY });
+     * const result = await agentBay.create({ imageId: 'mobile_latest' });
+     * if (result.success) {
+     *   const keyResult = await result.session.mobile.sendKey(4);
+     *   console.log('BACK key sent:', keyResult.success);
+     *   await result.session.delete();
+     * }
+     * ```
      */
     sendKey(key: number): Promise<BoolResult>;
     /**
@@ -3732,14 +4941,58 @@ declare class Mobile {
     getInstalledApps(startMenu?: boolean, desktop?: boolean, ignoreSystemApps?: boolean): Promise<InstalledAppsResult>;
     /**
      * Start an app.
+     *
+     * @param startCmd - Start command using "monkey -p" format (e.g., 'monkey -p com.android.settings')
+     * @param workDirectory - Optional working directory for the app
+     * @param activity - Optional activity name to launch
+     * @returns Promise resolving to ProcessResult containing launched process information
+     *
+     * @example
+     * ```typescript
+     * const agentBay = new AgentBay({ apiKey: process.env.AGENTBAY_API_KEY });
+     * const result = await agentBay.create({ imageId: 'mobile_latest' });
+     * if (result.success) {
+     *   const startResult = await result.session.mobile.startApp('monkey -p com.android.settings');
+     *   console.log('App started:', startResult.success);
+     *   await result.session.delete();
+     * }
+     * ```
      */
     startApp(startCmd: string, workDirectory?: string, activity?: string): Promise<ProcessResult>;
     /**
      * Stop app by command.
+     *
+     * @param stopCmd - Package name of the app to stop (e.g., 'com.android.settings')
+     * @returns Promise resolving to BoolResult with success status
+     *
+     * @example
+     * ```typescript
+     * const agentBay = new AgentBay({ apiKey: process.env.AGENTBAY_API_KEY });
+     * const result = await agentBay.create({ imageId: 'mobile_latest' });
+     * if (result.success) {
+     *   await result.session.mobile.startApp('monkey -p com.android.settings');
+     *   const stopResult = await result.session.mobile.stopAppByCmd('com.android.settings');
+     *   console.log('App stopped:', stopResult.success);
+     *   await result.session.delete();
+     * }
+     * ```
      */
     stopAppByCmd(stopCmd: string): Promise<BoolResult>;
     /**
-     * Take a screenshot.
+     * Take a screenshot of the current mobile screen.
+     *
+     * @returns Promise resolving to ScreenshotResult containing screenshot URL
+     *
+     * @example
+     * ```typescript
+     * const agentBay = new AgentBay({ apiKey: process.env.AGENTBAY_API_KEY });
+     * const result = await agentBay.create({ imageId: 'mobile_latest' });
+     * if (result.success) {
+     *   const screenshotResult = await result.session.mobile.screenshot();
+     *   console.log('Screenshot URL:', screenshotResult.data);
+     *   await result.session.delete();
+     * }
+     * ```
      */
     screenshot(): Promise<ScreenshotResult>;
     /**
@@ -3809,381 +5062,133 @@ declare class Mobile {
 /**
  * Handles OSS operations in the AgentBay cloud environment.
  */
-declare class Oss {
-    private session;
-    /**
-     * Initialize an Oss object.
-     *
-     * @param session - The Session instance that this Oss belongs to.
-     */
-    constructor(session: Session);
-    /**
-     * Sanitizes error messages to remove sensitive information like API keys.
-     *
-     * @param error - The error to sanitize
-     * @returns The sanitized error
-     */
-    private sanitizeError;
-    /**
-     * Initialize OSS environment variables with the specified credentials.
-     * Corresponds to Python's env_init() method
-     *
-     * @param accessKeyId - The access key ID
-     * @param accessKeySecret - The access key secret
-     * @param securityToken - The security token (optional)
-     * @param endpoint - The OSS endpoint (optional)
-     * @param region - The OSS region (optional)
-     * @returns OSSClientResult with client configuration and requestId
-     * @throws APIError if the operation fails.
-     */
-    envInit(accessKeyId: string, accessKeySecret: string, securityToken?: string, endpoint?: string, region?: string): Promise<OSSClientResult>;
-    /**
-     * Upload a file to OSS.
-     * Corresponds to Python's upload() method
-     *
-     * @param bucket - The OSS bucket name
-     * @param object - The OSS object key
-     * @param path - The local file path to upload
-     * @returns OSSUploadResult with upload result and requestId
-     * @throws APIError if the operation fails.
-     */
-    upload(bucket: string, object: string, path: string): Promise<OSSUploadResult>;
-    /**
-     * Upload a file to OSS using an anonymous URL.
-     * Corresponds to Python's upload_anonymous() method
-     *
-     * @param url - The anonymous upload URL
-     * @param path - The local file path to upload
-     * @returns OSSUploadResult with upload result and requestId
-     * @throws APIError if the operation fails.
-     */
-    uploadAnonymous(url: string, path: string): Promise<OSSUploadResult>;
-    /**
-     * Download a file from OSS.
-     * Corresponds to Python's download() method
-     *
-     * @param bucket - The OSS bucket name
-     * @param object - The OSS object key
-     * @param path - The local file path to save the downloaded file
-     * @returns OSSDownloadResult with download result and requestId
-     * @throws APIError if the operation fails.
-     */
-    download(bucket: string, object: string, path: string): Promise<OSSDownloadResult>;
-    /**
-     * Download a file from OSS using an anonymous URL.
-     * Corresponds to Python's download_anonymous() method
-     *
-     * @param url - The anonymous download URL
-     * @param path - The local file path to save the downloaded file
-     * @returns OSSDownloadResult with download result and requestId
-     * @throws APIError if the operation fails.
-     */
-    downloadAnonymous(url: string, path: string): Promise<OSSDownloadResult>;
-}
-
-/**
- * Key codes for UI operations
- */
-declare enum KeyCode {
-    HOME = 3,
-    BACK = 4,
-    VOLUME_UP = 24,
-    VOLUME_DOWN = 25,
-    POWER = 26,
-    MENU = 82
-}
-/**
- * Interface representing a UI element in the UI hierarchy
- */
-interface UIElement {
-    bounds: string;
-    className: string;
-    text: string;
-    type: string;
-    resourceId: string;
-    index: number;
-    isParent: boolean;
-    children?: UIElement[];
-}
-/**
- * Handles UI operations in the AgentBay cloud environment.
- *
- * @deprecated This module is deprecated. Use Computer or Mobile modules instead.
- * - For desktop UI operations, use session.computer
- * - For mobile UI operations, use session.mobile
- */
-declare class UI {
-    private session;
-    /**
-     * Initialize a UI object.
-     *
-     * @param session - The Session instance that this UI belongs to.
-     */
-    constructor(session: {
-        getAPIKey(): string;
-        getClient(): any;
-        getSessionId(): string;
-        callMcpTool(toolName: string, args: any): Promise<{
-            success: boolean;
-            data: string;
-            errorMessage: string;
-            requestId: string;
-        }>;
-    });
-    /**
-     * Sanitizes error messages to remove sensitive information like API keys.
-     *
-     * @param error - The error to sanitize
-     * @returns The sanitized error
-     */
-    private sanitizeError;
-    /**
-     * Retrieves all clickable UI elements within the specified timeout.
-     * Corresponds to Python's get_clickable_ui_elements() method
-     *
-     * @param timeoutMs - The timeout in milliseconds. Default is 2000ms.
-     * @returns UIElementListResult with clickable elements and requestId
-     * @throws Error if the operation fails.
-     *
-     * @deprecated Use session.computer.getClickableUIElements() for desktop or session.mobile.getClickableUIElements() for mobile instead.
-     */
-    getClickableUIElements(timeoutMs?: number): Promise<UIElementListResult>;
-    /**
-     * Retrieves all UI elements regardless of their clickable status.
-     * Corresponds to Python's get_all_ui_elements() method
-     *
-     * @param timeoutMs - The timeout in milliseconds. Default is 2000ms.
-     * @returns UIElementListResult with all elements and requestId
-     * @throws Error if the operation fails.
-     *
-     * @deprecated Use session.computer.getAllUIElements() for desktop or session.mobile.getAllUIElements() for mobile instead.
-     */
-    getAllUIElements(timeoutMs?: number): Promise<UIElementListResult>;
-    /**
-     * Sends a key press event.
-     * Corresponds to Python's send_key() method
-     *
-     * @param key - The key code to send. Supported key codes are:
-     *   - 3 : HOME
-     *   - 4 : BACK
-     *   - 24 : VOLUME UP
-     *   - 25 : VOLUME DOWN
-     *   - 26 : POWER
-     *   - 82 : MENU
-     * @returns BoolResult with success status and requestId
-     * @throws Error if the operation fails.
-     *
-     * @deprecated Use session.computer.pressKeys() for desktop or session.mobile.sendKey() for mobile instead.
-     */
-    sendKey(key: number): Promise<BoolResult$2>;
-    /**
-     * Inputs text into the currently focused UI element.
-     * Corresponds to Python's input_text() method
-     *
-     * @param text - The text to input
-     * @returns BoolResult with success status and requestId
-     * @throws Error if the operation fails.
-     *
-     * @deprecated Use session.computer.inputText() for desktop or session.mobile.inputText() for mobile instead.
-     */
-    inputText(text: string): Promise<BoolResult$2>;
-    /**
-     * Performs a swipe gesture on the screen.
-     * Corresponds to Python's swipe() method
-     *
-     * @param startX - The starting X coordinate
-     * @param startY - The starting Y coordinate
-     * @param endX - The ending X coordinate
-     * @param endY - The ending Y coordinate
-     * @param durationMs - The duration of the swipe in milliseconds. Default is 300ms.
-     * @returns BoolResult with success status and requestId
-     * @throws Error if the operation fails.
-     *
-     * @deprecated Use session.computer.dragMouse() for desktop or session.mobile.swipe() for mobile instead.
-     */
-    swipe(startX: number, startY: number, endX: number, endY: number, durationMs?: number): Promise<BoolResult$2>;
-    /**
-     * Clicks on the screen at the specified coordinates.
-     * Corresponds to Python's click() method
-     *
-     * @param x - The X coordinate
-     * @param y - The Y coordinate
-     * @param button - The mouse button to use. Default is 'left'
-     * @returns BoolResult with success status and requestId
-     * @throws Error if the operation fails.
-     *
-     * @deprecated Use session.computer.clickMouse() for desktop or session.mobile.tap() for mobile instead.
-     */
-    click(x: number, y: number, button?: string): Promise<BoolResult$2>;
-    /**
-     * Takes a screenshot of the current screen.
-     * Corresponds to Python's screenshot() method
-     *
-     * @returns OperationResult with success status and requestId
-     * @throws Error if the operation fails.
-     *
-     * @deprecated Use session.computer.screenshot() for desktop or session.mobile.screenshot() for mobile instead.
-     */
-    screenshot(): Promise<OperationResult>;
-}
-
-/**
- * Handles window management operations in the AgentBay cloud environment.
- *
- * @deprecated This module is deprecated. Use Computer module instead.
- * - For desktop window operations, use session.computer
- * - Window operations are not available for mobile
- */
-declare class WindowManager {
-    private session;
-    /**
-     * Creates a new WindowManager instance.
-     * @param session The session object that provides access to the AgentBay API.
-     */
-    constructor(session: {
-        getAPIKey(): string;
-        getSessionId(): string;
-        callMcpTool(toolName: string, args: any): Promise<{
-            success: boolean;
-            data: string;
-            errorMessage: string;
-            requestId: string;
-        }>;
-    });
-    /**
-     * Helper method to parse JSON string into Window objects
-     * @param jsonStr - JSON string to parse
-     * @returns Array of Window objects or single Window object
-     */
-    private parseWindowsFromJSON;
-    /**
-     * Lists all root windows in the system.
-     * Corresponds to Python's list_root_windows() method
-     *
-     * @param timeoutMs - The timeout in milliseconds. Default is 3000ms.
-     * @returns WindowListResult with windows array and requestId
-     *
-     * @deprecated Use session.computer.listRootWindows() instead.
-     */
-    listRootWindows(timeoutMs?: number): Promise<WindowListResult>;
-    /**
-     * Lists all windows in the system.
-     * Corresponds to Python's list_all_windows() method
-     *
-     * @param timeoutMs - The timeout in milliseconds. Default is 3000ms.
-     * @returns WindowListResult with windows array and requestId
-     *
-     * @deprecated Use session.computer.listAllWindows() instead.
-     */
-    listAllWindows(timeoutMs?: number): Promise<WindowListResult>;
-    /**
-     * Gets information about a specific window.
-     * Corresponds to Python's get_window_info() method
-     *
-     * @param windowId - The ID of the window to get information for.
-     * @returns WindowInfoResult with window information and requestId
-     *
-     * @deprecated Use session.computer.getWindowInfo() instead.
-     */
-    getWindowInfo(windowId: number): Promise<WindowInfoResult>;
-    /**
-     * Activates a window by bringing it to the foreground.
-     * Corresponds to Python's activate_window() method
-     *
-     * @param windowId - The ID of the window to activate.
-     * @returns BoolResult with success status and requestId
-     *
-     * @deprecated Use session.computer.activateWindow() instead.
-     */
-    activateWindow(windowId: number): Promise<BoolResult$2>;
-    /**
-     * Maximizes a window.
-     * Corresponds to Python's maximize_window() method
-     *
-     * @param windowId - The ID of the window to maximize.
-     * @returns BoolResult with success status and requestId
-     *
-     * @deprecated Use session.computer.maximizeWindow() instead.
-     */
-    maximizeWindow(windowId: number): Promise<BoolResult$2>;
+declare class Oss {
+    private session;
     /**
-     * Minimizes a window.
-     * Corresponds to Python's minimize_window() method
-     *
-     * @param windowId - The ID of the window to minimize.
-     * @returns BoolResult with success status and requestId
+     * Initialize an Oss object.
      *
-     * @deprecated Use session.computer.minimizeWindow() instead.
+     * @param session - The Session instance that this Oss belongs to.
      */
-    minimizeWindow(windowId: number): Promise<BoolResult$2>;
+    constructor(session: Session);
     /**
-     * Restores a window by ID.
-     * Corresponds to Python's restore_window() method
+     * Sanitizes error messages to remove sensitive information like API keys.
      *
-     * @param windowId The ID of the window to restore.
-     * @returns BoolResult with requestId
+     * @param error - The error to sanitize
+     * @returns The sanitized error
      */
-    restoreWindow(windowId: number): Promise<BoolResult$2>;
+    private sanitizeError;
     /**
-     * Closes a window.
-     * Corresponds to Python's close_window() method
-     *
-     * @param windowId - The ID of the window to close.
-     * @returns BoolResult with success status and requestId
+     * Initialize OSS environment variables with the specified STS temporary credentials.
+     * Corresponds to Python's env_init() method
      *
-     * @deprecated Use session.computer.closeWindow() instead.
-     */
-    closeWindow(windowId: number): Promise<BoolResult$2>;
-    /**
-     * Sets a window to fullscreen by ID.
-     * Corresponds to Python's fullscreen_window() method
+     * @param accessKeyId - The access key ID from STS temporary credentials
+     * @param accessKeySecret - The access key secret from STS temporary credentials
+     * @param securityToken - The security token from STS temporary credentials (required)
+     * @param endpoint - The OSS endpoint (optional)
+     * @param region - The OSS region (optional)
+     * @returns OSSClientResult with client configuration and requestId
+     * @throws APIError if the operation fails.
      *
-     * @param windowId The ID of the window to set to fullscreen.
-     * @returns BoolResult with requestId
+     * @example
+     * ```typescript
+     * const agentBay = new AgentBay({ apiKey: 'your_api_key' });
+     * const createResult = await agentBay.create();
+     * if (createResult.success) {
+     *   const result = await createResult.session.oss.envInit('sts_key_id', 'sts_key_secret', 'sts_token', 'oss-cn-hangzhou.aliyuncs.com', 'cn-hangzhou');
+     *   console.log('OSS initialized:', result.success);
+     *   await createResult.session.delete();
+     * }
+     * ```
      */
-    fullscreenWindow(windowId: number): Promise<BoolResult$2>;
+    envInit(accessKeyId: string, accessKeySecret: string, securityToken: string, endpoint?: string, region?: string): Promise<OSSClientResult>;
     /**
-     * Resizes a window to the specified dimensions.
-     * Corresponds to Python's resize_window() method
+     * Upload a file to OSS.
+     * Corresponds to Python's upload() method
      *
-     * @param windowId - The ID of the window to resize.
-     * @param width - The new width of the window.
-     * @param height - The new height of the window.
-     * @returns BoolResult with success status and requestId
+     * @param bucket - The OSS bucket name
+     * @param object - The OSS object key
+     * @param path - The local file path to upload
+     * @returns OSSUploadResult with upload result and requestId
+     * @throws APIError if the operation fails.
      *
-     * @deprecated Use session.computer.resizeWindow() instead.
+     * @example
+     * ```typescript
+     * const agentBay = new AgentBay({ apiKey: 'your_api_key' });
+     * const createResult = await agentBay.create();
+     * if (createResult.success) {
+     *   await createResult.session.oss.envInit('key_id', 'key_secret', 'token', 'oss-cn-hangzhou.aliyuncs.com', 'cn-hangzhou');
+     *   const result = await createResult.session.oss.upload('my-bucket', 'my-folder/file.txt', '/path/to/local/file.txt');
+     *   console.log('Upload success:', result.success);
+     *   await createResult.session.delete();
+     * }
+     * ```
      */
-    resizeWindow(windowId: number, width: number, height: number): Promise<BoolResult$2>;
+    upload(bucket: string, object: string, path: string): Promise<OSSUploadResult>;
     /**
-     * Moves a window to the specified position.
-     * Corresponds to Python's move_window() method
+     * Upload a file to OSS using an anonymous URL.
+     * Corresponds to Python's upload_anonymous() method
      *
-     * @param windowId - The ID of the window to move.
-     * @param x - The new x coordinate of the window.
-     * @param y - The new y coordinate of the window.
-     * @returns BoolResult with success status and requestId
+     * @param url - The anonymous upload URL
+     * @param path - The local file path to upload
+     * @returns OSSUploadResult with upload result and requestId
+     * @throws APIError if the operation fails.
      *
-     * @deprecated Use session.computer.moveWindow() instead.
+     * @example
+     * ```typescript
+     * const agentBay = new AgentBay({ apiKey: 'your_api_key' });
+     * const createResult = await agentBay.create();
+     * if (createResult.success) {
+     *   const result = await createResult.session.oss.uploadAnonymous('https://example.com/upload', '/path/to/local/file.txt');
+     *   console.log('Anonymous upload success:', result.success);
+     *   await createResult.session.delete();
+     * }
+     * ```
      */
-    moveWindow(windowId: number, x: number, y: number): Promise<BoolResult$2>;
+    uploadAnonymous(url: string, path: string): Promise<OSSUploadResult>;
     /**
-     * Enables or disables focus mode.
-     * Corresponds to Python's focus_mode() method
+     * Download a file from OSS.
+     * Corresponds to Python's download() method
+     *
+     * @param bucket - The OSS bucket name
+     * @param object - The OSS object key
+     * @param path - The local file path to save the downloaded file
+     * @returns OSSDownloadResult with download result and requestId
+     * @throws APIError if the operation fails.
      *
-     * @param on Whether to enable focus mode.
-     * @returns BoolResult with requestId
+     * @example
+     * ```typescript
+     * const agentBay = new AgentBay({ apiKey: 'your_api_key' });
+     * const createResult = await agentBay.create();
+     * if (createResult.success) {
+     *   await createResult.session.oss.envInit('key_id', 'key_secret', 'token', 'oss-cn-hangzhou.aliyuncs.com', 'cn-hangzhou');
+     *   const result = await createResult.session.oss.download('my-bucket', 'my-folder/file.txt', '/path/to/save/file.txt');
+     *   console.log('Download success:', result.success);
+     *   await createResult.session.delete();
+     * }
+     * ```
      */
-    focusMode(on: boolean): Promise<BoolResult$2>;
+    download(bucket: string, object: string, path: string): Promise<OSSDownloadResult>;
     /**
-     * Gets the currently active window.
-     * Corresponds to Python's get_active_window() method
+     * Download a file from OSS using an anonymous URL.
+     * Corresponds to Python's download_anonymous() method
      *
-     * @param timeoutMs - The timeout in milliseconds. Default is 3000ms.
-     * @returns WindowInfoResult with active window information and requestId
+     * @param url - The anonymous download URL
+     * @param path - The local file path to save the downloaded file
+     * @returns OSSDownloadResult with download result and requestId
+     * @throws APIError if the operation fails.
      *
-     * @deprecated Use session.computer.getActiveWindow() instead.
+     * @example
+     * ```typescript
+     * const agentBay = new AgentBay({ apiKey: 'your_api_key' });
+     * const createResult = await agentBay.create();
+     * if (createResult.success) {
+     *   const result = await createResult.session.oss.downloadAnonymous('https://example.com/file.txt', '/path/to/save/file.txt');
+     *   console.log('Anonymous download success:', result.success);
+     *   await createResult.session.delete();
+     * }
+     * ```
      */
-    getActiveWindow(timeoutMs?: number): Promise<WindowInfoResult>;
+    downloadAnonymous(url: string, path: string): Promise<OSSDownloadResult>;
 }
 
 /**
@@ -4220,9 +5225,6 @@ declare class Session {
     command: Command;
     code: Code;
     oss: Oss;
-    application: Application;
-    window: WindowManager;
-    ui: UI;
     computer: Computer;
     mobile: Mobile;
     agent: Agent;
@@ -4238,46 +5240,118 @@ declare class Session {
     constructor(agentBay: AgentBay, sessionId: string);
     /**
      * Return the AgentBay instance that created this session.
+     *
+     * @returns The AgentBay client instance
+     * @internal
      */
     getAgentBay(): AgentBay;
     /**
      * Return the API key for this session.
+     * Note: This method is used internally by SDK modules (Code, Computer, Mobile, Agent).
+     *
+     * @returns The API key string
+     * @internal
      */
     getAPIKey(): string;
     /**
      * Return the HTTP client for this session.
+     *
+     * @returns The Client instance used for API communication
+     * @internal
      */
     getClient(): Client;
     /**
      * Return the session_id for this session.
+     * Note: This method is used internally by SDK modules. Users should prefer using the `sessionId` property.
+     *
+     * @returns The session ID string
+     * @internal
      */
     getSessionId(): string;
     /**
      * Return whether this session uses VPC resources.
+     *
+     * @returns boolean indicating if VPC is enabled for this session
+     * @internal
      */
-    isVpcEnabled(): boolean;
+    private isVpcEnabled;
     /**
      * Return the network interface IP for VPC sessions.
+     *
+     * @returns The network interface IP string for VPC sessions
+     * @internal
      */
-    getNetworkInterfaceIp(): string;
+    private getNetworkInterfaceIp;
     /**
      * Return the HTTP port for VPC sessions.
+     *
+     * @returns The HTTP port string for VPC sessions
+     * @internal
      */
-    getHttpPort(): string;
+    private getHttpPort;
     /**
      * Return the token for VPC sessions.
+     *
+     * @returns The token string for VPC sessions
+     * @internal
      */
-    getToken(): string;
+    private getToken;
     /**
      * Find the server that provides the given tool.
+     *
+     * @param toolName - Name of the tool to find
+     * @returns The server name that provides the tool, or empty string if not found
+     * @internal
      */
-    findServerForTool(toolName: string): string;
+    private findServerForTool;
     /**
      * Delete this session.
      *
      * @param syncContext - Whether to sync context data (trigger file uploads) before deleting the session. Defaults to false.
      * @returns DeleteResult indicating success or failure and request ID
      */
+    /**
+     * Deletes the session and releases all associated resources.
+     *
+     * @param syncContext - Whether to synchronize context data before deletion.
+     *                      If true, uploads all context data to OSS.
+     *                      If false but browser replay is enabled, syncs only the recording context.
+     *                      Defaults to false.
+     *
+     * @returns Promise resolving to DeleteResult containing:
+     *          - success: Whether deletion succeeded
+     *          - requestId: Unique identifier for this API request
+     *          - errorMessage: Error description if deletion failed
+     *
+     * @throws Error if the API call fails or network issues occur.
+     *
+     * @example
+     * ```typescript
+     * const agentBay = new AgentBay({ apiKey: 'your_api_key' });
+     * const result = await agentBay.create();
+     * if (result.success) {
+     *   await result.session.fileSystem.writeFile('/tmp/data.txt', 'data');
+     *   const deleteResult = await result.session.delete(true);
+     *   console.log('Session deleted:', deleteResult.success);
+     * }
+     * ```
+     *
+     * @remarks
+     * **Behavior:**
+     * - If `syncContext=true`: Uploads all context data to OSS before deletion
+     * - If `syncContext=false` but browser replay enabled: Syncs only recording context
+     * - If `syncContext=false` and no browser replay: Deletes immediately without sync
+     * - Continues with deletion even if context sync fails
+     * - Releases all associated resources (browser, computer, mobile, etc.)
+     *
+     * **Best Practices:**
+     * - Use `syncContext=true` when you need to preserve context data for later retrieval
+     * - For temporary sessions, use `syncContext=false` for faster cleanup
+     * - Always call `delete()` when done to avoid resource leaks
+     * - Handle deletion errors gracefully in production code
+     *
+     * @see {@link info}, {@link ContextManager.sync}
+     */
     delete(syncContext?: boolean): Promise<DeleteResult>;
     /**
      * Validates labels parameter for label operations.
@@ -4292,6 +5366,17 @@ declare class Session {
      * @param labels - The labels to set for the session.
      * @returns OperationResult indicating success or failure with request ID
      * @throws Error if the operation fails (matching Python SessionError)
+     *
+     * @example
+     * ```typescript
+     * const agentBay = new AgentBay({ apiKey: 'your_api_key' });
+     * const result = await agentBay.create();
+     * if (result.success) {
+     *   const setResult = await result.session.setLabels({ project: 'demo', env: 'test' });
+     *   console.log('Labels set:', setResult.success);
+     *   await result.session.delete();
+     * }
+     * ```
      */
     setLabels(labels: Record<string, string>): Promise<OperationResult>;
     /**
@@ -4299,22 +5384,106 @@ declare class Session {
      *
      * @returns OperationResult containing the labels as data and request ID
      * @throws Error if the operation fails (matching Python SessionError)
+     *
+     * @example
+     * ```typescript
+     * const agentBay = new AgentBay({ apiKey: 'your_api_key' });
+     * const result = await agentBay.create();
+     * if (result.success) {
+     *   await result.session.setLabels({ project: 'demo', env: 'test' });
+     *   const getResult = await result.session.getLabels();
+     *   console.log('Labels:', JSON.stringify(getResult.data));
+     *   await result.session.delete();
+     * }
+     * ```
      */
     getLabels(): Promise<OperationResult>;
     /**
-     * Gets information about this session.
+     * Retrieves detailed information about the current session.
      *
-     * @returns OperationResult containing the session information as data and request ID
-     * @throws Error if the operation fails (matching Python SessionError)
+     * @returns Promise resolving to OperationResult containing:
+     *          - success: Whether the operation succeeded (always true if no exception)
+     *          - data: SessionInfo object with the following fields:
+     *            - sessionId (string): The session identifier
+     *            - resourceUrl (string): URL for accessing the session
+     *            - appId (string): Application ID (for desktop sessions)
+     *            - authCode (string): Authentication code
+     *            - connectionProperties (string): Connection configuration
+     *            - resourceId (string): Resource identifier
+     *            - resourceType (string): Type of resource (e.g., "Desktop")
+     *            - ticket (string): Access ticket
+     *          - requestId: Unique identifier for this API request
+     *          - errorMessage: Error description if operation failed
+     *
+     * @throws Error if the API request fails or response is invalid.
+     *
+     * @example
+     * ```typescript
+     * const agentBay = new AgentBay({ apiKey: 'your_api_key' });
+     * const result = await agentBay.create();
+     * if (result.success) {
+     *   const infoResult = await result.session.info();
+     *   console.log(`Session ID: ${infoResult.data.sessionId}`);
+     *   console.log(`Resource URL: ${infoResult.data.resourceUrl}`);
+     *   await result.session.delete();
+     * }
+     * ```
+     *
+     * @remarks
+     * **Behavior:**
+     * - This method calls the GetMcpResource API to retrieve session metadata
+     * - The returned SessionInfo contains:
+     *   - sessionId: The session identifier
+     *   - resourceUrl: URL for accessing the session
+     *   - Desktop-specific fields (appId, authCode, connectionProperties, etc.)
+     *     are populated from the DesktopInfo section of the API response
+     * - Session info is retrieved from the AgentBay API in real-time
+     * - The resourceUrl can be used for browser-based access
+     * - Desktop-specific fields (appId, authCode) are only populated for desktop sessions
+     * - This method does not modify the session state
+     *
+     * @see {@link delete}, {@link getLink}
      */
     info(): Promise<OperationResult>;
     /**
-     * Get a link associated with the current session.
+     * Retrieves an access link for the session.
      *
-     * @param protocolType - Optional protocol type to use for the link
-     * @param port - Optional port to use for the link (must be in range [30100, 30199])
-     * @returns OperationResult containing the link as data and request ID
-     * @throws Error if the operation fails (matching Python SessionError)
+     * @param protocolType - Protocol type for the link (optional, reserved for future use)
+     * @param port - Specific port number to access (must be in range [30100, 30199]).
+     *               If not specified, returns the default session link.
+     *
+     * @returns Promise resolving to OperationResult containing:
+     *          - success: Whether the operation succeeded
+     *          - data: String URL for accessing the session
+     *          - requestId: Unique identifier for this API request
+     *          - errorMessage: Error description if operation failed
+     *
+     * @throws Error if the API call fails or port is out of valid range.
+     *
+     * @example
+     * ```typescript
+     * const agentBay = new AgentBay({ apiKey: 'your_api_key' });
+     * const result = await agentBay.create();
+     * if (result.success) {
+     *   const linkResult = await result.session.getLink();
+     *   console.log(`Session link: ${linkResult.data}`);
+     *   await result.session.delete();
+     * }
+     * ```
+     *
+     * @remarks
+     * **Behavior:**
+     * - Without port: Returns the default session access URL
+     * - With port: Returns URL for accessing specific port-mapped service
+     * - Port must be in range [30100, 30199] for port forwarding
+     * - For ADB connections, use `session.mobile.getAdbUrl()` with appropriate ADB public key
+     *
+     * **Best Practices:**
+     * - Use default link for general session access
+     * - Use port-specific links when you've started services on specific ports
+     * - Validate port range before calling to avoid errors
+     *
+     * @see {@link info}
      */
     getLink(protocolType?: string, port?: number, options?: string): Promise<OperationResult>;
     /**
@@ -4324,6 +5493,17 @@ declare class Session {
      * @param port - Optional port to use for the link (must be in range [30100, 30199])
      * @returns OperationResult containing the link as data and request ID
      * @throws Error if the operation fails (matching Python SessionError)
+     *
+     * @example
+     * ```typescript
+     * const agentBay = new AgentBay({ apiKey: 'your_api_key' });
+     * const result = await agentBay.create();
+     * if (result.success) {
+     *   const linkResult = await result.session.getLinkAsync(undefined, 30150);
+     *   console.log(`Port link: ${linkResult.data}`);
+     *   await result.session.delete();
+     * }
+     * ```
      */
     getLinkAsync(protocolType?: string, port?: number, options?: string): Promise<OperationResult>;
     /**
@@ -4331,6 +5511,17 @@ declare class Session {
      *
      * @param imageId Optional image ID, defaults to session's imageId or "linux_latest"
      * @returns McpToolsResult containing tools list and request ID
+     *
+     * @example
+     * ```typescript
+     * const agentBay = new AgentBay({ apiKey: 'your_api_key' });
+     * const result = await agentBay.create();
+     * if (result.success) {
+     *   const toolsResult = await result.session.listMcpTools();
+     *   console.log(`Found ${toolsResult.tools.length} MCP tools`);
+     *   await result.session.delete();
+     * }
+     * ```
      */
     listMcpTools(imageId?: string): Promise<McpToolsResult>;
     /**
@@ -4340,6 +5531,21 @@ declare class Session {
      * @param args - Arguments to pass to the tool
      * @param autoGenSession - Whether to automatically generate session if not exists (default: false)
      * @returns McpToolResult containing the response data
+     *
+     * @example
+     * ```typescript
+     * const agentBay = new AgentBay({ apiKey: 'your_api_key' });
+     * const result = await agentBay.create();
+     * if (result.success) {
+     *   const shellResult = await result.session.callMcpTool('shell', { command: "echo 'Hello'" });
+     *   console.log(`Output: ${shellResult.data}`);
+     *   await result.session.delete();
+     * }
+     * ```
+     *
+     * @remarks
+     * For press_keys tool, key names are automatically normalized to correct case format.
+     * This improves case compatibility (e.g., "CTRL" -> "Ctrl", "tab" -> "Tab").
      */
     callMcpTool(toolName: string, args: any, autoGenSession?: boolean): Promise<McpToolResult>;
 }
@@ -4498,6 +5704,16 @@ declare class ExtensionsService {
      *
      * @returns Promise that resolves to an array of Extension objects.
      * @throws {AgentBayError} If listing extensions fails.
+     *
+     * @example
+     * ```typescript
+     * const agentBay = new AgentBay({ apiKey: 'your_api_key' });
+     * const service = new ExtensionsService(agentBay, 'my_extensions');
+     * await service.create('/path/to/ext1.zip');
+     * const extensions = await service.list();
+     * console.log(`Found ${extensions.length} extensions`);
+     * await service.cleanup();
+     * ```
      */
     list(): Promise<Extension[]>;
     /**
@@ -4508,6 +5724,15 @@ declare class ExtensionsService {
      * @throws {Error} If the local file doesn't exist.
      * @throws {Error} If the file format is not supported (only .zip is supported).
      * @throws {AgentBayError} If upload fails.
+     *
+     * @example
+     * ```typescript
+     * const agentBay = new AgentBay({ apiKey: 'your_api_key' });
+     * const service = new ExtensionsService(agentBay);
+     * const extension = await service.create('/path/to/my-extension.zip');
+     * console.log(`Extension ID: ${extension.id}`);
+     * await service.cleanup();
+     * ```
      */
     create(localPath: string): Promise<Extension>;
     /**
@@ -4519,6 +5744,16 @@ declare class ExtensionsService {
      * @throws {Error} If the new local file doesn't exist.
      * @throws {Error} If the extension doesn't exist in the context.
      * @throws {AgentBayError} If update fails.
+     *
+     * @example
+     * ```typescript
+     * const agentBay = new AgentBay({ apiKey: 'your_api_key' });
+     * const service = new ExtensionsService(agentBay, 'my_extensions');
+     * const ext = await service.create('/path/to/ext-v1.zip');
+     * const updated = await service.update(ext.id, '/path/to/ext-v2.zip');
+     * console.log('Extension updated:', updated.name);
+     * await service.cleanup();
+     * ```
      */
     update(extensionId: string, newLocalPath: string): Promise<Extension>;
     /**
@@ -4536,6 +5771,15 @@ declare class ExtensionsService {
      * Note:
      *   This method only works if the context was auto-created by this service.
      *   For existing contexts, no cleanup is performed.
+     *
+     * @example
+     * ```typescript
+     * const agentBay = new AgentBay({ apiKey: 'your_api_key' });
+     * const service = new ExtensionsService(agentBay);
+     * await service.create('/path/to/my-extension.zip');
+     * const success = await service.cleanup();
+     * console.log('Cleanup success:', success);
+     * ```
      */
     cleanup(): Promise<boolean>;
     /**
@@ -4543,6 +5787,16 @@ declare class ExtensionsService {
      *
      * @param extensionId - ID of the extension to delete.
      * @returns Promise that resolves to true if deletion was successful, false otherwise.
+     *
+     * @example
+     * ```typescript
+     * const agentBay = new AgentBay({ apiKey: 'your_api_key' });
+     * const service = new ExtensionsService(agentBay, 'my_extensions');
+     * const ext = await service.create('/path/to/my-extension.zip');
+     * const success = await service.delete(ext.id);
+     * console.log('Delete success:', success);
+     * await service.cleanup();
+     * ```
      */
     delete(extensionId: string): Promise<boolean>;
     /**
@@ -4587,6 +5841,7 @@ declare class ExtensionsService {
  * Key Features:
  * - Browser context binding for sessions
  * - Automatic browser data upload on session end
+ * - Optional browser fingerprint integration with automatic context sync generation
  * - Optional extension integration with automatic context sync generation
  * - Clean API with ExtensionOption encapsulation
  *
@@ -4598,16 +5853,22 @@ declare class ExtensionsService {
  * ```typescript
  * // With extensions using ExtensionOption
  * import { ExtensionOption } from "./extension";
+ * import { BrowserFingerprintContext } from "./browser";
  *
  * const extOption = new ExtensionOption(
  *   "my_extensions",
  *   ["ext1", "ext2"]
  * );
  *
+ * const fingerprintContext = new BrowserFingerprintContext(
+ *   "my_fingerprint_context"
+ * );
+ *
  * const browserContext = new BrowserContext(
  *   "browser_session",
  *   true,
- *   extOption
+ *   extOption,
+ *   fingerprintContext
  * );
  *
  * // Without extensions (minimal configuration)
@@ -4615,7 +5876,15 @@ declare class ExtensionsService {
  *   "browser_session",
  *   true
  * );
- * // extensionContextSyncs will be undefined
+ * // extensionContextSyncs and fingerprintContextSync will be undefined
+ *
+ * // With fingerprint only
+ * const browserContextWithFingerprint = new BrowserContext(
+ *   "browser_session",
+ *   true,
+ *   undefined,
+ *   fingerprintContext
+ * );
  * ```
  */
 declare class BrowserContext {
@@ -4623,6 +5892,12 @@ declare class BrowserContext {
     contextId: string;
     /** Whether to automatically upload browser data when the session ends */
     autoUpload: boolean;
+    /** Optional browser fingerprint context configuration object containing fingerprintContextId */
+    fingerprintContext?: BrowserFingerprintContext;
+    /** ID of the fingerprint context for browser fingerprint. Set automatically from fingerprint_context. */
+    fingerprintContextId?: string;
+    /** Auto-generated context sync for fingerprint. None if no fingerprint configuration provided. */
+    fingerprintContextSync?: ContextSync;
     /** Optional extension configuration object containing context_id and extension_ids */
     extensionOption?: ExtensionOption;
     /** ID of the extension context for browser extensions. Set automatically from extension_option. */
@@ -4632,7 +5907,7 @@ declare class BrowserContext {
     /** Auto-generated context syncs for extensions. None if no extension configuration provided. */
     extensionContextSyncs?: ContextSync[];
     /**
-     * Initialize BrowserContextImpl with optional extension support.
+     * Initialize BrowserContextImpl with optional extension and fingerprint support.
      *
      * @param contextId - ID of the browser context to bind to the session.
      *                   This identifies the browser instance for the session.
@@ -4642,17 +5917,28 @@ declare class BrowserContext {
      *                         contextId and extensionIds. This encapsulates
      *                         all extension-related configuration.
      *                         Defaults to undefined.
+     * @param fingerprintContext - Browser fingerprint context configuration object containing
+     *                            fingerprintContextId. This encapsulates
+     *                            all fingerprint-related configuration.
+     *                            Defaults to undefined.
      *
      * Extension Configuration:
      * - **ExtensionOption**: Use extensionOption parameter with an ExtensionOption object
      * - **No Extensions**: Don't provide extensionOption parameter
      *
+     * Fingerprint Configuration:
+     * - **BrowserFingerprintContext**: Use fingerprintContext parameter with a BrowserFingerprintContext object
+     * - **No Fingerprint**: Don't provide fingerprintContext parameter
+     *
      * Auto-generation:
      * - extensionContextSyncs is automatically generated when extensionOption is provided
      * - extensionContextSyncs will be undefined if no extensionOption is provided
      * - extensionContextSyncs will be a ContextSync[] if extensionOption is valid
+     * - fingerprintContextSync is automatically generated when fingerprintContext is provided
+     * - fingerprintContextSync will be undefined if no fingerprintContext is provided
+     * - fingerprintContextSync will be a ContextSync if fingerprintContext is valid
      */
-    constructor(contextId: string, autoUpload?: boolean, extensionOption?: ExtensionOption);
+    constructor(contextId: string, autoUpload?: boolean, extensionOption?: ExtensionOption, fingerprintContext?: BrowserFingerprintContext);
     /**
      * Create ContextSync configurations for browser extensions.
      *
@@ -4664,11 +5950,28 @@ declare class BrowserContext {
      */
     private _createExtensionContextSyncs;
     /**
-     * Get all context syncs including extension syncs.
+     * Create ContextSync configuration for browser fingerprint.
+     *
+     * This method is called only when fingerprintContext is provided and contains
+     * valid fingerprint configuration (fingerprintContextId).
+     *
+     * @returns ContextSync - Context sync configuration for fingerprint.
+     *                       Returns undefined if fingerprint configuration is invalid.
+     */
+    private _createFingerprintContextSync;
+    /**
+     * Get context syncs for extensions.
+     *
+     * @returns ContextSync[] - Context sync configurations for extensions. Returns empty list if no extensions configured.
+     */
+    getExtensionContextSyncs(): ContextSync[];
+    /**
+     * Get context sync for fingerprint.
      *
-     * @returns ContextSync[] - All context sync configurations. Returns empty list if no extensions configured.
+     * @returns ContextSync - Context sync configuration for fingerprint.
+     *                       Returns undefined if fingerprint configuration is invalid.
      */
-    getAllContextSyncs(): ContextSync[];
+    getFingerprintContextSync(): ContextSync | undefined;
 }
 /**
  * Configuration interface for CreateSessionParams
@@ -4749,18 +6052,12 @@ declare class CreateSessionParams$1 implements CreateSessionParamsConfig {
      * GetLabelsJSON returns the labels as a JSON string.
      * Returns an object with success status and result/error message to match Go version behavior.
      */
-    getLabelsJSON(): {
-        result: string;
-        error?: string;
-    };
+    private getLabelsJSON;
     /**
      * GetExtraConfigsJSON returns the extra configs as a JSON string.
      * Returns an object with result and optional error message to match Go version behavior.
      */
-    getExtraConfigsJSON(): {
-        result: string;
-        error?: string;
-    };
+    private getExtraConfigsJSON;
     /**
      * AddContextSync adds a context sync configuration to the session parameters.
      */
@@ -4869,19 +6166,49 @@ declare class AgentBay {
      * @param params - Optional parameters for creating the session
      * @returns SessionResult containing the created session and request ID
      */
-    create(params?: CreateSessionParams): Promise<SessionResult>;
     /**
-     * List sessions filtered by the provided labels with pagination support.
-     * It returns sessions that match all the specified labels.
+     * Creates a new AgentBay session with specified configuration.
      *
-     * @deprecated This method is deprecated and will be removed in a future version. Use list() instead.
+     * @param params - Configuration parameters for the session:
+     *                 - labels: Key-value pairs for session metadata
+     *                 - imageId: Custom image ID for the session environment
+     *                 - contextSync: Array of context synchronization configurations
+     *                 - browserContext: Browser-specific context configuration
+     *                 - isVpc: Whether to create a VPC session
+     *                 - policyId: Security policy ID
+     *                 - enableBrowserReplay: Enable browser session recording
+     *                 - extraConfigs: Additional configuration options
+     *                 - framework: Framework identifier for tracking
      *
-     * **Breaking Change**: This method currently only accepts ListSessionParams parameters，
+     * @returns Promise resolving to SessionResult containing:
+     *          - success: Whether session creation succeeded
+     *          - session: Session object for interacting with the environment
+     *          - requestId: Unique identifier for this API request
+     *          - errorMessage: Error description if creation failed
      *
-     * @param params - Parameters including labels and pagination options (required)
-     * @returns API response with sessions list and pagination info
+     * @throws Error if API call fails or authentication is invalid.
+     *
+     * @example
+     * ```typescript
+     * const agentBay = new AgentBay({ apiKey: 'your_api_key' });
+     * const result = await agentBay.create({ labels: { project: 'demo' } });
+     * if (result.success) {
+     *   await result.session.filesystem.readFile('/etc/hostname');
+     *   await result.session.delete();
+     * }
+     * ```
+     *
+     * @remarks
+     * **Behavior:**
+     * - Creates a new isolated cloud runtime environment
+     * - Automatically creates file transfer context if not provided
+     * - Waits for context synchronization if contextSync is specified
+     * - For VPC sessions, includes VPC-specific configuration
+     * - Browser replay creates a separate recording context
+     *
+     * @see {@link get}, {@link list}, {@link Session.delete}
      */
-    listByLabels(params?: ListSessionParams): Promise<SessionListResult>;
+    create(params?: CreateSessionParams): Promise<SessionResult>;
     /**
      * Returns paginated list of session IDs filtered by labels.
      *
@@ -4893,22 +6220,9 @@ declare class AgentBay {
      * @example
      * ```typescript
      * const agentBay = new AgentBay({ apiKey: "your_api_key" });
-     *
-     * // List all sessions
-     * const result = await agentBay.list();
-     *
-     * // List sessions with specific labels
-     * const result = await agentBay.list({ project: "demo" });
-     *
-     * // List sessions with pagination
-     * const result = await agentBay.list({ "my-label": "my-value" }, 2, 10);
-     *
+     * const result = await agentBay.list({ project: "demo" }, 1, 10);
      * if (result.success) {
-     *   for (const sessionId of result.sessionIds) {
-     *     console.log(`Session ID: ${sessionId}`);
-     *   }
-     *   console.log(`Total count: ${result.totalCount}`);
-     *   console.log(`Request ID: ${result.requestId}`);
+     *   console.log(`Found ${result.sessionIds.length} sessions`);
      * }
      * ```
      */
@@ -4919,11 +6233,34 @@ declare class AgentBay {
      * @param session - The session to delete.
      * @param syncContext - Whether to sync context data (trigger file uploads) before deleting the session. Defaults to false.
      * @returns DeleteResult indicating success or failure and request ID
+     *
+     * @example
+     * ```typescript
+     * const agentBay = new AgentBay({ apiKey: 'your_api_key' });
+     * const result = await agentBay.create();
+     * if (result.success) {
+     *   await agentBay.delete(result.session);
+     * }
+     * ```
      */
     delete(session: Session, syncContext?: boolean): Promise<DeleteResult>;
     /**
+     * Remove a session from the internal session cache.
+     *
+     * This is an internal utility method that removes a session reference from the AgentBay client's
+     * session cache without actually deleting the session from the cloud. Use this when you need to
+     * clean up local references to a session that was deleted externally or no longer needed.
+     *
+     * @param sessionId - The ID of the session to remove from the cache.
+     *
+     * @internal
+     *
+     * @remarks
+     * **Note:** This method only removes the session from the local cache. It does not delete the
+     * session from the cloud. To delete a session from the cloud, use {@link delete} or
+     * {@link Session.delete}.
      *
-     * @param sessionId - The ID of the session to remove.
+     * @see {@link delete}, {@link Session.delete}
      */
     removeSession(sessionId: string): void;
     /**
@@ -4944,15 +6281,42 @@ declare class AgentBay {
      *
      * @example
      * ```typescript
-     * const result = await agentBay.get("my-session-id");
-     * if (result.success) {
-     *   console.log(result.session.sessionId);
-     *   console.log(result.requestId);
+     * const agentBay = new AgentBay({ apiKey: 'your_api_key' });
+     * const createResult = await agentBay.create();
+     * if (createResult.success) {
+     *   const result = await agentBay.get(createResult.session.sessionId);
+     *   await result.session?.filesystem.readFile('/etc/hostname');
+     *   await result.session?.delete();
      * }
      * ```
      */
     get(sessionId: string): Promise<SessionResult>;
+    /**
+     * Get the internal HTTP client instance.
+     *
+     * This is primarily for internal use and advanced scenarios where you need direct access
+     * to the underlying API client.
+     *
+     * @returns The Client instance used for API communication
+     *
+     * @internal
+     *
+     * @remarks
+     * **Note:** This method is primarily for internal use. Most users should interact
+     * with the SDK through higher-level methods like `create()`, `get()`, and `list()`.
+     */
     getClient(): Client;
+    /**
+     * Get the API key used for authentication.
+     *
+     * @returns The API key string
+     *
+     * @internal
+     *
+     * @remarks
+     * **Security Note:** Be careful when logging or exposing API keys. Always keep them secure
+     * and never commit them to version control.
+     */
     getAPIKey(): string;
 }
 
@@ -4982,12 +6346,6 @@ declare class APIError extends AgentBayError {
 declare class FileError extends AgentBayError {
     constructor(message?: string, extra?: Record<string, any>);
 }
-/**
- * Raised for errors related to command execution.
- */
-declare class CommandError extends AgentBayError {
-    constructor(message?: string, extra?: Record<string, any>);
-}
 /**
  * Raised for errors related to session operations.
  */
@@ -5000,18 +6358,6 @@ declare class SessionError extends AgentBayError {
 declare class OssError extends AgentBayError {
     constructor(message?: string, extra?: Record<string, any>);
 }
-/**
- * Raised for errors related to application operations.
- */
-declare class ApplicationError extends AgentBayError {
-    constructor(message?: string, extra?: Record<string, any>);
-}
-/**
- * Raised for errors related to UI operations.
- */
-declare class UIError extends AgentBayError {
-    constructor(message?: string, extra?: Record<string, any>);
-}
 /**
  * Raised for errors related to browser operations.
  */
@@ -5029,6 +6375,37 @@ declare class BrowserError extends AgentBayError {
 type LogLevel = 'DEBUG' | 'INFO' | 'WARN' | 'ERROR';
 /**
  * Logger configuration options
+ *
+ * @example
+ * ```typescript
+ * import { AgentBay, setupLogger } from 'wuying-agentbay-sdk';
+ *
+ * const agentBay = new AgentBay({ apiKey: 'your_api_key' });
+ *
+ * async function demonstrateLogging() {
+ *     try {
+ *         // Configure logging with file output
+ *         setupLogger({
+ *             level: 'DEBUG',
+ *             logFile: '/var/log/agentbay.log',
+ *             maxFileSize: '100 MB',
+ *             enableConsole: true
+ *         });
+ *
+ *         // Create a session - logs will be written to both console and file
+ *         const result = await agentBay.create();
+ *         if (result.success) {
+ *             const session = result.session;
+ *             console.log(`Session created: ${session.sessionId}`);
+ *             await session.delete();
+ *         }
+ *     } catch (error) {
+ *         console.error('Error:', error);
+ *     }
+ * }
+ *
+ * demonstrateLogging().catch(console.error);
+ * ```
  */
 interface LoggerConfig {
     level?: LogLevel;
@@ -5036,13 +6413,6 @@ interface LoggerConfig {
     maxFileSize?: string;
     enableConsole?: boolean;
 }
-/**
- * Mask sensitive information in data structures
- * @param data Data to mask (dict, str, list, etc.)
- * @param fields Additional sensitive field names
- * @returns Masked data (deep copy)
- */
-declare function maskSensitiveData(data: any, fields?: string[]): any;
 /**
  * Set the log level
  * @param level The log level to set
@@ -5056,6 +6426,37 @@ declare function getLogLevel(): LogLevel;
 /**
  * Setup logger configuration
  * @param config Logger configuration options
+ *
+ * @example
+ * ```typescript
+ * import { AgentBay, setupLogger } from 'wuying-agentbay-sdk';
+ *
+ * const agentBay = new AgentBay({ apiKey: 'your_api_key' });
+ *
+ * async function demonstrateLogging() {
+ *     try {
+ *         // Configure logging to file only
+ *         setupLogger({
+ *             level: 'DEBUG',
+ *             logFile: '/var/log/myapp.log',
+ *             maxFileSize: '100 MB',
+ *             enableConsole: false
+ *         });
+ *
+ *         // Create a session - logs will only be written to file
+ *         const result = await agentBay.create({ imageId: 'browser_latest' });
+ *         if (result.success) {
+ *             const session = result.session;
+ *             // All operations will be logged to file
+ *             await session.delete();
+ *         }
+ *     } catch (error) {
+ *         console.error('Error:', error);
+ *     }
+ * }
+ *
+ * demonstrateLogging().catch(console.error);
+ * ```
  */
 declare function setupLogger(config: LoggerConfig): void;
 /**
@@ -5090,4 +6491,4 @@ declare function logWarn(message: string, ...args: any[]): void;
  */
 declare function logError(message: string, error?: any): void;
 
-export { APIError, APP_BLACKLIST_TEMPLATE, APP_WHITELIST_TEMPLATE, type ActOptions, ActResult, Agent, AgentBay, AgentBayError, type ApiResponse, type ApiResponseWithData, type AppManagerRule, Application, ApplicationError, ApplyMqttTokenRequest, ApplyMqttTokenResponse, ApplyMqttTokenResponseBody, ApplyMqttTokenResponseBodyData, AuthenticationError, type BWList, Browser, BrowserAgent, BrowserContext, BrowserError, type BrowserFingerprint, type BrowserOption, BrowserOptionClass, type BrowserProxy, BrowserProxyClass, type BrowserScreen, type BrowserViewport, CallMcpToolRequest, CallMcpToolResponse, CallMcpToolResponseBody, ClearContextRequest, ClearContextResponse, ClearContextResponseBody, Client, Command, CommandError, type Config, Context, type ContextInfoResult, ContextManager, ContextService, type ContextStatusData, type ContextStatusItem, ContextSync, type ContextSyncResult, CreateMcpSessionRequest, CreateMcpSessionRequestPersistenceDataList, CreateMcpSessionResponse, CreateMcpSessionResponseBody, CreateMcpSessionResponseBodyData, CreateMcpSessionShrinkRequest, type CreateSessionParams, type CreateSessionParamsConfig, DeleteContextFileRequest, DeleteContextFileResponse, DeleteContextFileResponseBody, DeleteContextRequest, DeleteContextResponse, DeleteContextResponseBody, type DeletePolicy, type DeleteResult, DescribeContextFilesRequest, DescribeContextFilesResponse, DescribeContextFilesResponseBody, type DirectoryEntry, type DownloadPolicy, DownloadStrategy, type ExecutionResult, Extension, ExtensionOption, ExtensionsService, type ExtraConfigs, type ExtractOptions, type ExtractPolicy, ExtractPolicyClass, type FileChangeEvent, FileChangeEventHelper, type FileChangeResult, FileChangeResultHelper, FileError, type FileInfo, FileSystem, GetContextFileDownloadUrlRequest, GetContextFileDownloadUrlResponse, GetContextFileDownloadUrlResponseBody, GetContextFileUploadUrlRequest, GetContextFileUploadUrlResponse, GetContextFileUploadUrlResponseBody, GetContextInfoRequest, GetContextInfoResponse, GetContextInfoResponseBody, GetContextInfoResponseBodyData, GetContextRequest, GetContextResponse, GetContextResponseBody, GetContextResponseBodyData, GetLabelRequest, GetLabelResponse, GetLabelResponseBody, GetLabelResponseBodyData, GetLinkRequest, GetLinkResponse, GetLinkResponseBody, GetLinkResponseBodyData, GetMcpResourceRequest, GetMcpResourceResponse, GetMcpResourceResponseBody, GetMcpResourceResponseBodyData, GetMcpResourceResponseBodyDataDesktopInfo, GetSessionRequest, GetSessionResponse, GetSessionResponseBody, GetSessionResponseBodyData, HIDE_NAVIGATION_BAR_TEMPLATE, IS_RELEASE, InitBrowserRequest, InitBrowserResponse, InitBrowserResponseBody, InitBrowserResponseBodyData, type InstalledApp$1 as InstalledApp, KeyCode, Lifecycle, ListContextsRequest, ListContextsResponse, ListContextsResponseBody, ListContextsResponseBodyData, ListMcpToolsRequest, ListMcpToolsResponse, ListMcpToolsResponseBody, type ListSessionParams, ListSessionRequest, ListSessionResponse, ListSessionResponseBody, ListSessionResponseBodyData, type LogLevel, type LoggerConfig, MOBILE_COMMAND_TEMPLATES, type McpSession, type McpToolResult, type MobileExtraConfig, ModifyContextRequest, ModifyContextResponse, ModifyContextResponseBody, type ObserveOptions, ObserveResult, Oss, OssError, type Process$1 as Process, type QueryResult, RESOLUTION_LOCK_TEMPLATE, type RecyclePolicy, ReleaseMcpSessionRequest, ReleaseMcpSessionResponse, ReleaseMcpSessionResponseBody, SHOW_NAVIGATION_BAR_TEMPLATE, Session, SessionError, type SessionInterface, type SessionListResult, SetLabelRequest, SetLabelResponse, SetLabelResponseBody, type SyncCallback, SyncContextRequest, SyncContextResponse, SyncContextResponseBody, type SyncPolicy, SyncPolicyImpl, UI, type UIElement, UIError, UNINSTALL_BLACKLIST_TEMPLATE, UploadMode, type UploadPolicy, UploadStrategy, VERSION, type WhiteList, WhiteListValidator, createListSessionParams, extraConfigsFromJSON, extraConfigsToJSON, extractRequestId, getLogLevel, getMobileCommandTemplate, hasMobileCommandTemplate, loadConfig, loadDotEnv, log, logDebug, logError, logInfo, logWarn, maskSensitiveData, newContextManager, newContextSync, newCreateSessionParams, newDeletePolicy, newDownloadPolicy, newExtractPolicy, newRecyclePolicy, newSyncPolicy, newSyncPolicyWithDefaults, newUploadPolicy, replaceTemplatePlaceholders, setLogLevel, setupLogger, validateAppManagerRule, validateExtraConfigs, validateMobileExtraConfig, validateSyncPolicy };
+export { APIError, APP_BLACKLIST_TEMPLATE, APP_WHITELIST_TEMPLATE, type ActOptions, ActResult, Agent, AgentBay, AgentBayError, type ApiResponse, type ApiResponseWithData, type AppManagerRule, ApplyMqttTokenRequest, ApplyMqttTokenResponse, ApplyMqttTokenResponseBody, ApplyMqttTokenResponseBodyData, AuthenticationError, type BWList, type Brand, Browser, BrowserAgent, BrowserContext, BrowserError, type BrowserFingerprint, BrowserFingerprintContext, BrowserFingerprintGenerator, type BrowserOption, BrowserOptionClass, type BrowserProxy, BrowserProxyClass, type BrowserScreen, type BrowserViewport, CallMcpToolRequest, CallMcpToolResponse, CallMcpToolResponseBody, ClearContextRequest, ClearContextResponse, ClearContextResponseBody, Client, Code, Command, Computer, type Config, Context, type ContextInfoResult, ContextManager, ContextService, type ContextStatusData, type ContextStatusItem, ContextSync, type ContextSyncResult, CreateMcpSessionRequest, CreateMcpSessionRequestPersistenceDataList, CreateMcpSessionResponse, CreateMcpSessionResponseBody, CreateMcpSessionResponseBodyData, CreateMcpSessionShrinkRequest, type CreateSessionParams, type CreateSessionParamsConfig, DeleteContextFileRequest, DeleteContextFileResponse, DeleteContextFileResponseBody, DeleteContextRequest, DeleteContextResponse, DeleteContextResponseBody, type DeletePolicy, type DeleteResult, DescribeContextFilesRequest, DescribeContextFilesResponse, DescribeContextFilesResponseBody, type DirectoryEntry, type DownloadPolicy, DownloadStrategy, type ExecutionResult, Extension, ExtensionOption, ExtensionsService, type ExtraConfigs, type ExtraProperties, type ExtractOptions, type ExtractPolicy, ExtractPolicyClass, type FileChangeEvent, FileChangeEventHelper, type FileChangeResult, FileChangeResultHelper, FileError, type FileInfo, FileSystem, type Fingerprint, FingerprintFormat, GetAdbLinkRequest, GetAdbLinkResponse, GetAdbLinkResponseBody, GetAdbLinkResponseBodyData, GetCdpLinkRequest, GetCdpLinkResponse, GetCdpLinkResponseBody, GetCdpLinkResponseBodyData, GetContextFileDownloadUrlRequest, GetContextFileDownloadUrlResponse, GetContextFileDownloadUrlResponseBody, GetContextFileUploadUrlRequest, GetContextFileUploadUrlResponse, GetContextFileUploadUrlResponseBody, GetContextInfoRequest, GetContextInfoResponse, GetContextInfoResponseBody, GetContextInfoResponseBodyData, GetContextRequest, GetContextResponse, GetContextResponseBody, GetContextResponseBodyData, GetLabelRequest, GetLabelResponse, GetLabelResponseBody, GetLabelResponseBodyData, GetLinkRequest, GetLinkResponse, GetLinkResponseBody, GetLinkResponseBodyData, GetMcpResourceRequest, GetMcpResourceResponse, GetMcpResourceResponseBody, GetMcpResourceResponseBodyData, GetMcpResourceResponseBodyDataDesktopInfo, GetSessionRequest, GetSessionResponse, GetSessionResponseBody, GetSessionResponseBodyData, HIDE_NAVIGATION_BAR_TEMPLATE, IS_RELEASE, InitBrowserRequest, InitBrowserResponse, InitBrowserResponseBody, InitBrowserResponseBodyData, Lifecycle, ListContextsRequest, ListContextsResponse, ListContextsResponseBody, ListContextsResponseBodyData, ListMcpToolsRequest, ListMcpToolsResponse, ListMcpToolsResponseBody, type ListSessionParams, ListSessionRequest, ListSessionResponse, ListSessionResponseBody, ListSessionResponseBodyData, type LogLevel, type LoggerConfig, MOBILE_COMMAND_TEMPLATES, type MappingPolicy, type McpSession, type McpToolResult, Mobile, type MobileExtraConfig, ModifyContextRequest, ModifyContextResponse, ModifyContextResponseBody, type NavigatorFingerprint, type ObserveOptions, ObserveResult, Oss, OssError, type QueryResult, RESOLUTION_LOCK_TEMPLATE, type RecyclePolicy, ReleaseMcpSessionRequest, ReleaseMcpSessionResponse, ReleaseMcpSessionResponseBody, SHOW_NAVIGATION_BAR_TEMPLATE, type ScreenFingerprint, Session, SessionError, type SessionInterface, type SessionListResult, SetLabelRequest, SetLabelResponse, SetLabelResponseBody, type SyncCallback, SyncContextRequest, SyncContextResponse, SyncContextResponseBody, type SyncPolicy, SyncPolicyImpl, UNINSTALL_BLACKLIST_TEMPLATE, UploadMode, type UploadPolicy, UploadStrategy, type UserAgentData, VERSION, type VideoCard, type WhiteList, WhiteListValidator, createListSessionParams, extraConfigsFromJSON, extraConfigsToJSON, extractRequestId, getLogLevel, getMobileCommandTemplate, hasMobileCommandTemplate, log, logDebug, logError, logInfo, logWarn, newContextManager, newContextSync, newCreateSessionParams, newDeletePolicy, newDownloadPolicy, newExtractPolicy, newMappingPolicy, newRecyclePolicy, newSyncPolicy, newSyncPolicyWithDefaults, newUploadPolicy, replaceTemplatePlaceholders, setLogLevel, setupLogger, validateAppManagerRule, validateExtraConfigs, validateMobileExtraConfig };