runloop_api_client 1.5.1__py3-none-any.whl

runloop_api_client/types/repository_connection_view.py

@@ -0,0 +1,18 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from .._models import BaseModel
+
+__all__ = ["RepositoryConnectionView"]
+
+
+class RepositoryConnectionView(BaseModel):
+    """The ID of the Repository."""
+
+    id: str
+    """The ID of the Repository."""
+
+    name: str
+    """The name of the Repository."""
+
+    owner: str
+    """The account owner of the Repository."""

runloop_api_client/types/repository_create_params.py

@@ -0,0 +1,22 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Optional
+from typing_extensions import Required, TypedDict
+
+__all__ = ["RepositoryCreateParams"]
+
+
+class RepositoryCreateParams(TypedDict, total=False):
+    name: Required[str]
+    """Name of the repository."""
+
+    owner: Required[str]
+    """Account owner of the repository."""
+
+    blueprint_id: Optional[str]
+    """ID of blueprint to use as base for resulting RepositoryVersion blueprint."""
+
+    github_auth_token: Optional[str]
+    """GitHub authentication token for accessing private repositories."""

runloop_api_client/types/repository_inspect_params.py

@@ -0,0 +1,13 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Optional
+from typing_extensions import TypedDict
+
+__all__ = ["RepositoryInspectParams"]
+
+
+class RepositoryInspectParams(TypedDict, total=False):
+    github_auth_token: Optional[str]
+    """GitHub authentication token for accessing private repositories."""

runloop_api_client/types/repository_inspection_details.py

@@ -0,0 +1,83 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Dict, List, Optional
+from typing_extensions import Literal
+
+from .._models import BaseModel
+from .repository_manifest_view import RepositoryManifestView
+
+__all__ = ["RepositoryInspectionDetails", "WorkflowContexts", "WorkflowContextsActionsContext"]
+
+
+class WorkflowContextsActionsContext(BaseModel):
+    """Details about actions processing for this workflow."""
+
+    actions_skipped_unnecessary: List[str]
+    """
+    Actions that were skipped because they were unnecessary (e.g., upload
+    artifacts).
+    """
+
+    actions_taken: List[str]
+    """Actions that were translated into commands and executed."""
+
+    actions_unknown: List[str]
+    """
+    Actions that were not understood and skipped because we did not know what to do.
+    """
+
+
+class WorkflowContexts(BaseModel):
+    """
+    Workflow context containing file name and details about actions processing during inspection.
+    """
+
+    actions_context: WorkflowContextsActionsContext
+    """Details about actions processing for this workflow."""
+
+    file_name: str
+    """The file name of the workflow."""
+
+
+class RepositoryInspectionDetails(BaseModel):
+    id: str
+    """The ID of the inspection."""
+
+    commit_sha: str
+    """The sha of the inspected version of the Repository."""
+
+    inspected_at: int
+    """Inspection time of the Repository Version (Unix timestamp milliseconds)."""
+
+    repository_manifest: RepositoryManifestView
+    """Repository manifest containing container config and workspace details."""
+
+    status: Literal[
+        "invalid",
+        "repo_auth_pending",
+        "repo_authentication_failure",
+        "repo_access_failure",
+        "inspection_pending",
+        "inspection_failed",
+        "inspection_success",
+        "inspection_user_manifest_added",
+    ]
+    """The status of the repository inspection."""
+
+    blueprint_id: Optional[str] = None
+    """The blueprint ID associated with this inspection if successful."""
+
+    blueprint_name: Optional[str] = None
+    """The blueprint name associated with this inspection if successful."""
+
+    build_status: Optional[Literal["image_building", "image_build_success", "image_build_failure"]] = None
+    """The status of the linked Blueprint build."""
+
+    user_manifest: Optional[RepositoryManifestView] = None
+    """
+    User uploaded repository manifest containing container config and workspace
+    details.
+    """
+
+    workflow_contexts: Optional[Dict[str, WorkflowContexts]] = None
+    """Workflow contexts mapping workflow names to their processing details."""

runloop_api_client/types/repository_inspection_list_view.py

@@ -0,0 +1,13 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List
+
+from .._models import BaseModel
+from .repository_inspection_details import RepositoryInspectionDetails
+
+__all__ = ["RepositoryInspectionListView"]
+
+
+class RepositoryInspectionListView(BaseModel):
+    inspections: List[RepositoryInspectionDetails]
+    """List of inspections for this repository."""

runloop_api_client/types/repository_list_params.py

