agbcloud-sdk 0.1.0__py3-none-any.whl

agb/__init__.py

@@ -0,0 +1,7 @@
+from .agb import AGB
+from .session import Session
+from .session_params import CreateSessionParams
+from .api.http_client import HTTPClient
+from .api.client import Client
+
+__all__ = ["AGB", "Session", "CreateSessionParams", "HTTPClient", "Client"]

agb/agb.py

@@ -0,0 +1,215 @@
+# -*- coding: utf-8 -*-
+"""
+AGB represents the main client for interacting with the AGB cloud runtime
+environment.
+"""
+
+import json
+import os
+from typing import Dict, List, Optional, Union
+from threading import Lock
+
+from agb.api.client import Client as mcp_client
+from agb.api.models import (
+    CreateSessionRequest,
+    ReleaseSessionRequest,
+    CreateSessionResponse,
+)
+from agb.config import load_config, Config
+from agb.session import Session, BaseSession
+from agb.session_params import CreateSessionParams
+from agb.model.response import SessionResult, DeleteResult
+
+
+class AGB:
+    """
+    AGB represents the main client for interacting with the AGB cloud runtime
+    environment.
+    """
+
+    def __init__(self, api_key: str = "", cfg: Optional[Config] = None):
+        """
+        Initialize the AGB client.
+
+        Args:
+            api_key (str): API key for authentication. If not provided, it will be
+                loaded from the AGB_API_KEY environment variable.
+            cfg (Optional[Config]): Configuration object. If not provided, default
+                configuration will be used.
+        """
+        if not api_key:
+            api_key = os.getenv("AGB_API_KEY")
+            if not api_key:
+                raise ValueError(
+                    "API key is required. Provide it as a parameter or set the "
+                    "AGB_API_KEY environment variable"
+                )
+
+        # Load configuration
+        self.config = load_config(cfg)
+
+        self.api_key = api_key
+        self.endpoint = self.config.endpoint
+        self.timeout_ms = self.config.timeout_ms
+
+        # Initialize the HTTP API client with the complete config
+        self.client = mcp_client(self.config)
+        self._sessions = {}
+        self._lock = Lock()
+
+
+    def create(self, params: Optional[CreateSessionParams] = None) -> SessionResult:
+        """
+        Create a new session in the AGB cloud environment.
+
+        Args:
+            params (Optional[CreateSessionParams], optional): Parameters for
+              creating the session.Defaults to None.
+
+        Returns:
+            SessionResult: Result containing the created session and request ID.
+        """
+        try:
+            if params is None:
+                params = CreateSessionParams()
+
+            request = CreateSessionRequest(authorization=f"Bearer {self.api_key}")
+
+            if params.image_id:
+                request.image_id = params.image_id
+
+            response : CreateSessionResponse = self.client.create_mcp_session(request)
+
+            # Check if response is empty
+            if response is None:
+                return SessionResult(
+                    request_id="",
+                    success=False,
+                    error_message="OpenAPI client returned None response",
+                )
+
+            try:
+                print("Response body:")
+                print(response.to_dict())
+            except Exception:
+                print(f"Response: {response}")
+
+            # Extract request ID
+            request_id = getattr(response, 'request_id', '') or ''
+
+            # Check if the session creation was successful
+            if response.data and response.data.success is False:
+                error_msg = response.data.err_msg
+                if error_msg is None:
+                    error_msg = "Unknown error"
+                return SessionResult(
+                    request_id=request_id,
+                    success=False,
+                    error_message=error_msg,
+                )
+
+            session_id = response.get_session_id()
+            if not session_id:
+                return SessionResult(
+                    request_id=request_id,
+                    success=False,
+                    error_message=response.get_error_message(),
+                )
+
+            # ResourceUrl is optional in CreateMcpSession response
+            resource_url = response.get_resource_url()
+
+            print("session_id =", session_id)
+            print("resource_url =", resource_url)
+
+            # Create Session object
+            session = Session(self, session_id)
+            if resource_url is not None:
+                session.resource_url = resource_url
+
+            # Store image_id used for this session
+            session.image_id = params.image_id
+
+            with self._lock:
+                self._sessions[session_id] = session
+
+            # Return SessionResult with request ID
+            return SessionResult(request_id=request_id, success=True, session=session)
+
+        except Exception as e:
+            print("Error calling create_mcp_session:", e)
+            return SessionResult(
+                request_id="",
+                success=False,
+                error_message=f"Failed to create session: {e}",
+            )
+
+    def list(self) -> List[BaseSession]:
+        """
+        List all available sessions.
+
+        Returns:
+            List[BaseSession]: A list of all available sessions.
+        """
+        with self._lock:
+            return list(self._sessions.values())
+
+
+    def delete(self, session: Session) -> DeleteResult:
+        """
+        Delete a session by session object.
+
+        Args:
+            session (Session): The session to delete.
+
+        Returns:
+            DeleteResult: Result indicating success or failure and request ID.
+        """
+        try:
+            # Create request to release the session
+            request = ReleaseSessionRequest(
+                authorization=f"Bearer {self.api_key}",
+                session_id=session.session_id,
+            )
+
+            # Make the API call
+            response = self.client.release_mcp_session(request)
+
+            # Check if response is empty
+            if response is None:
+                return DeleteResult(
+                    request_id="",
+                    success=False,
+                    error_message="OpenAPI client returned None response",
+                )
+
+            # Check response type, if it's ReleaseSessionResponse, use new parsing method
+            if hasattr(response, 'is_successful'):
+                # This is a ReleaseSessionResponse object
+                if response.is_successful():
+                    # Remove from local cache
+                    with self._lock:
+                        self._sessions.pop(session.session_id, None)
+
+                    return DeleteResult(request_id=response.request_id or "", success=True)
+                else:
+                    error_msg = response.get_error_message() or "Failed to delete session"
+                    return DeleteResult(
+                        request_id=response.request_id or "",
+                        success=False,
+                        error_message=error_msg,
+                    )
+            else:
+                return DeleteResult(
+                    request_id=response.request_id or "",
+                    success=False,
+                    error_message="Failed to delete session",
+                )
+
+        except Exception as e:
+            print("Error calling release_mcp_session:", e)
+            # In case of error, return failure result with error message
+            return DeleteResult(
+                success=False,
+                error_message=f"Failed to delete session {session.session_id}: {e}",
+            )

