dojo-sdk-core 0.1.0__tar.gz

dojo_sdk_core-0.1.0/.gitignore

@@ -0,0 +1,4 @@
+__pycache__/
+.venv/
+.pytest_cache/
+screenshots/

dojo_sdk_core-0.1.0/PKG-INFO

@@ -0,0 +1,21 @@
+Metadata-Version: 2.4
+Name: dojo-sdk-core
+Version: 0.1.0
+Summary: Core functionality of dojo
+Requires-Python: >=3.9
+Requires-Dist: datasets>=4.1.1
+Requires-Dist: pydantic>=2.11.9
+Requires-Dist: python-dotenv>=1.1.1
+Provides-Extra: dev
+Requires-Dist: black; extra == 'dev'
+Requires-Dist: isort; extra == 'dev'
+Requires-Dist: mypy; extra == 'dev'
+Requires-Dist: pytest-cov; extra == 'dev'
+Requires-Dist: pytest>=7.0.0; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
+Description-Content-Type: text/markdown
+
+## dojo-core
+
+Core functionality of dojo.
+Contains models shared by other parts of the dojo project.

dojo_sdk_core-0.1.0/README.md

@@ -0,0 +1,4 @@
+## dojo-core
+
+Core functionality of dojo.
+Contains models shared by other parts of the dojo project.

dojo_sdk_core-0.1.0/core/__about__.py

@@ -0,0 +1 @@
+__version__ = "0.0.1"

dojo_sdk_core-0.1.0/core/__init__.py

@@ -0,0 +1,46 @@
+from core.__about__ import __version__
+from core.models import EnvironmentConfig, InstructionsConfig, TaskDefinition
+from core.tasks import PyTaskLoader, RemoteTaskLoader
+from core.types import (
+    Action,
+    ActionType,
+    ClickAction,
+    DoneAction,
+    DoubleClickAction,
+    DragAction,
+    FailAction,
+    HotkeyAction,
+    KeyAction,
+    MiddleClickAction,
+    MoveToAction,
+    PressAction,
+    RightClickAction,
+    ScrollAction,
+    TypeAction,
+    WaitAction,
+)
+
+__all__ = [
+    "__version__",
+    "EnvironmentConfig",
+    "InstructionsConfig",
+    "TaskDefinition",
+    "PyTaskLoader",
+    "RemoteTaskLoader",
+    "KeyAction",
+    "ClickAction",
+    "RightClickAction",
+    "ScrollAction",
+    "TypeAction",
+    "DoubleClickAction",
+    "DragAction",
+    "MoveToAction",
+    "PressAction",
+    "HotkeyAction",
+    "MiddleClickAction",
+    "DoneAction",
+    "WaitAction",
+    "FailAction",
+    "Action",
+    "ActionType",
+]

dojo_sdk_core-0.1.0/core/dojos/__init__.py

@@ -0,0 +1,4 @@
+from core.dojos.dojos_loader import collect_tasks, load_dojos
+from core.dojos.model import Dojo
+
+__all__ = ["Dojo", "collect_tasks", "load_dojos"]

dojo_sdk_core-0.1.0/core/dojos/dojos_loader.py

@@ -0,0 +1,25 @@
+from core.dojos.model import Dojo
+
+
+# Add new dojos here
+def load_dojos() -> list[Dojo]:
+    return []
+
+
+def collect_tasks(dojos: list[Dojo]) -> list[str]:
+    return [dojo.get_id() + "/" + task.id for dojo in dojos for task in dojo.get_tasks_list()]
+
+
+# TODO: For now this is just a sanity check to make sure the task name is valid.
+def run_tasks_by_name(task_names: list[str]) -> list[str]:
+    dojos = load_dojos()
+    for task_name in task_names:
+        found = False
+        for dojo in dojos:
+            for task in dojo.get_tasks_list():
+                if dojo.get_id() + "/" + task.id == task_name:
+                    found = True
+                    break
+        if not found:
+            raise ValueError(f"Task {task_name} not found")
+    return task_names

dojo_sdk_core-0.1.0/core/dojos/model.py

@@ -0,0 +1,14 @@
+import string
+from abc import ABC, abstractmethod
+
+from core.models import TaskDefinition
+
+
+class Dojo(ABC):
+    @abstractmethod
+    def get_id(self) -> string:
+        pass
+
+    @abstractmethod
+    def get_tasks_list(self) -> list[TaskDefinition]:
+        pass