@@ -0,0 +1,21 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import TypedDict
+
+__all__ = ["RepositoryListParams"]
+
+
+class RepositoryListParams(TypedDict, total=False):
+    limit: int
+    """The limit of items to return. Default is 20. Max is 5000."""
+
+    name: str
+    """Filter by repository name"""
+
+    owner: str
+    """Filter by repository owner"""
+
+    starting_after: str
+    """Load the next page of data starting after the item with the given ID."""

runloop_api_client/types/repository_manifest_view.py

@@ -0,0 +1,174 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Dict, List, Optional
+from typing_extensions import Literal
+
+from .._models import BaseModel
+
+__all__ = [
+    "RepositoryManifestView",
+    "ContainerConfig",
+    "Language",
+    "Workspace",
+    "WorkspaceDevCommands",
+    "ContainerizedService",
+    "ContainerizedServiceCredentials",
+]
+
+
+class ContainerConfig(BaseModel):
+    """Container configuration specifying the base image and setup commands."""
+
+    base_image_name: str
+    """The name of the base image.
+
+    Should be one of the GitHub public images like ubuntu-latest, ubuntu-24.04,
+    ubuntu-22.04, windows-latest, windows-2022, macos-latest etc.
+    """
+
+    architecture: Optional[Literal["x86_64", "arm64"]] = None
+    """The target architecture for the Repository Container."""
+
+    setup_commands: Optional[List[str]] = None
+    """
+    Commands to run to setup the base container such as installing necessary
+    toolchains (e.g. apt install).
+    """
+
+
+class Language(BaseModel):
+    language: Optional[str] = None
+
+    version: Optional[str] = None
+
+
+class WorkspaceDevCommands(BaseModel):
+    """
+    Extracted common commands important to the developer life cycle like linting, testing, building, etc.
+    """
+
+    build: Optional[List[str]] = None
+    """Build command (e.g. npm run build)."""
+
+    install: Optional[List[str]] = None
+    """Installation command (e.g. pip install -r requirements.txt)."""
+
+    lint: Optional[List[str]] = None
+    """Lint command (e.g. flake8)."""
+
+    scripts: Optional[List[str]] = None
+    """Script commands."""
+
+    test: Optional[List[str]] = None
+    """Test command (e.g. pytest)."""
+
+
+class Workspace(BaseModel):
+    """
+    A workspace is a buildable unit of code within a repository and often represents a deployable unit of code like a backend service or a frontend app.
+    """
+
+    build_tool: List[str]
+    """Name of the build tool used (e.g. pip, npm)."""
+
+    dev_commands: Optional[WorkspaceDevCommands] = None
+    """
+    Extracted common commands important to the developer life cycle like linting,
+    testing, building, etc.
+    """
+
+    name: Optional[str] = None
+    """Name of the workspace.
+
+    Can be empty if the workspace is the root of the repository. Only necessary for
+    monorepo style repositories.
+    """
+
+    path: Optional[str] = None
+    """Path to the workspace from the root of the repository.
+
+    Can be empty if the workspace is the root of the repository. Only necessary for
+    monorepo style repositories.
+    """
+
+    workspace_refresh_commands: Optional[List[str]] = None
+    """
+    Commands to run to refresh this workspace after pulling the latest changes to
+    the repository via git (e.g. npm install).
+    """
+
+    workspace_setup_commands: Optional[List[str]] = None
+    """
+    Commands to run to setup this workspace after a fresh clone of the repository on
+    a new container such as installing necessary toolchains and dependencies (e.g.
+    npm install).
+    """
+
+
+class ContainerizedServiceCredentials(BaseModel):
+    """The credentials of the container service."""
+
+    password: str
+    """The password of the container service."""
+
+    username: str
+    """The username of the container service."""
+
+
+class ContainerizedService(BaseModel):
+    image: str
+    """The image of the container service."""
+
+    name: str
+    """The name of the container service."""
+
+    credentials: Optional[ContainerizedServiceCredentials] = None
+    """The credentials of the container service."""
+
+    env: Optional[Dict[str, str]] = None
+    """The environment variables of the container service."""
+
+    options: Optional[str] = None
+    """Additional Docker container create options."""
+
+    port_mappings: Optional[List[str]] = None
+    """The port mappings of the container service.
+
+    Port mappings are in the format of <host_port>:<container_port>.
+    """
+
+
+class RepositoryManifestView(BaseModel):
+    """
+    The repository manifest contains container configuration and workspace definitions for a repository.
+    """
+
+    container_config: ContainerConfig
+    """Container configuration specifying the base image and setup commands."""
+
+    languages: List[Language]
+    """List of required languages found in Repository."""
+
+    workspaces: List[Workspace]
+    """List of workspaces within the repository.
+
+    Each workspace represents a buildable unit of code.
+    """
+
+    containerized_services: Optional[List[ContainerizedService]] = None
+    """List of discovered ContainerizedServices.
+
+    Services can be explicitly started when creating a Devbox.
+    """
+
+    env_vars: Optional[Dict[str, str]] = None
+    """
+    Qualified environment variables and values that should be set for this
+    repository to run correctly.
+    """
+
+    required_env_vars: Optional[List[str]] = None
+    """
+    Missing environment variables that (may) be required for this repository to run
+    correctly.
+    """

