chore: release version 0.7.0

- Add session pause/resume functionality
- Enhance browser automation test stability
- Improve HTTP client and API models
- Update documentation and example code
- Add MCP access guide
- Enhance unit and integration test coverage

Author: AgbAccount

CHANGES.md

@@ -1,5 +1,48 @@
 # Changelog
 
+## [0.7.0] - 2025-12-18
+
+### New Features
+- **Browser Fingerprint Enhancement**: Comprehensive browser fingerprint management with persistence, local sync, and advanced configuration options
+- **Computer Automation Module**: Full desktop automation capabilities including:
+  - Screenshot capture support for AGB sessions
+  - Keyboard input functionality with comprehensive key support
+  - Mouse operations with button and scroll direction enums
+  - Window listing and management functionality
+  - Application operations support
+- **File Transfer Function**: Complete file transfer functionality for moving files between local and remote environments
+- **Session Pause and Resume**: Added pause and resume functionality for sessions to optimize resource usage and costs
+- **Async Session Deletion**: Migrated session deletion API from `release_mcp_session` to `delete_session_async` with polling support
+- **Browser Type Configuration**: Support for browser type and command arguments settings for enhanced browser control
+- **MCP Access Documentation**: Comprehensive guide for MCP (Model Context Protocol) access and configuration
+
+### Enhancements
+- **Context Manager**: Improved error handling by returning error results instead of raising exceptions in context sync validation
+- **Browser Agent**: Enhanced browser agent with improved integration tests and better error handling
+- **API Documentation**: Added fingerprint module to API documentation generation
+- **Code Examples**: Optimized and improved code examples throughout documentation
+
+### Documentation
+- Added MCP access guide with comprehensive configuration instructions
+- Added examples for application and window operations
+- Updated text input examples in documentation
+- Corrected documentation regarding command execution instructions
+- Standardized guides structure to match template
+- Fixed ContextManager docstring to use AGB instead of AgentBay
+- Removed example code from ContextManager docstring
+- Added file transfer guide markdown
+
+### Refactoring
+- Removed unused `http_port` and `token` fields from session response models
+- Improved context sync validation to return error results instead of exceptions
+- Cleaned up unrelated files and code
+
+### Testing & CI/CD
+- Added comprehensive unit and integration tests for pause and resume functionality
+- Optimized CI/CD pipeline summary with switch state for better visibility
+- Enhanced test coverage for computer module, file transfer, and browser fingerprint features
+- Fixed context manager sync tests to match new validation logic
+
 ## [0.6.0] - 2025-12-04
 
 ### New Features
@@ -27,7 +70,6 @@
 - Added CI bot guard to prevent infinite loops and enhanced error detection
 - Fixed AONE documentation pipeline configuration and optimized documentation workflow
 
-
 ## [0.5.0] - 2025-11-20
 
 ### New Features

agb/__init__.py

@@ -8,6 +8,7 @@
 from .context_sync import ContextSync, SyncPolicy, UploadPolicy, DownloadPolicy, DeletePolicy, ExtractPolicy, UploadStrategy, DownloadStrategy, UploadMode, MappingPolicy
 from .extension import ExtensionsService, ExtensionOption, Extension
 from .modules.computer import Computer, MouseButton, ScrollDirection
+from .model.response import SessionPauseResult, SessionResumeResult
 
 __all__ = [
     "AGB", "Session", "CreateSessionParams", "HTTPClient", "Client",
@@ -17,5 +18,7 @@
     "ContextSync", "SyncPolicy", "UploadPolicy", "DownloadPolicy", "DeletePolicy", "ExtractPolicy",
     "UploadStrategy", "DownloadStrategy", "UploadMode", "MappingPolicy", "ExtensionsService","ExtensionOption","Extension",
     # Computer related exports
-    "Computer", "MouseButton", "ScrollDirection"
+    "Computer", "MouseButton", "ScrollDirection",
+    # Pause and resume related exports
+    "SessionPauseResult", "SessionResumeResult",
 ]