dojo_sdk_core-0.1.0/core/dojos/rewards.py

@@ -0,0 +1,131 @@
+"""
+Centralized reward functions for all dojos.
+
+This module contains all reward validation functions used across different dojos.
+Each function takes (initial_state, final_state) and returns (score, reason).
+"""
+
+import logging
+from typing import Any, Dict, Tuple
+
+logger = logging.getLogger(__name__)
+
+
+def _validate_get_2048(initial_state: Dict[str, Any], final_state: Dict[str, Any]) -> Tuple[float, str]:
+    """Validate that a 2048 tile is present on the board."""
+    if "board" not in final_state:
+        return 0.0, "No board in final state"
+
+    logger.debug(f"running reward function on state: {final_state}")
+    if 2048 in final_state["board"]:
+        return 1.0, "A 2048 tile is present."
+    return 0.0, "No 2048 tile is present."
+
+
+def _validate_search_for_dzaka(initial_state: Dict[str, Any], final_state: Dict[str, Any]) -> Tuple[float, str]:
+    """Validate that the user successfully searched for Dzaka Athif."""
+    logger.debug(f"Running reward function on state: {final_state}")
+    
+    # Check 1: currentView is "search"
+    if final_state.get("currentView") != "search":
+        return 0.0, f"Not on search page, current view: {final_state.get('currentView')}"
+    
+    # Check 2: searchQuery contains "dzaka" (case insensitive)
+    query = final_state.get("searchQuery", "").lower()
+    if "dzaka" not in query:
+        return 0.0, f"Search query doesn't contain 'dzaka': {final_state.get('searchQuery')}"
+    
+    # Check 3: Dzaka Athif in search results
+    search_results = final_state.get("searchResults", {})
+    people = search_results.get("allPeople", [])
+    
+    dzaka_found = any(
+        user.get("name") == "Dzaka Athif" 
+        for user in people
+    )
+    
+    if dzaka_found:
+        return 1.0, "Successfully searched for Dzaka Athif"
+    
+    return 0.0, f"Dzaka Athif not found in search results. Found {len(people)} people."
+
+
+def _validate_drag_to_different_column(initial_state: Dict[str, Any], final_state: Dict[str, Any]) -> Tuple[float, str]:
+    """Validate that an issue was moved to a different column."""
+    if "issues" not in final_state:
+        return 0.0, "No issues in final state"
+
+    logger.debug(f"Running reward function on state: {final_state}")
+    
+    # Find the issue we're tracking (VSS-101)
+    target_issue = next(
+        (issue for issue in final_state["issues"] if issue.get("identifier") == "VSS-101"),
+        None
+    )
+    
+    if not target_issue:
+        return 0.0, "Target issue VSS-101 not found in final state"
+    
+    # Check if it moved to in_progress status
+    if target_issue.get("status") == "in_progress" and target_issue.get("assigneeId") == "1":
+        return 1.0, "Issue VSS-101 successfully moved to In Progress column for user 1"
+    
+    return 0.0, f"Issue VSS-101 has status={target_issue.get('status')}, assigneeId={target_issue.get('assigneeId')}, expected status=in_progress, assigneeId=1"
+
+
+def _validate_drag_two_issues_same_user(initial_state: Dict[str, Any], final_state: Dict[str, Any]) -> Tuple[float, str]:
+    """Validate that two issues were moved within the same user's board."""
+    if "issues" not in final_state:
+        return 0.0, "No issues in final state"
+
+    logger.debug(f"Running reward function on state: {final_state}")
+    
+    # Find both target issues
+    issue_101 = next(
+        (issue for issue in final_state["issues"] if issue.get("identifier") == "VSS-101"),
+        None
+    )
+    issue_106 = next(
+        (issue for issue in final_state["issues"] if issue.get("identifier") == "VSS-106"),
+        None
+    )
+    
+    if not issue_101:
+        return 0.0, "Target issue VSS-101 not found in final state"
+    if not issue_106:
+        return 0.0, "Target issue VSS-106 not found in final state"
+    
+    # Check both issues
+    issue_101_correct = (
+        issue_101.get("status") == "in_progress" and 
+        issue_101.get("assigneeId") == "1"
+    )
+    issue_106_correct = (
+        issue_106.get("status") == "queued" and 
+        issue_106.get("assigneeId") == "1"
+    )
+    
+    if issue_101_correct and issue_106_correct:
+        return 1.0, "Both issues successfully moved to target columns for user 1"
+    
+    errors = []
+    if not issue_101_correct:
+        errors.append(f"VSS-101: status={issue_101.get('status')}, assigneeId={issue_101.get('assigneeId')} (expected in_progress, 1)")
+    if not issue_106_correct:
+        errors.append(f"VSS-106: status={issue_106.get('status')}, assigneeId={issue_106.get('assigneeId')} (expected queued, 1)")
+    
+    return 0.0, "; ".join(errors)
+
+
+# Registry of all reward functions for easy lookup
+REWARD_FUNCTIONS = {
+    "_validate_get_2048": _validate_get_2048,
+    "_validate_search_for_dzaka": _validate_search_for_dzaka,
+    "_validate_drag_to_different_column": _validate_drag_to_different_column,
+    "_validate_drag_two_issues_same_user": _validate_drag_two_issues_same_user,
+}
+
+
+def get_reward_function(name: str):
+    """Get a reward function by name."""
+    return REWARD_FUNCTIONS.get(name)

