oagi 0.1.0__py3-none-any.whl → 0.2.1__py3-none-any.whl

oagi/__init__.py

@@ -6,8 +6,48 @@
 #  Licensed under the MIT License.
 # -----------------------------------------------------------------------------
 
+from oagi.exceptions import (
+    APIError,
+    AuthenticationError,
+    ConfigurationError,
+    NetworkError,
+    NotFoundError,
+    OAGIError,
+    RateLimitError,
+    RequestTimeoutError,
+    ServerError,
+    ValidationError,
+)
 from oagi.pyautogui_action_handler import PyautoguiActionHandler
 from oagi.screenshot_maker import ScreenshotMaker
 from oagi.short_task import ShortTask
+from oagi.single_step import single_step
+from oagi.sync_client import ErrorDetail, ErrorResponse, LLMResponse, SyncClient
+from oagi.task import Task
 
-__all__ = ["ShortTask", "PyautoguiActionHandler", "ScreenshotMaker"]
+__all__ = [
+    # Core classes
+    "Task",
+    "ShortTask",
+    "SyncClient",
+    # Functions
+    "single_step",
+    # Handler classes
+    "PyautoguiActionHandler",
+    "ScreenshotMaker",
+    # Response models
+    "LLMResponse",
+    "ErrorResponse",
+    "ErrorDetail",
+    # Exceptions
+    "OAGIError",
+    "APIError",
+    "AuthenticationError",
+    "ConfigurationError",
+    "NetworkError",
+    "NotFoundError",
+    "RateLimitError",
+    "ServerError",
+    "RequestTimeoutError",
+    "ValidationError",
+]

oagi/exceptions.py

@@ -0,0 +1,75 @@
+# -----------------------------------------------------------------------------
+#  Copyright (c) OpenAGI Foundation
+#  All rights reserved.
+#
+#  This file is part of the official API project.
+#  Licensed under the MIT License.
+# -----------------------------------------------------------------------------
+
+import httpx
+
+
+class OAGIError(Exception):
+    pass
+
+
+class APIError(OAGIError):
+    def __init__(
+        self,
+        message: str,
+        code: str | None = None,
+        status_code: int | None = None,
+        response: httpx.Response | None = None,
+    ):
+        """Initialize APIError.
+
+        Args:
+            message: Human-readable error message
+            code: API error code for programmatic handling
+            status_code: HTTP status code
+            response: Original HTTP response object
+        """
+        super().__init__(message)
+        self.message = message
+        self.code = code
+        self.status_code = status_code
+        self.response = response
+
+    def __str__(self) -> str:
+        if self.code:
+            return f"API Error [{self.code}]: {self.message}"
+        return f"API Error: {self.message}"
+
+
+class AuthenticationError(APIError):
+    pass
+
+
+class RateLimitError(APIError):
+    pass
+
+
+class ValidationError(APIError):
+    pass
+
+
+class NotFoundError(APIError):
+    pass
+
+
+class ServerError(APIError):
+    pass
+
+
+class NetworkError(OAGIError):
+    def __init__(self, message: str, original_error: Exception | None = None):
+        super().__init__(message)
+        self.original_error = original_error
+
+
+class RequestTimeoutError(NetworkError):
+    pass
+
+
+class ConfigurationError(OAGIError):
+    pass

oagi/short_task.py

@@ -7,92 +7,14 @@
 # -----------------------------------------------------------------------------
 
 from .logging import get_logger
-from .sync_client import SyncClient, encode_screenshot_from_bytes
-from .types import ActionHandler, Image, ImageProvider, Step
+from .task import Task
+from .types import ActionHandler, ImageProvider
 
 logger = get_logger("short_task")
 
 