runloop_api_client/types/repository_refresh_params.py

@@ -0,0 +1,16 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Optional
+from typing_extensions import TypedDict
+
+__all__ = ["RepositoryRefreshParams"]
+
+
+class RepositoryRefreshParams(TypedDict, total=False):
+    blueprint_id: Optional[str]
+    """ID of blueprint to use as base for resulting RepositoryVersion blueprint."""
+
+    github_auth_token: Optional[str]
+    """GitHub authentication token for accessing private repositories."""

runloop_api_client/types/scenario_create_params.py

@@ -0,0 +1,53 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Dict, Optional
+from typing_extensions import Literal, Required, TypedDict
+
+from .._types import SequenceNotStr
+from .input_context_param import InputContextParam
+from .scoring_contract_param import ScoringContractParam
+from .scenario_environment_param import ScenarioEnvironmentParam
+
+__all__ = ["ScenarioCreateParams"]
+
+
+class ScenarioCreateParams(TypedDict, total=False):
+    input_context: Required[InputContextParam]
+    """The input context for the Scenario."""
+
+    name: Required[str]
+    """Name of the scenario."""
+
+    scoring_contract: Required[ScoringContractParam]
+    """The scoring contract for the Scenario."""
+
+    environment_parameters: Optional[ScenarioEnvironmentParam]
+    """The Environment in which the Scenario will run."""
+
+    metadata: Optional[Dict[str, str]]
+    """User defined metadata to attach to the scenario for organization."""
+
+    reference_output: Optional[str]
+    """A string representation of the reference output to solve the scenario.
+
+    Commonly can be the result of a git diff or a sequence of command actions to
+    apply to the environment.
+    """
+
+    required_environment_variables: Optional[SequenceNotStr[str]]
+    """Environment variables required to run the scenario.
+
+    If these variables are not provided, the scenario will fail to start.
+    """
+
+    required_secret_names: Optional[SequenceNotStr[str]]
+    """
+    Secrets required to run the scenario (user secret name to scenario required
+    secret name). If these secrets are not provided or the mapping is incorrect, the
+    scenario will fail to start.
+    """
+
+    validation_type: Optional[Literal["UNSPECIFIED", "FORWARD", "REVERSE", "EVALUATION"]]
+    """Validation strategy."""

runloop_api_client/types/scenario_definition_list_view.py

@@ -0,0 +1,19 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List
+
+from .._models import BaseModel
+from .scenario_view import ScenarioView
+
+__all__ = ["ScenarioDefinitionListView"]
+
+
+class ScenarioDefinitionListView(BaseModel):
+    has_more: bool
+
+    remaining_count: int
+
+    scenarios: List[ScenarioView]
+    """List of Scenarios matching filter."""
+
+    total_count: int

runloop_api_client/types/scenario_environment.py

@@ -0,0 +1,29 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+
+from .._models import BaseModel
+from .shared.launch_parameters import LaunchParameters
+
+__all__ = ["ScenarioEnvironment"]
+
+
+class ScenarioEnvironment(BaseModel):
+    """
+    ScenarioEnvironmentParameters specify the environment in which a Scenario will be run.
+    """
+
+    blueprint_id: Optional[str] = None
+    """Use the blueprint with matching ID."""
+
+    launch_parameters: Optional[LaunchParameters] = None
+    """Optional launch parameters to apply to the devbox environment at launch."""
+
+    snapshot_id: Optional[str] = None
+    """Use the snapshot with matching ID."""
+
+    working_directory: Optional[str] = None
+    """The working directory where the agent is expected to fulfill the scenario.
+
+    Scoring functions also run from the working directory.
+    """

runloop_api_client/types/scenario_environment_param.py

@@ -0,0 +1,31 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Optional
+from typing_extensions import TypedDict
+
+from .shared_params.launch_parameters import LaunchParameters
+
+__all__ = ["ScenarioEnvironmentParam"]
+
+
+class ScenarioEnvironmentParam(TypedDict, total=False):
+    """
+    ScenarioEnvironmentParameters specify the environment in which a Scenario will be run.
+    """
+
+    blueprint_id: Optional[str]
+    """Use the blueprint with matching ID."""
+
+    launch_parameters: Optional[LaunchParameters]
+    """Optional launch parameters to apply to the devbox environment at launch."""
+
+    snapshot_id: Optional[str]
+    """Use the snapshot with matching ID."""
+
+    working_directory: Optional[str]
+    """The working directory where the agent is expected to fulfill the scenario.
+
+    Scoring functions also run from the working directory.
+    """