dojo_sdk_core-0.1.0/core/models.py

@@ -0,0 +1,167 @@
+import json
+from pathlib import Path
+from typing import Any, Callable, Optional
+
+from pydantic import BaseModel, Field
+
+
+class SettingsConfig(BaseModel):
+    """Settings configuration."""
+
+    anthropic_api_key: str = Field("", description="Anthropic API key")
+    openai_api_key: str = Field("", description="OpenAI API key")
+    openai_api_url: str = Field("", description="OpenAI API URL")
+    dojo_websocket_endpoint: str = Field("", description="Dojo websocket endpoint")
+    dojo_http_endpoint: str = Field("", description="Dojo http endpoint")
+
+
+class EnvironmentConfig(BaseModel):
+    """Environment configuration."""
+
+    type: str = Field(..., description="Environment type (e.g., 'spa')")
+    path: str = Field(..., description="Path to environment file")
+
+
+class InstructionsConfig(BaseModel):
+    """Task instructions configuration."""
+
+    user_prompt: str = Field(..., description="Prompt to show to the agent")
+    success_criteria: str = Field(..., description="What constitutes success")
+
+
+class TaskDefinition(BaseModel):
+    """Complete task definition."""
+
+    id: str = Field(..., description="Unique task identifier")
+    name: str = Field(..., description="Human-readable task name")
+    description: str = Field(..., description="Task description")
+    environment: EnvironmentConfig = Field(..., description="Environment configuration")
+    initial_state: dict[str, Any] = Field(
+        ..., description="Initial state for the environment"
+    )
+    instructions: InstructionsConfig = Field(..., description="Task instructions")
+    reward_function: Optional[
+        Callable[[dict[str, Any], dict[str, Any]], tuple[float, str]]
+    ] = Field(
+        None,
+        description="Reward function to be used if valid_target_states is not provided",
+    )
+    valid_target_states: Optional[list[dict[str, Any]]] = Field(
+        None,
+        description="List of valid target states for binary reward (1 if reached, 0 otherwise)",
+    )
+    max_steps: int = Field(default=10, description="Maximum number of steps allowed")
+    timeout_seconds: int = Field(default=60, description="Task timeout in seconds")
+    metadata: dict[str, Any] = Field(
+        default_factory=dict, description="Additional metadata"
+    )
+
+    def model_post_init(self, __context: Any) -> None:
+        """Validate that either reward_function or valid_target_states is provided."""
+        if not self.reward_function and not self.valid_target_states:
+            raise ValueError(
+                "Either reward_function or valid_target_states must be provided"
+            )
+        if self.reward_function and self.valid_target_states:
+            raise ValueError(
+                "Cannot specify both reward_function and valid_target_states"
+            )
+
+    def get_environment_path(self, base_path: Optional[Path] = None) -> Path:
+        """Get absolute path to environment file."""
+        if base_path is None:
+            base_path = Path.cwd()
+        return base_path / self.environment.path
+
+    def load_reward_function(
+        self,
+    ) -> Callable[[dict[str, Any], dict[str, Any]], tuple[float, str]]:
+        """Load and return the reward function."""
+        if self.valid_target_states:
+            # Return built-in binary reward function
+            return self._create_binary_reward_function()
+
+        if not self.reward_function:
+            raise ValueError("No reward function or valid_target_states specified")
+
+        return self.reward_function
+
+    def _create_binary_reward_function(
+        self,
+    ) -> Callable[[dict[str, Any], dict[str, Any]], tuple[float, str]]:
+        """Create a binary reward function based on valid_target_states."""
+
+        def binary_reward_function(
+            initial_state: dict[str, Any], final_state: dict[str, Any]
+        ) -> tuple[float, str]:
+            """Binary reward function that checks if final_state matches any valid target state."""
+            if not self.valid_target_states:
+                return 0.0, "No valid target states defined"
+
+            for i, target_state in enumerate(self.valid_target_states):
+                if self._states_match(final_state, target_state):
+                    return 1.0, f"Reached valid target state {i + 1}"
+
+            return 0.0, "Did not reach any valid target state"
+
+        return binary_reward_function
+
+    def _states_match(self, state1: dict[str, Any], state2: dict[str, Any]) -> bool:
+        """Check if two states match by comparing all key-value pairs."""
+        # Check that state1 contains all key-value pairs from state2
+        for key, value in state2.items():
+            if key not in state1:
+                return False
+            if state1[key] != value:
+                return False
+        return True
+
+    @classmethod
+    def from_hf_row(cls, row: dict[str, Any], reward_function_importer: Optional[Callable[[str], Optional[Callable]]] = None) -> "TaskDefinition":
+        """
+        Create a TaskDefinition from a HuggingFace dataset row.
+        
+        This handles the stringified JSON fields and optional reward function importing
+        that's specific to the HF dataset format.
+        
+        Args:
+            row: Dictionary representing a row from the HF dataset
+            reward_function_importer: Optional function to import reward functions by name
+            
+        Returns:
+            TaskDefinition instance
+        """
+        # Parse stringified JSON fields
+        initial_state = json.loads(row["initial_state"])
+        environment = json.loads(row["environment"])
+        instructions = json.loads(row["instructions"])
+        metadata = json.loads(row["metadata"])
+        
+        # Handle valid_target_states (may be empty string)
+        valid_target_states = None
+        if row["valid_target_states"] and row["valid_target_states"].strip():
+            valid_target_states = json.loads(row["valid_target_states"])
+        
+        # Handle reward_function (may be empty string)
+        reward_function = None
+        if row["reward_function"] and row["reward_function"].strip():
+            if reward_function_importer:
+                reward_function = reward_function_importer(row["reward_function"])
+            else:
+                # Store function name as string if no importer provided
+                # This allows the caller to handle importing later
+                pass
+        
+        return cls(
+            id=row["id"],
+            name=row["name"],
+            description=row["description"],
+            environment=environment,
+            initial_state=initial_state,
+            instructions=instructions,
+            reward_function=reward_function,
+            valid_target_states=valid_target_states,
+            max_steps=row["max_steps"],
+            timeout_seconds=row["timeout_seconds"],
+            metadata=metadata
+        )