agb/api/__init__.py

@@ -0,0 +1,11 @@
+from .http_client import HTTPClient
+from .base_service import BaseService
+from .client import Client
+
+__version__ = "1.0.0"
+
+__all__ = [
+    "HTTPClient",
+    "BaseService",
+    "Client",
+]

agb/api/base_service.py

@@ -0,0 +1,122 @@
+import json
+import requests
+import time
+import random
+import string
+from typing import Any, Dict
+
+from agb.api.models import CallMcpToolRequest
+from agb.exceptions import AGBError
+from agb.model import OperationResult
+
+
+class BaseService:
+    """
+    Base service class that provides common functionality for all service classes.
+    This class implements the common methods for calling MCP tools and parsing
+    responses.
+    """
+
+    def __init__(self, session):
+        """
+        Initialize a BaseService object.
+
+        Args:
+            session: The Session instance that this service belongs to.
+        """
+        self.session = session
+
+    def _handle_error(self, e):
+        """
+        Handle and convert exceptions. This method should be overridden by subclasses
+        to provide specific error handling.
+
+        Args:
+            e (Exception): The exception to handle.
+
+        Returns:
+            Exception: The handled exception.
+        """
+        return e
+
+    def _call_mcp_tool(self, name: str, args: Dict[str, Any], read_timeout: int = None, connect_timeout: int = None) -> OperationResult:
+        """
+        Internal helper to call MCP tool and handle errors.
+
+        Args:
+            name (str): The name of the tool to call.
+            args (Dict[str, Any]): The arguments to pass to the tool.
+
+        Returns:
+            OperationResult: The response from the tool with request ID.
+        """
+        try:
+            args_json = json.dumps(args, ensure_ascii=False)
+
+            # use traditional API call
+            request = CallMcpToolRequest(
+                authorization=f"Bearer {self.session.get_api_key()}",
+                session_id=self.session.get_session_id(),
+                name=name,
+                args=args_json,
+            )
+            response = self.session.get_client().call_mcp_tool(request, read_timeout=read_timeout, connect_timeout=connect_timeout)
+
+            # Check if response is empty
+            if response is None:
+                return OperationResult(
+                    request_id="",
+                    success=False,
+                    error_message="OpenAPI client returned None response",
+                )
+
+            request_id = response.request_id or ""
+
+            # Check response type, if it's CallMcpToolResponse, use new parsing method
+            if hasattr(response, 'is_tool_successful'):
+                # This is a CallMcpToolResponse object
+                try:
+                    print("Response body:")
+                    print(json.dumps(response.json_data, ensure_ascii=False, indent=2))
+                except Exception:
+                    print(f"Response: {response}")
+
+                if response.is_tool_successful():
+                    # Tool execution successful
+                    result = response.get_tool_result()
+                    return OperationResult(request_id=request_id, success=True, data=result)
+                else:
+                    # Tool execution failed
+                    error_msg = response.get_error_message() or "Tool execution failed"
+                    return OperationResult(
+                        request_id=request_id,
+                        success=False,
+                        error_message=error_msg,
+                    )
+            else:
+                # This is the original OpenAPI response object, use existing parsing method
+                # Here you can add existing parsing logic if needed
+                error_msg = "Unsupported response type"
+                return OperationResult(
+                    request_id=request_id,
+                    success=False,
+                    error_message=error_msg,
+                )
+
+
+        except AGBError as e:
+            handled_error = self._handle_error(e)
+            request_id = "" if "request_id" not in locals() else request_id
+            return OperationResult(
+                request_id=request_id,
+                success=False,
+                error_message=str(handled_error),
+            )
+        except Exception as e:
+            handled_error = self._handle_error(e)
+            request_id = "" if "request_id" not in locals() else request_id
+            return OperationResult(
+                request_id=request_id,
+                success=False,
+                error_message=f"Failed to call MCP tool {name}: {handled_error}",
+            )