runloop_api_client/types/scenario_list_params.py

@@ -0,0 +1,24 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import TypedDict
+
+__all__ = ["ScenarioListParams"]
+
+
+class ScenarioListParams(TypedDict, total=False):
+    benchmark_id: str
+    """Filter scenarios by benchmark ID."""
+
+    limit: int
+    """The limit of items to return. Default is 20. Max is 5000."""
+
+    name: str
+    """Query for Scenarios with a given name."""
+
+    starting_after: str
+    """Load the next page of data starting after the item with the given ID."""
+
+    validation_type: str
+    """Filter by validation type"""

runloop_api_client/types/scenario_list_public_params.py

@@ -0,0 +1,18 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import TypedDict
+
+__all__ = ["ScenarioListPublicParams"]
+
+
+class ScenarioListPublicParams(TypedDict, total=False):
+    limit: int
+    """The limit of items to return. Default is 20. Max is 5000."""
+
+    name: str
+    """Query for Scenarios with a given name."""
+
+    starting_after: str
+    """Load the next page of data starting after the item with the given ID."""

runloop_api_client/types/scenario_run_list_view.py

@@ -0,0 +1,19 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List
+
+from .._models import BaseModel
+from .scenario_run_view import ScenarioRunView
+
+__all__ = ["ScenarioRunListView"]
+
+
+class ScenarioRunListView(BaseModel):
+    has_more: bool
+
+    remaining_count: int
+
+    runs: List[ScenarioRunView]
+    """List of ScenarioRuns matching filter."""
+
+    total_count: int

runloop_api_client/types/scenario_run_view.py

@@ -0,0 +1,55 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Dict, Optional
+from typing_extensions import Literal
+
+from .._models import BaseModel
+from .scoring_contract_result_view import ScoringContractResultView
+
+__all__ = ["ScenarioRunView"]
+
+
+class ScenarioRunView(BaseModel):
+    """A ScenarioRunView represents a single run of a Scenario on a Devbox.
+
+    When completed, the ScenarioRun will contain the final score and output of the run.
+    """
+
+    id: str
+    """ID of the ScenarioRun."""
+
+    devbox_id: str
+    """ID of the Devbox on which the Scenario is running."""
+
+    metadata: Dict[str, str]
+    """User defined metadata to attach to the scenario run for organization."""
+
+    scenario_id: str
+    """ID of the Scenario that has been run."""
+
+    state: Literal["running", "scoring", "scored", "completed", "canceled", "timeout", "failed"]
+    """The state of the ScenarioRun."""
+
+    benchmark_run_id: Optional[str] = None
+    """ID of the BenchmarkRun that this Scenario is associated with, if any."""
+
+    duration_ms: Optional[int] = None
+    """Duration scenario took to run."""
+
+    environment_variables: Optional[Dict[str, str]] = None
+    """Environment variables used to run the scenario."""
+
+    name: Optional[str] = None
+    """Optional name of ScenarioRun."""
+
+    purpose: Optional[str] = None
+    """Purpose of the ScenarioRun."""
+
+    scoring_contract_result: Optional[ScoringContractResultView] = None
+    """The scoring result of the ScenarioRun."""
+
+    secrets_provided: Optional[Dict[str, str]] = None
+    """User secrets used to run the scenario."""
+
+    start_time_ms: Optional[int] = None
+    """The time that the scenario started"""

runloop_api_client/types/scenario_start_run_params.py

@@ -0,0 +1,30 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Dict, Optional
+from typing_extensions import Required, Annotated, TypedDict
+
+from .._utils import PropertyInfo
+from .shared_params.run_profile import RunProfile
+
+__all__ = ["ScenarioStartRunParams"]
+
+
+class ScenarioStartRunBaseParams(TypedDict, total=False):
+    benchmark_run_id: Optional[str]
+    """Benchmark to associate the run."""
+
+    metadata: Optional[Dict[str, str]]
+    """User defined metadata to attach to the run for organization."""
+
+    run_name: Optional[str]
+    """Display name of the run."""
+
+    run_profile: Annotated[Optional[RunProfile], PropertyInfo(alias="runProfile")]
+    """Runtime configuration to use for this benchmark run"""
+
+
+class ScenarioStartRunParams(ScenarioStartRunBaseParams):
+    scenario_id: Required[str]
+    """ID of the Scenario to run."""