-class ShortTask:
-    def __init__(self, api_key: str | None = None, base_url: str | None = None):
-        self.client = SyncClient(base_url=base_url, api_key=api_key)
-        self.api_key = self.client.api_key
-        self.base_url = self.client.base_url
-        self.task_id: str | None = None
-        self.task_description: str | None = None
-        self.model = "vision-model-v1"  # default model
-
-    def init_task(self, task_desc: str, max_steps: int = 5):
-        """Initialize a new task with the given description."""
-        self.task_description = task_desc
-        response = self.client.create_message(
-            model=self.model,
-            screenshot="",
-            task_description=self.task_description,
-            task_id=None,
-        )
-        self.task_id = response.task_id  # Reset task_id for new task
-        logger.info(f"Task initialized: '{task_desc}' (max_steps: {max_steps})")
-
-    def step(self, screenshot: Image) -> Step:
-        """Send screenshot to the server and get the next actions."""
-        if not self.task_description:
-            raise ValueError("Task description must be set. Call init_task() first.")
-
-        logger.debug(f"Executing step for task: '{self.task_description}'")
-
-        try:
-            # Convert Image to bytes using the protocol
-            screenshot_bytes = screenshot.read()
-            screenshot_b64 = encode_screenshot_from_bytes(screenshot_bytes)
-
-            # Call API
-            response = self.client.create_message(
-                model=self.model,
-                screenshot=screenshot_b64,
-                task_description=self.task_description,
-                task_id=self.task_id,
-            )
-
-            # Update task_id from response
-            if self.task_id != response.task_id:
-                if self.task_id is None:
-                    logger.debug(f"Task ID assigned: {response.task_id}")
-                else:
-                    logger.debug(
-                        f"Task ID changed: {self.task_id} -> {response.task_id}"
-                    )
-                self.task_id = response.task_id
-
-            # Convert API response to Step
-            result = Step(
-                reason=response.reason,
-                actions=response.actions,
-                stop=response.is_complete,
-            )
-
-            if response.is_complete:
-                logger.info(f"Task completed after {response.current_step} steps")
-            else:
-                logger.debug(
-                    f"Step {response.current_step} completed with {len(response.actions)} actions"
-                )
-
-            return result
-
-        except Exception as e:
-            logger.error(f"Error during step execution: {e}")
-            raise
-
-    def close(self):
-        """Close the underlying HTTP client to free resources."""
-        self.client.close()
-
-    def __enter__(self):
-        return self
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        self.close()
+class ShortTask(Task):
+    """Task implementation with automatic mode for short-duration tasks."""
 
     def auto_mode(
         self,

oagi/single_step.py

@@ -0,0 +1,82 @@
+# -----------------------------------------------------------------------------
+#  Copyright (c) OpenAGI Foundation
+#  All rights reserved.
+#
+#  This file is part of the official API project.
+#  Licensed under the MIT License.
+# -----------------------------------------------------------------------------
+
+from pathlib import Path
+
+from .task import Task
+from .types import Image, Step
+
+
+def single_step(
+    task_description: str,
+    screenshot: str | bytes | Path | Image,
+    instruction: str | None = None,
+    api_key: str | None = None,
+    base_url: str | None = None,
+) -> Step:
+    """
+    Perform a single-step inference without maintaining task state.
+
+    This is useful for one-off analyses where you don't need to maintain
+    a conversation or task context across multiple steps.
+
+    Args:
+        task_description: Description of the task to perform
+        screenshot: Screenshot as Image, bytes, or file path
+        instruction: Optional additional instruction for the task
+        api_key: OAGI API key (uses environment variable if not provided)
+        base_url: OAGI base URL (uses environment variable if not provided)
+
+    Returns:
+        Step: Object containing reasoning, actions, and completion status
+
+    Example:
+        >>> # Using with bytes
+        >>> with open("screenshot.png", "rb") as f:
+        ...     image_bytes = f.read()
+        >>> step = single_step(
+        ...     task_description="Click the submit button",
+        ...     screenshot=image_bytes
+        ... )
+
+        >>> # Using with file path
+        >>> step = single_step(
+        ...     task_description="Fill in the form",
+        ...     screenshot=Path("screenshot.png"),
+        ...     instruction="Use test@example.com for email"
+        ... )
+
+        >>> # Using with Image object
+        >>> from oagi.types import Image
+        >>> image = Image(...)
+        >>> step = single_step(
+        ...     task_description="Navigate to settings",
+        ...     screenshot=image
+        ... )
+    """
+    # Convert file paths to bytes
+    if isinstance(screenshot, (str, Path)):
+        path = Path(screenshot) if isinstance(screenshot, str) else screenshot
+        if path.exists():
+            with open(path, "rb") as f:
+                screenshot_bytes = f.read()
+        else:
+            raise FileNotFoundError(f"Screenshot file not found: {path}")
+    elif isinstance(screenshot, bytes):
+        screenshot_bytes = screenshot
+    elif isinstance(screenshot, Image):
+        screenshot_bytes = screenshot.read()
+    else:
+        raise ValueError(
+            f"screenshot must be Image, bytes, str, or Path, got {type(screenshot)}"
+        )
+
+    # Use Task to perform single step
+    with Task(api_key=api_key, base_url=base_url) as task:
+        task.init_task(task_description)
+        return task.step(screenshot_bytes, instruction=instruction)

oagi/sync_client.py

@@ -8,11 +8,23 @@
 
 import base64
 import os
-from typing import Optional
+from functools import wraps
 
 import httpx
+from httpx import Response
 from pydantic import BaseModel
 
+from .exceptions import (
+    APIError,
+    AuthenticationError,
+    ConfigurationError,
+    NetworkError,
+    NotFoundError,
+    RateLimitError,
+    RequestTimeoutError,
+    ServerError,
+    ValidationError,
+)
 from .logging import get_logger
 from .types import Action
 
@@ -25,6 +37,19 @@ class Usage(BaseModel):
     total_tokens: int
 
 
+class ErrorDetail(BaseModel):
+    """Detailed error information."""
+
+    code: str
+    message: str
+
+
+class ErrorResponse(BaseModel):
+    """Standard error response format."""
+
+    error: ErrorDetail | None
+
+
 class LLMResponse(BaseModel):
     id: str
     task_id: str
@@ -37,29 +62,45 @@ class LLMResponse(BaseModel):
     actions: list[Action]
     reason: str | None = None
     usage: Usage
+    error: ErrorDetail | None = None
 
 
-class ErrorResponse(BaseModel):
-    error: str
-    message: str
-    code: int
+def _log_trace_id(response: Response):
+    logger.error(f"Request Id: {response.headers.get('x-request-id', '')}")
+    logger.error(f"Trace Id: {response.headers.get('x-trace-id', '')}")
+
+
+def log_trace_on_failure(func):
+    """Decorator that logs trace ID when a method fails."""
+
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        try:
+            return func(*args, **kwargs)
+        except Exception as e:
+            # Try to get response from the exception if it has one
+            if (response := getattr(e, "response", None)) is not None:
+                _log_trace_id(response)
+            raise
+
+    return wrapper
 
 
 class SyncClient:
-    def __init__(self, base_url: Optional[str] = None, api_key: Optional[str] = None):
+    def __init__(self, base_url: str | None = None, api_key: str | None = None):
         # Get from environment if not provided
         self.base_url = base_url or os.getenv("OAGI_BASE_URL")
         self.api_key = api_key or os.getenv("OAGI_API_KEY")
 
         # Validate required configuration
         if not self.base_url:
-            raise ValueError(
+            raise ConfigurationError(
                 "OAGI base URL must be provided either as 'base_url' parameter or "
                 "OAGI_BASE_URL environment variable"
             )
 
         if not self.api_key:
-            raise ValueError(
+            raise ConfigurationError(
                 "OAGI API key must be provided either as 'api_key' parameter or "
                 "OAGI_API_KEY environment variable"
             )
@@ -80,14 +121,16 @@ class SyncClient:
         """Close the underlying httpx client"""
         self.client.close()
 
+    @log_trace_on_failure
     def create_message(
         self,
         model: str,
         screenshot: str,  # base64 encoded
-        task_description: Optional[str] = None,
-        task_id: Optional[str] = None,
-        max_actions: Optional[int] = 5,
-        api_version: Optional[str] = None,
+        task_description: str | None = None,
+        task_id: str | None = None,
+        instruction: str | None = None,
+        max_actions: int | None = 5,
+        api_version: str | None = None,
     ) -> LLMResponse:
         """
         Call the /v1/message endpoint to analyze task and screenshot
@@ -97,6 +140,7 @@ class SyncClient:
             screenshot: Base64-encoded screenshot image
             task_description: Description of the task (required for new sessions)
             task_id: Task ID for continuing existing task
+            instruction: Additional instruction when continuing a session (only works with task_id)
             max_actions: Maximum number of actions to return (1-20)
             api_version: API version header
 
@@ -118,6 +162,8 @@ class SyncClient:
             payload["task_description"] = task_description
         if task_id is not None:
             payload["task_id"] = task_id
+        if instruction is not None:
+            payload["instruction"] = instruction
         if max_actions is not None:
             payload["max_actions"] = max_actions
 
@@ -126,32 +172,92 @@ class SyncClient:
             f"Request includes task_description: {task_description is not None}, task_id: {task_id is not None}"
         )
 
-        response = self.client.post(
-            "/v1/message", json=payload, headers=headers, timeout=self.timeout
-        )
+        try:
+            response = self.client.post(
+                "/v1/message", json=payload, headers=headers, timeout=self.timeout
+            )
+        except httpx.TimeoutException as e:
+            logger.error(f"Request timed out after {self.timeout} seconds")
+            raise RequestTimeoutError(
+                f"Request timed out after {self.timeout} seconds", e
+            )
+        except httpx.NetworkError as e:
+            logger.error(f"Network error: {e}")
+            raise NetworkError(f"Network error: {e}", e)
 
-        if response.status_code == 200:
-            result = LLMResponse(**response.json())
-            logger.info(
-                f"API request successful - task_id: {result.task_id}, step: {result.current_step}, complete: {result.is_complete}"
+        try:
+            response_data = response.json()
+        except ValueError:
+            # If response is not JSON, raise API error
+            logger.error(f"Non-JSON API response: {response.status_code}")
+            raise APIError(
+                f"Invalid response format (status {response.status_code})",
+                status_code=response.status_code,
+                response=response,
             )
-            logger.debug(f"Response included {len(result.actions)} actions")
-            return result
-        else:
-            # Handle error responses
-            try:
-                error_data = response.json()
-                error = ErrorResponse(**error_data)
-                logger.error(f"API Error {error.code}: {error.error} - {error.message}")
-                raise httpx.HTTPStatusError(
-                    f"API Error {error.code}: {error.error} - {error.message}",
-                    request=response.request,
+
+        # Check if it's an error response (non-200 status or has error field)
+        if response.status_code != 200:
+            error_resp = ErrorResponse(**response_data)
+            if error_resp.error:
+                error_code = error_resp.error.code
+                error_msg = error_resp.error.message
+                logger.error(f"API Error [{error_code}]: {error_msg}")
+
+                # Map to specific exception types based on status code
+                exception_class = self._get_exception_class(response.status_code)
+                raise exception_class(
+                    error_msg,
+                    code=error_code,
+                    status_code=response.status_code,
+                    response=response,
+                )
+            else:
+                # Error response without error details
+                logger.error(
+                    f"API error response without details: {response.status_code}"
+                )
+                exception_class = self._get_exception_class(response.status_code)
+                raise exception_class(
+                    f"API error (status {response.status_code})",
+                    status_code=response.status_code,
                     response=response,
                 )
-            except ValueError:
-                # If response is not JSON, raise generic error
-                logger.error(f"Non-JSON API error response: {response.status_code}")
-                response.raise_for_status()
+
+        # Parse successful response
+        result = LLMResponse(**response_data)
+
+        # Check if the response contains an error (even with 200 status)
+        if result.error:
+            logger.error(
+                f"API Error in response: [{result.error.code}]: {result.error.message}"
+            )
+            raise APIError(
+                result.error.message,
+                code=result.error.code,
+                status_code=200,
+                response=response,
+            )
+
+        logger.info(
+            f"API request successful - task_id: {result.task_id}, step: {result.current_step}, complete: {result.is_complete}"
+        )
+        logger.debug(f"Response included {len(result.actions)} actions")
+        return result
+
+    def _get_exception_class(self, status_code: int) -> type[APIError]:
+        """Get the appropriate exception class based on status code."""
+        status_map = {
+            401: AuthenticationError,
+            404: NotFoundError,
+            422: ValidationError,
+            429: RateLimitError,
+        }
+
+        if status_code >= 500:
+            return ServerError
+
+        return status_map.get(status_code, APIError)
 
     def health_check(self) -> dict:
         """

oagi/task.py

@@ -0,0 +1,109 @@
+# -----------------------------------------------------------------------------
+#  Copyright (c) OpenAGI Foundation
+#  All rights reserved.
+#
+#  This file is part of the official API project.
+#  Licensed under the MIT License.
+# -----------------------------------------------------------------------------
+
+from .logging import get_logger
+from .sync_client import SyncClient, encode_screenshot_from_bytes
+from .types import Image, Step
+
+logger = get_logger("task")
+
+
+class Task:
+    """Base class for task automation with the OAGI API."""
+
+    def __init__(self, api_key: str | None = None, base_url: str | None = None):
+        self.client = SyncClient(base_url=base_url, api_key=api_key)
+        self.api_key = self.client.api_key
+        self.base_url = self.client.base_url
+        self.task_id: str | None = None
+        self.task_description: str | None = None
+        self.model = "vision-model-v1"  # default model
+
+    def init_task(self, task_desc: str, max_steps: int = 5):
+        """Initialize a new task with the given description."""
+        self.task_description = task_desc
+        response = self.client.create_message(
+            model=self.model,
+            screenshot="",
+            task_description=self.task_description,
+            task_id=None,
+        )
+        self.task_id = response.task_id  # Reset task_id for new task
+        logger.info(f"Task initialized: '{task_desc}' (max_steps: {max_steps})")
+
+    def step(self, screenshot: Image | bytes, instruction: str | None = None) -> Step:
+        """Send screenshot to the server and get the next actions.
+
+        Args:
+            screenshot: Screenshot as Image object or raw bytes
+            instruction: Optional additional instruction for this step (only works with existing task_id)
+
+        Returns:
+            Step: The actions and reasoning for this step
+        """
+        if not self.task_description:
+            raise ValueError("Task description must be set. Call init_task() first.")
+
+        logger.debug(f"Executing step for task: '{self.task_description}'")
+
+        try:
+            # Convert Image to bytes using the protocol
+            if isinstance(screenshot, Image):
+                screenshot_bytes = screenshot.read()
+            else:
+                screenshot_bytes = screenshot
+            screenshot_b64 = encode_screenshot_from_bytes(screenshot_bytes)
+
+            # Call API
+            response = self.client.create_message(
+                model=self.model,
+                screenshot=screenshot_b64,
+                task_description=self.task_description,
+                task_id=self.task_id,
+                instruction=instruction,
+            )
+
+            # Update task_id from response
+            if self.task_id != response.task_id:
+                if self.task_id is None:
+                    logger.debug(f"Task ID assigned: {response.task_id}")
+                else:
+                    logger.debug(
+                        f"Task ID changed: {self.task_id} -> {response.task_id}"
+                    )
+                self.task_id = response.task_id
+
+            # Convert API response to Step
+            result = Step(
+                reason=response.reason,
+                actions=response.actions,
+                stop=response.is_complete,
+            )
+
+            if response.is_complete:
+                logger.info(f"Task completed after {response.current_step} steps")
+            else:
+                logger.debug(
+                    f"Step {response.current_step} completed with {len(response.actions)} actions"
+                )
+
+            return result
+
+        except Exception as e:
+            logger.error(f"Error during step execution: {e}")
+            raise
+
+    def close(self):
+        """Close the underlying HTTP client to free resources."""
+        self.client.close()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.close()

oagi/types/image.py

@@ -6,9 +6,10 @@
 #  Licensed under the MIT License.
 # -----------------------------------------------------------------------------
 
-from typing import Protocol
+from typing import Protocol, runtime_checkable
 
 
+@runtime_checkable
 class Image(Protocol):
     """Protocol for image objects that can be read as bytes."""
 

{oagi-0.1.0.dist-info → oagi-0.2.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: oagi
-Version: 0.1.0
+Version: 0.2.1
 Summary: Official API of OpenAGI Foundation
 Project-URL: Homepage, https://github.com/agiopen-org/oagi
 Author-email: OpenAGI Foundation <contact@agiopen.org>
@@ -33,3 +33,23 @@ Requires-Dist: pydantic>=2.0.0
 Description-Content-Type: text/markdown
 
 # OAGI Python SDK
+
+## Basic Usage
+```bash
+pip install oagi # python >= 3.10
+```
+```bash
+export OAGI_BASE_URL=""
+export OAGI_API_KEY="sk-xxxx"
+```
+
+```python
+from oagi import PyautoguiActionHandler, ScreenshotMaker, ShortTask
+short_task = ShortTask()
+is_completed = short_task.auto_mode(
+    "Search weather with Google",
+    max_steps=5,
+    executor=PyautoguiActionHandler(),
+    image_provider=(sm := ScreenshotMaker()),
+)
+```

{oagi-0.1.0.dist-info → oagi-0.2.1.dist-info}/RECORD

@@ -1,17 +1,20 @@
-oagi/__init__.py,sha256=Qk4_6TmIBIGQhFSDPbt06h-WCpW_nqZ9PYBeXu-1XDA,531
+oagi/__init__.py,sha256=ms9ahLdHNrMWtiqX93q8Iv55ag__tO4Id0DQ3hA2TVM,1347
+oagi/exceptions.py,sha256=VMwVS8ouE9nHhBpN3AZMYt5_U2kGcihWaTnBhoQLquo,1662
 oagi/logging.py,sha256=CWe89mA5MKTipIvfrqSYkv2CAFNBSwHMDQMDkG_g64g,1350
 oagi/pyautogui_action_handler.py,sha256=LBWmtqkXzZSJo07s3uOw-NWUE9rZZtbNAx0YI83pCbk,5482
 oagi/screenshot_maker.py,sha256=lyJSMFagHeaqg59CQGMTqLvSzQN_pBbhbV2oIFG46vA,2077
-oagi/short_task.py,sha256=cDmMjQ-rv04FH6AVHLAasgCeVKWfeteaeuJp6LZNq2s,4479
-oagi/sync_client.py,sha256=nH68my12ujxMusV4PkSl0gDiW-vFMvUKf_jSeC4Seks,5907
+oagi/short_task.py,sha256=ofcMi7vbu9W1MCSGOk_FNEHJcB02pfgNcx1-Y8UkpJY,1552
+oagi/single_step.py,sha256=JEsF7ABa4wwW5Pi5AfjeKzyuKhC4kC4fcotnmnNye5o,2874
+oagi/sync_client.py,sha256=E6EgFIe-H91rdsPhF1puwrBTpOnKaL6JA1WHR4R-CLY,9395
+oagi/task.py,sha256=NmpNMu8CJll50zGsGtVie1kdpKeWnAAWudEa-aasBbU,3959
 oagi/types/__init__.py,sha256=eh-1IEqMTY2hUrvQJeTg6vsvlE6F4Iz5C0_K86AnWn8,549
 oagi/types/action_handler.py,sha256=NH8E-m5qpGqWcXzTSWfF7W0Xdp8SkzJsbhCmQ0B96cg,1075
-oagi/types/image.py,sha256=1vmQaOgNJuNso3WtiPN-sAP2DGjMDHwogrB0Pgi9uQ8,499
+oagi/types/image.py,sha256=KgPCCTJ6D5vHIaGZdbTE7eQEa1WlT6G9tf59ZuUCV2U,537
 oagi/types/image_provider.py,sha256=oYFdOYznrK_VOR9egzOjw5wFM5w8EY2sY01pH0ANAgU,1112
 oagi/types/models/__init__.py,sha256=4qhKxWXsXEVzD6U_RM6PXR45os765qigtZs1BsS4WHg,414
 oagi/types/models/action.py,sha256=8Xd3IcH32ENq7uXczo-mbQ736yUOGxO_TaZTfHVRY7w,935
 oagi/types/models/step.py,sha256=RSI4H_2rrUBq_xyCoWKaq7JHdJWNobtQppaKC1l0aWU,471
-oagi-0.1.0.dist-info/METADATA,sha256=vVl2-HqzJKJsScHkslj4zZ7ZAjKaPw3LtB9eakqssQ8,1656
-oagi-0.1.0.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
-oagi-0.1.0.dist-info/licenses/LICENSE,sha256=sy5DLA2M29jFT4UfWsuBF9BAr3FnRkYtnAu6oDZiIf8,1075
-oagi-0.1.0.dist-info/RECORD,,
+oagi-0.2.1.dist-info/METADATA,sha256=5W_aB_J2LUEyKAvE6G_iOcySv7tf0PWiGikOQe_K7l4,2066
+oagi-0.2.1.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
+oagi-0.2.1.dist-info/licenses/LICENSE,sha256=sy5DLA2M29jFT4UfWsuBF9BAr3FnRkYtnAu6oDZiIf8,1075
+oagi-0.2.1.dist-info/RECORD,,