agb/api/client.py

@@ -0,0 +1,257 @@
+# -*- coding: utf-8 -*-
+"""
+AGB API client implementation using HTTP client
+"""
+
+from typing import Dict, Optional, Union, List, Any
+from agb.api.models import (
+    CreateSessionResponse,
+    CallMcpToolResponse,
+    ListMcpToolsResponse,
+    GetMcpResourceResponse,
+    ReleaseSessionResponse,
+    CreateSessionRequest,
+    ReleaseSessionRequest,
+    CallMcpToolRequest,
+    ListMcpToolsRequest,
+    GetMcpResourceRequest,
+    InitBrowserRequest,
+    InitBrowserResponse,
+    GetLinkRequest,
+    GetLinkResponse,
+)
+from .http_client import HTTPClient
+import aiohttp
+
+class Client:
+    """
+    AGB API client that uses HTTP client
+    """
+
+    def __init__(self, config=None):
+        """
+        Initialize the client
+
+        Args:
+            config: Configuration object for HTTP client
+        """
+        self.config = config
+        self._http_client = None
+
+    def _get_http_client(self, api_key: str) -> HTTPClient:
+        """
+        Get HTTP client instance, creating a new one for each request
+
+        Args:
+            api_key: API key for authentication
+
+        Returns:
+            HTTPClient: HTTP client instance
+        """
+        # Always create a new HTTP client for each request
+        return HTTPClient(api_key=api_key, cfg=self.config)
+
+    def create_mcp_session(self, request: CreateSessionRequest) -> CreateSessionResponse:
+        """
+        Create MCP session using HTTP client
+        """
+        # Extract API key from authorization header
+        if not request.authorization:
+            raise ValueError("authorization 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.create_session(request)
+            return response
+        finally:
+            # Always close the HTTP client to release resources
+            http_client.close()
+
+    def release_mcp_session(self, request: ReleaseSessionRequest) -> ReleaseSessionResponse:
+        """
+        Release MCP session using HTTP client
+        """
+        if not request.session_id:
+            raise ValueError("session_id is required")
+
+        if not request.authorization:
+            raise ValueError("authorization 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.release_session(request)
+            return response
+        finally:
+            # Always close the HTTP client to release resources
+            http_client.close()
+
+    def call_mcp_tool(self, request: CallMcpToolRequest, read_timeout: int = None, connect_timeout: int = None) -> CallMcpToolResponse:
+        """
+        Call MCP tool using HTTP client
+        """
+        if not request.authorization:
+            raise ValueError("authorization 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.call_mcp_tool(request, read_timeout=read_timeout, connect_timeout=connect_timeout)
+            return response
+        finally:
+            # Always close the HTTP client to release resources
+            http_client.close()
+
+    def list_mcp_tools(self, request: ListMcpToolsRequest) -> ListMcpToolsResponse:
+        """
+        List MCP tools using HTTP client
+        """
+        if not request.authorization:
+            raise ValueError("authorization 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.list_mcp_tools(request)
+            return response
+        finally:
+            # Always close the HTTP client to release resources
+            http_client.close()
+
+    def get_mcp_resource(self, request: GetMcpResourceRequest) -> GetMcpResourceResponse:
+        """
+        Get MCP resource using HTTP client
+        """
+        if not request.session_id:
+            raise ValueError("session_id is required")
+
+        if not request.authorization:
+            raise ValueError("authorization 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.get_mcp_resource(request)
+            return response
+        finally:
+            # Always close the HTTP client to release resources
+            http_client.close()
+
+    def init_browser(self, request: InitBrowserRequest) -> InitBrowserResponse:
+        """
+        Initialize browser using HTTP client
+        """
+        if not request.authorization:
+            raise ValueError("authorization 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.init_browser(request)
+            return response
+        finally:
+            # Always close the HTTP client to release resources
+            http_client.close()
+
+
+    async def init_browser_async(
+        self,
+        request: InitBrowserRequest,
+    ) -> InitBrowserResponse:
+        """
+        Async version of init_browser using HTTP client
+        """
+        if not request.authorization:
+            raise ValueError("authorization is required")
+
+        # Get HTTP client and make async request
+        http_client = self._get_http_client(request.authorization)
+
+        try:
+            response = await http_client.init_browser_async(request)
+            return response
+        finally:
+            # Always close the HTTP client to release resources
+            http_client.close()
+
+    def close(self):
+        """Close HTTP client and clean up resources"""
+        # No need to manage long-lived HTTP client anymore
+        # Each request creates a new client that gets cleaned up automatically
+        pass
+
+    async def call_api_async_with_requests(url, method="GET", headers=None, params=None, data=None, json=None, timeout=30):
+        """
+        使用 aiohttp 实现异步 HTTP 请求，模拟 requests 的用法。
+        """
+        async with aiohttp.ClientSession() as session:
+            req_method = getattr(session, method.lower())
+            async with req_method(
+                url,
+                headers=headers,
+                params=params,
+                data=data,
+                json=json,
+                timeout=timeout
+            ) as resp:
+                resp_data = await resp.text()
+                # 你可以根据需要返回 resp.json() 或 resp.read()
+                return {
+                    "status_code": resp.status,
+                    "headers": dict(resp.headers),
+                    "body": resp_data
+                }
+
+
+    def get_link(
+        self,
+        request: GetLinkRequest,
+    ) -> GetLinkResponse:
+        """
+        Get session link 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.get_link(request)
+            return response
+        finally:
+            # Always close the HTTP client to release resources
+            http_client.close()
+
+    async def get_link_async(
+        self,
+        request: GetLinkRequest,
+    ) -> GetLinkResponse:
+        """
+        Async version of get_link 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 async request
+        http_client = self._get_http_client(request.authorization)
+
+        try:
+            response = await http_client.get_link_async(request)
+            return response
+        finally:
+            # Always close the HTTP client to release resources
+            http_client.close()