agb/agb.py

@@ -19,7 +19,7 @@
 )
 from agb.config import Config, load_config, BROWSER_DATA_PATH
 from agb.context_sync import ContextSync, WhiteList, UploadPolicy, BWList, RecyclePolicy, SyncPolicy
-from agb.model.response import DeleteResult, SessionResult, GetSessionResult, GetSessionData, SessionListResult
+from agb.model.response import DeleteResult, SessionResult, GetSessionResult, GetSessionData, SessionListResult, SessionPauseResult, SessionResumeResult
 from agb.session import Session
 from agb.session_params import CreateSessionParams
 from agb.context import ContextService
@@ -171,10 +171,10 @@ def create(self, params: Optional[CreateSessionParams] = None) -> SessionResult:
             response: CreateSessionResponse = self.client.create_mcp_session(request)
 
             try:
-                logger.debug("Response body:")
-                logger.debug(response.to_dict())
+                logger.info("Response body:")
+                logger.info(response.to_dict())
             except Exception:
-                logger.debug(f"Response: {response}")
+                logger.info(f"Response: {response}")
 
             # Extract request ID
             request_id_attr = getattr(response, "request_id", "")
@@ -509,6 +509,7 @@ def get_session(self, session_id: str) -> GetSessionResult:
                     session_id=response.data.session_id or session_id,
                     success=True,
                     resource_url=response.data.resource_url or "",
+                    status=response.data.status or "",
                 )
 
             # Log API response with key details
@@ -587,4 +588,68 @@ def get(self, session_id: str) -> SessionResult:
             request_id=get_result.request_id or "",
             success=True,
             session=session,
-        )
+        )
+
+    def pause(self, session: Session, timeout: int = 600, poll_interval: float = 2.0) -> SessionPauseResult:
+        """
+        Pause a session, putting it into a dormant state.
+
+        Args:
+            session (Session): The session to pause.
+            timeout (int, optional): Timeout in seconds to wait for the session to pause.
+                Defaults to 600 seconds.
+            poll_interval (float, optional): Interval in seconds between status polls.
+                Defaults to 2.0 seconds.
+
+        Returns:
+            SessionPauseResult: Result containing the request ID, success status, and final session status.
+        """
+        return session.pause(timeout, poll_interval)
+
+    async def pause_async(self, session: Session, timeout: int = 600, poll_interval: float = 2.0) -> SessionPauseResult:
+        """
+        Pause a session asynchronously.
+
+        Args:
+            session (Session): The session to pause.
+            timeout (int, optional): Timeout in seconds to wait for the session to pause.
+                Defaults to 600 seconds.
+            poll_interval (float, optional): Interval in seconds between status polls.
+                Defaults to 2.0 seconds.
+
+        Returns:
+            SessionPauseResult: Result containing the request ID, success status, and final session status.
+        """
+        return await session.pause_async(timeout, poll_interval)
+
+    def resume(self, session: Session, timeout: int = 600, poll_interval: float = 2.0) -> SessionResumeResult:
+        """
+        Resume a session from a paused state.
+
+        Args:
+            session (Session): The session to resume.
+            timeout (int, optional): Timeout in seconds to wait for the session to resume.
+                Defaults to 600 seconds.
+            poll_interval (float, optional): Interval in seconds between status polls.
+                Defaults to 2.0 seconds.
+
+        Returns:
+            SessionResumeResult: Result containing the request ID, success status, and final session status.
+        """
+        return session.resume(timeout, poll_interval)
+
+    async def resume_async(self, session: Session, timeout: int = 600, poll_interval: float = 2.0) -> SessionResumeResult:
+        """
+        Resume a session asynchronously.
+
+        Args:
+            session (Session): The session to resume.
+            timeout (int, optional): Timeout in seconds to wait for the session to resume.
+                Defaults to 600 seconds.
+            poll_interval (float, optional): Interval in seconds between status polls.
+                Defaults to 2.0 seconds.
+
+        Returns:
+            SessionResumeResult: Result containing the request ID, success status, and final session status.
+        """
+        return await session.resume_async(timeout, poll_interval)