dojo_sdk_core-0.1.0/core/settings.py

@@ -0,0 +1,47 @@
+import os
+
+from dotenv import load_dotenv
+
+from core.models import SettingsConfig
+
+load_dotenv()
+
+
+_DEFAULT_HTTP_ENDPOINT = "https://orchestrator.trydojo.ai/api/v1"
+
+
+def _resolve_http_endpoint() -> str:
+    """Resolve the HTTP endpoint for the Dojo backend."""
+
+    return os.getenv("DOJO_HTTP_ENDPOINT") or _DEFAULT_HTTP_ENDPOINT
+
+
+def _derive_ws_endpoint(http_endpoint: str) -> str:
+    """Derive a websocket endpoint from the provided HTTP endpoint."""
+
+    if not http_endpoint:
+        return "ws://localhost:8765/api/v1/jobs"
+
+    normalized = http_endpoint.rstrip("/")
+    if normalized.startswith("https://"):
+        normalized = "wss://" + normalized[len("https://") :]
+    elif normalized.startswith("http://"):
+        normalized = "ws://" + normalized[len("http://") :]
+
+    if not normalized.endswith("/jobs"):
+        normalized = f"{normalized}/jobs"
+
+    return normalized
+
+
+_http_endpoint = _resolve_http_endpoint()
+_ws_endpoint = os.getenv("DOJO_WEBSOCKET_ENDPOINT") or _derive_ws_endpoint(_http_endpoint)
+
+settings = SettingsConfig(
+    anthropic_api_key=os.getenv("ANTHROPIC_API_KEY", ""),
+    openai_api_key=os.getenv("OPENAI_API_KEY", ""),
+    openai_api_url=os.getenv("OPENAI_API_URL", ""),
+    # TODO: switch to prod endpoint as default
+    dojo_websocket_endpoint=_ws_endpoint,
+    dojo_http_endpoint=_http_endpoint,
+)