agb/api/client.py

@@ -7,7 +7,7 @@
 
 import aiohttp
 
-from agb.api.models import (
+from .models import (
     CallMcpToolRequest,
     CallMcpToolResponse,
     CreateSessionRequest,
@@ -30,6 +30,14 @@
     SetLabelResponse,
     GetLabelRequest,
     GetLabelResponse,
+    # Pause and Resume imports
+    PauseSessionRequest,
+    PauseSessionResponse,
+    ResumeSessionRequest,
+    ResumeSessionResponse,
+    # Delete session async imports
+    DeleteSessionAsyncRequest,
+    DeleteSessionAsyncResponse,
     # Context related imports
     ListContextsRequest,
     ListContextsResponse,
@@ -580,3 +588,105 @@ def get_and_load_internal_context(self, request: GetAndLoadInternalContextReques
         finally:
             # Always close the HTTP client to release resources
             http_client.close()
+
+    def pause_session(self, request: PauseSessionRequest) -> PauseSessionResponse:
+        """
+        Pause session using HTTP client
+        """
+        if not request.authorization:
+            raise ValueError("authorization is required")
+
+        if not request.session_id:
+            raise ValueError("session_id is required")
+
+        # Get HTTP client and make request directly with the input request
+        http_client = self._get_http_client(request.authorization)
+
+        try:
+            response = http_client.pause_session(request)
+            return response
+        finally:
+            # Always close the HTTP client to release resources
+            http_client.close()
+
+    async def pause_session_async(self, request: PauseSessionRequest) -> PauseSessionResponse:
+        """
+        Pause session asynchronously using HTTP client
+        """
+        if not request.authorization:
+            raise ValueError("authorization is required")
+
+        if not request.session_id:
+            raise ValueError("session_id is required")
+
+        # Get HTTP client and make request directly with the input request
+        http_client = self._get_http_client(request.authorization)
+
+        try:
+            response = await http_client.pause_session_async(request)
+            return response
+        finally:
+            # Always close the HTTP client to release resources
+            http_client.close()
+
+
+    def resume_session(self, request: ResumeSessionRequest) -> ResumeSessionResponse:
+        """
+        Resume session using HTTP client
+        """
+        if not request.authorization:
+            raise ValueError("authorization is required")
+
+        if not request.session_id:
+            raise ValueError("session_id is required")
+
+        # Get HTTP client and make request directly with the input request
+        http_client = self._get_http_client(request.authorization)
+
+        try:
+            response = http_client.resume_session(request)
+            return response
+        finally:
+            # Always close the HTTP client to release resources
+            http_client.close()
+
+    async def resume_session_async(self, request: ResumeSessionRequest) -> ResumeSessionResponse:
+        """
+        Resume session asynchronously using HTTP client
+        """
+        if not request.authorization:
+            raise ValueError("authorization is required")
+
+        if not request.session_id:
+            raise ValueError("session_id is required")
+
+        # Get HTTP client and make request directly with the input request
+        http_client = self._get_http_client(request.authorization)
+
+        try:
+            response = await http_client.resume_session_async(request)
+            return response
+        finally:
+            # Always close the HTTP client to release resources
+            http_client.close()
+
+    def delete_session_async(self, request: "DeleteSessionAsyncRequest") -> "DeleteSessionAsyncResponse":
+        """
+        Delete session asynchronously using HTTP client
+        """
+        if not request.authorization:
+            raise ValueError("authorization is required")
+
+        if not request.session_id:
+            raise ValueError("session_id is required")
+
+        # Get HTTP client and make request directly with the input request
+        http_client = self._get_http_client(request.authorization)
+
+        try:
+            response = http_client.delete_session_async(request)
+            return response
+        finally:
+            # Always close the HTTP client to release resources
+            http_client.close()
+