dojo_sdk_core-0.1.0/core/tasks.py

@@ -0,0 +1,123 @@
+"""Task definition and loading system."""
+
+import importlib
+import json
+import string
+from abc import ABC, abstractmethod
+from typing import Any, Callable, List, Optional
+
+from datasets import load_dataset
+
+from core.dojos import Dojo
+from core.dojos.dojos_loader import load_dojos
+from core.dojos.rewards import get_reward_function
+from core.models import TaskDefinition
+
+
+class TaskLoader(ABC):
+    """Abstract base class for task loaders."""
+
+    @abstractmethod
+    def load_task(self, task_path: str) -> TaskDefinition:
+        """Load a task definition from a JSON file."""
+        pass
+
+    @abstractmethod
+    def load_dojo_tasks(self, dojo_name: str) -> List[TaskDefinition]:
+        """Load all tasks from a benchmark directory."""
+        pass
+
+    @abstractmethod
+    def list_tasks(self, category: Optional[str] = None) -> dict[str, TaskDefinition]:
+        """List all available tasks."""
+        pass
+
+
+class PyTaskLoader:
+    """Loads tasks from python-based task registry"""
+
+    @staticmethod
+    def _register_all(bms: list[Dojo]) -> dict[string, Dojo]:
+        result = {}
+        for bm in bms:
+            result[bm.get_id()] = bm
+
+        return result
+
+    def __init__(self):
+        self.benchmarks_by_name = PyTaskLoader._register_all(load_dojos())
+
+    def load_task(self, benchmark_task_path: str) -> TaskDefinition:
+        split_path = benchmark_task_path.split("/")
+        benchmark_name = split_path[0]
+        task_id = split_path[1]
+        tasks = self.load_benchmark_tasks(benchmark_name)
+        for task in tasks:
+            if task.id == task_id:
+                return task
+        raise ValueError(f"Task {task_id} not found in benchmark {benchmark_name}")
+
+    def load_benchmark_tasks(self, benchmark_name: str) -> List[TaskDefinition]:
+        return self.benchmarks_by_name[benchmark_name].get_tasks_list()
+
+    def list_tasks(self, category: Optional[str] = None) -> dict[str, TaskDefinition]:
+        raise NotImplementedError("List tasks not implemented")
+
+
+class RemoteTaskLoader:
+    """Loads tasks from a Hugging Face dataset."""
+
+    def __init__(self, dataset_name: str):
+        self.dataset_name = dataset_name
+        self.dataset = None
+        self.tasks_cache = None
+
+    def _load_dataset(self):
+        """Lazy load the HF dataset."""
+        if self.dataset is None:
+            self.dataset = load_dataset(self.dataset_name)["train"]
+            print(f"✓ Loaded {len(self.dataset)} tasks from HF dataset {self.dataset_name}")
+        return self.dataset
+
+    def _import_reward_function(self, function_name: str) -> Optional[Callable[[dict[str, Any], dict[str, Any]], tuple[float, str]]]:
+        """Import a reward function by name from the centralized rewards module."""
+        if not function_name or function_name == "":
+            return None
+            
+        return get_reward_function(function_name)
+
+    def _get_all_tasks(self) -> List[TaskDefinition]:
+        """Load all tasks from HF dataset and convert to TaskDefinition objects."""
+        if self.tasks_cache is None:
+            dataset = self._load_dataset()
+            tasks = []
+            
+            for row in dataset:
+                # Use the clean constructor that handles HF-specific parsing
+                task = TaskDefinition.from_hf_row(row, reward_function_importer=self._import_reward_function)
+                tasks.append(task)
+            
+            self.tasks_cache = tasks
+            print(f"✓ Converted {len(tasks)} HF tasks to TaskDefinition objects")
+        
+        return self.tasks_cache
+
+    def load_task(self, task_path: str) -> TaskDefinition:
+        """Load a specific task by dojo/task_id path."""
+        # Parse task_path like "action-tester/must-click"
+        if "/" not in task_path:
+            raise ValueError(f"Invalid task path format: {task_path}. Expected 'dojo/task_id'")
+        
+        dojo_name, task_id = task_path.split("/", 1)
+        
+        all_tasks = self._get_all_tasks()
+        
+        # Find task by task_id (dojo info is embedded in the task path, not metadata)
+        for task in all_tasks:
+            if task.id == task_id:
+                return task
+        
+        raise ValueError(f"Task {task_id} not found in dojo {dojo_name}")
+
+    def list_tasks(self, category: Optional[str] = None) -> dict[str, TaskDefinition]:
+        raise NotImplementedError("List tasks not implemented")

dojo_sdk_core-0.1.0/core/types.py

@@ -0,0 +1,131 @@
+from enum import Enum
+from typing import List, Literal, Union
+
+from pydantic import BaseModel
+
+"""Type definitions for Dojo."""
+
+
+class ActionType(str, Enum):
+    KEY = "key"
+    CLICK = "click"
+    RIGHT_CLICK = "right_click"
+    SCROLL = "scroll"
+    TYPE = "type"
+    DOUBLE_CLICK = "double_click"
+    DRAG = "drag"
+    MOVE_TO = "move_to"
+    PRESS = "press"
+    HOTKEY = "hotkey"
+    MIDDLE_CLICK = "middle_click"
+    DONE = "done"
+    WAIT = "wait"
+    FAIL = "fail"
+
+
+class KeyAction(BaseModel):
+    type: Literal[ActionType.KEY]
+    key: str
+
+
+class ClickAction(BaseModel):
+    type: Literal[ActionType.CLICK]
+    x: int
+    y: int
+
+
+class RightClickAction(BaseModel):
+    type: Literal[ActionType.RIGHT_CLICK]
+    x: int
+    y: int
+
+
+class ScrollAction(BaseModel):
+    type: Literal[ActionType.SCROLL]
+    direction: str = "up"
+    amount: int = 100
+
+
+class TypeAction(BaseModel):
+    type: Literal[ActionType.TYPE]
+    text: str
+
+
+class DoubleClickAction(BaseModel):
+    type: Literal[ActionType.DOUBLE_CLICK]
+    x: int
+    y: int
+
+
+class DragAction(BaseModel):
+    type: Literal[ActionType.DRAG]
+    from_x: int
+    from_y: int
+    to_x: int
+    to_y: int
+    duration: float = 1.0
+
+
+class MoveToAction(BaseModel):
+    type: Literal[ActionType.MOVE_TO]
+    x: int
+    y: int
+    duration: float = 0.0
+
+
+class PressAction(BaseModel):
+    type: Literal[ActionType.PRESS]
+    key: str
+
+
+class HotkeyAction(BaseModel):
+    type: Literal[ActionType.HOTKEY]
+    keys: List[str]
+
+
+class MiddleClickAction(BaseModel):
+    type: Literal[ActionType.MIDDLE_CLICK]
+    x: int
+    y: int
+
+
+class DoneAction(BaseModel):
+    type: Literal[ActionType.DONE]
+
+
+class WaitAction(BaseModel):
+    type: Literal[ActionType.WAIT]
+    seconds: int = 1
+
+
+class FailAction(BaseModel):
+    type: Literal[ActionType.FAIL]
+    message: str
+
+
+Action = Union[
+    KeyAction,
+    ClickAction,
+    RightClickAction,
+    ScrollAction,
+    TypeAction,
+    DoubleClickAction,
+    DragAction,
+    MoveToAction,
+    PressAction,
+    HotkeyAction,
+    MiddleClickAction,
+    DoneAction,
+    WaitAction,
+    FailAction,
+]
+
+
+class Score(BaseModel):
+    task_name: str
+    score: float
+    status: str
+    success: bool
+    steps_taken: int
+    reward: float
+    completion_reason: str

dojo_sdk_core-0.1.0/core/ws_types.py

@@ -0,0 +1,134 @@
+from datetime import datetime
+from enum import Enum
+from typing import List, Literal, Optional, Union
+
+from pydantic import BaseModel
+
+from core.types import Action
+
+
+class ExecutionTrace(BaseModel):
+    task_name: str
+    status: str
+    success: bool
+    steps_taken: int
+    reward: float
+    completion_reason: str
+    history: List[dict]
+    final_state: dict
+    final_screenshot: str
+
+
+# WebSocket API Message Types
+class TaskStatus(str, Enum):
+    RUNNING = "RUNNING"
+    COMPLETED = "COMPLETED"
+    FAILED = "FAILED"
+    PENDING = "PENDING"
+    TIMEOUT = "TIMEOUT"
+
+
+class JobStatus(str, Enum):
+    RUNNING = "RUNNING"
+    COMPLETED = "COMPLETED"
+    FAILED = "FAILED"
+    PENDING = "PENDING"
+
+
+class MsgType(str, Enum):
+    START_JOB = "StartJobRequest"
+    START_JOB_RESP = "StartJobResponse"
+    SUBMIT_ACTION = "SubmitActionRequest"
+    GET_NEXT_ACTION = "GetNextActionRequest"
+    TASK_COMPLETE = "TaskComplete"
+    JOB_STATUS_RESP = "JobStatusResponse"
+    JOB_COMPLETE = "JobComplete"
+    AUTH = "Auth"
+    AUTH_RESP = "AuthResp"
+    CANCEL_JOB = "CancelJobRequest"
+
+
+class HistoryStep(BaseModel):
+    step: int
+    after_screenshot: str
+    agent_response: str
+    raw_response: str
+    action: Action
+    score: float
+
+
+class NextStep(BaseModel):
+    number: int
+    after_screenshot: str
+
+
+class TaskResult(BaseModel):
+    status: TaskStatus
+    start_time: datetime
+    end_time: datetime
+    exec_id: str
+    task_id: str
+    task_name: str
+    job_id: str
+    final_score: float
+    reason: str
+    history: List[HistoryStep]
+    recording: Optional[str] = None
+
+
+class JobComplete(BaseModel):
+    type: Literal[MsgType.JOB_COMPLETE]
+    job_id: str
+    tasks: List[TaskResult]
+
+
+# Stateless API Types
+
+
+class PendingTask(BaseModel):
+    start_time: datetime
+    task_name: str
+    id: str
+    exec_id: str
+    prompt: str
+    status: TaskStatus
+    history: List[HistoryStep]
+    pending_step: Optional[NextStep] = None
+
+
+class FinishedTask(BaseModel):
+    status: TaskStatus
+    start_time: datetime
+    end_time: datetime
+    task_name: str
+    id: str
+    exec_id: str
+    prompt: str
+    history: List[HistoryStep]
+    score: float
+    recording: Optional[str] = None
+
+
+class JobStatusResponse(BaseModel):
+    status: JobStatus
+    start_time: datetime
+    end_time: datetime | None
+    pending_tasks: List[PendingTask]
+    finished_tasks: List[FinishedTask]
+
+
+class JobMetadata(BaseModel):
+    id: str
+    status: JobStatus
+    start_time: datetime
+    end_time: datetime | None
+    num_tasks: int
+    num_completed_tasks: int
+
+
+class JobsResponse(BaseModel):
+    jobs: List[JobMetadata]
+
+
+# Union type for all WebSocket messages
+WebSocketMessage = Union[JobComplete,]

dojo_sdk_core-0.1.0/pyproject.toml

@@ -0,0 +1,38 @@
+[project]
+name = "dojo-sdk-core"
+version = "0.1.0"
+description = "Core functionality of dojo"
+readme = "README.md"
+requires-python = ">=3.9"
+dependencies = ["pydantic>=2.11.9", "python-dotenv>=1.1.1", "datasets>=4.1.1"]
+
+[project.optional-dependencies]
+dev = ["pytest>=7.0.0", "pytest-cov", "black", "isort", "mypy", "ruff"]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.sdist]
+include = ["/src", "/README.md"]
+
+[tool.isort]
+profile = "black"
+src_paths = ["src", "tests"]
+
+[tool.ruff]
+line-length = 128
+target-version = "py311"
+
+[tool.ruff.lint]
+select = ["E", "F", "W", "B", "I"]
+
+[tool.ruff.format]
+quote-style = "double"
+indent-style = "space"
+
+[tool.hatch.build]
+sources = ["src"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/core"]