plato-sandbox-sdk 1.1.1

package/dist/api/types/CreateSandboxResponse.d.ts

@@ -0,0 +1,13 @@
+export interface CreateSandboxResponse {
+    /** Public URL for the sandbox */
+    url?: string;
+    /** Public ID of the sandbox job */
+    job_public_id: string;
+    /** Job group ID for the sandbox */
+    job_group_id: string;
+    /** Current status of the sandbox */
+    status?: string;
+    /** Correlation ID for monitoring operation progress via SSE */
+    correlation_id?: string;
+}
+//# sourceMappingURL=CreateSandboxResponse.d.ts.map

package/dist/api/types/CreateSnapshotResponse.d.ts

@@ -0,0 +1,9 @@
+export interface CreateSnapshotResponse {
+    artifact_id: string;
+    status: string;
+    timestamp: string;
+    correlation_id: string;
+    s3_uri: string;
+    git_hash?: string;
+}
+//# sourceMappingURL=CreateSnapshotResponse.d.ts.map

package/dist/api/types/DeleteSandboxResponse.d.ts

@@ -0,0 +1,5 @@
+export interface DeleteSandboxResponse {
+    success?: boolean;
+    message?: string;
+}
+//# sourceMappingURL=DeleteSandboxResponse.d.ts.map

package/dist/api/types/Environment.d.ts

@@ -0,0 +1,6 @@
+export interface Environment {
+    job_id: string;
+    alias?: string;
+    status?: string;
+}
+//# sourceMappingURL=Environment.d.ts.map

package/dist/api/types/EnvironmentStateResponse.d.ts

@@ -0,0 +1,9 @@
+export interface EnvironmentStateResponse {
+    data?: EnvironmentStateResponse.Data;
+}
+export declare namespace EnvironmentStateResponse {
+    interface Data {
+        state?: Record<string, unknown>;
+    }
+}
+//# sourceMappingURL=EnvironmentStateResponse.d.ts.map

package/dist/api/types/ErrorResponse.d.ts

@@ -0,0 +1,5 @@
+export interface ErrorResponse {
+    error?: string;
+    message?: string;
+}
+//# sourceMappingURL=ErrorResponse.d.ts.map

package/dist/api/types/EvaluateResponse.d.ts

@@ -0,0 +1,18 @@
+export interface EvaluateResponse {
+    score?: EvaluateResponse.Score;
+}
+export declare namespace EvaluateResponse {
+    interface Score {
+        result?: Score.Result;
+    }
+    namespace Score {
+        interface Result {
+            correct?: boolean;
+            reason?: string;
+            diffs?: Record<string, unknown>[];
+            expected_mutations?: Record<string, unknown>[];
+            mutations?: Record<string, unknown>[];
+        }
+    }
+}
+//# sourceMappingURL=EvaluateResponse.d.ts.map

package/dist/api/types/EvaluationResult.d.ts

@@ -0,0 +1,8 @@
+export interface EvaluationResult {
+    success: boolean;
+    reason?: string;
+    diffs?: Record<string, unknown>[];
+    expected_mutations?: Record<string, unknown>[];
+    actual_mutations?: Record<string, unknown>[];
+}
+//# sourceMappingURL=EvaluationResult.d.ts.map

package/dist/api/types/HeartbeatResponse.d.ts

@@ -0,0 +1,5 @@
+export interface HeartbeatResponse {
+    success?: boolean;
+    timestamp?: string;
+}
+//# sourceMappingURL=HeartbeatResponse.d.ts.map

package/dist/api/types/JobStatusResponse.d.ts

@@ -0,0 +1,6 @@
+export interface JobStatusResponse {
+    status: string;
+    job_id?: string;
+    job_group_id?: string;
+}
+//# sourceMappingURL=JobStatusResponse.d.ts.map

package/dist/api/types/LogResponse.d.ts

@@ -0,0 +1,4 @@
+export interface LogResponse {
+    success?: boolean;
+}
+//# sourceMappingURL=LogResponse.d.ts.map

package/dist/api/types/MakeEnvironmentResponse.d.ts

@@ -0,0 +1,5 @@
+export interface MakeEnvironmentResponse {
+    job_id: string;
+    alias?: string;
+}
+//# sourceMappingURL=MakeEnvironmentResponse.d.ts.map

package/dist/api/types/OperationEvent.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Server-sent event for operation monitoring. The SSE data field contains base64-encoded JSON of this object.
+ *
+ * **Event Types:**
+ * - `connected`: Initial connection event, no action needed, continue listening
+ * - `progress`: Progress update with human-readable message
+ * - `run_result`: Sandbox setup/creation completed (check `success` field)
+ * - `ssh_result`: SSH setup operation completed (check `success` field)
+ * - `error`: Operation failed (check `error` or `message` field)
+ *
+ * **Terminal Events:**
+ * `run_result`, `ssh_result`, and `error` are terminal events that indicate the operation has finished.
+ * Close the stream after receiving one of these.
+ *
+ * **Success Detection:**
+ * An operation is successful if you receive `run_result` or `ssh_result` with `success: true`.
+ * An operation failed if you receive an `error` event or a result event with `success: false`.
+ */
+export interface OperationEvent {
+    /** Type of operation event */
+    type: OperationEvent.Type;
+    /** Whether the operation was successful (only present in result events) */
+    success?: boolean;
+    /** Error message if operation failed */
+    error?: string;
+    /** Human-readable progress or status message */
+    message?: string;
+}
+export declare namespace OperationEvent {
+    /** Type of operation event */
+    const Type: {
+        readonly Connected: "connected";
+        readonly RunResult: "run_result";
+        readonly SshResult: "ssh_result";
+        readonly Error: "error";
+        readonly Progress: "progress";
+    };
+    type Type = (typeof Type)[keyof typeof Type];
+}
+//# sourceMappingURL=OperationEvent.d.ts.map

package/dist/api/types/PlatoConfig.d.ts

@@ -0,0 +1,6 @@
+import type * as Api from "../index.js";
+export interface PlatoConfig {
+    service?: string;
+    datasets?: Record<string, Api.SimConfigDataset>;
+}
+//# sourceMappingURL=PlatoConfig.d.ts.map

package/dist/api/types/PlatoTask.d.ts

@@ -0,0 +1,19 @@
+import type * as Api from "../index.js";
+export interface PlatoTask {
+    public_id: string;
+    name: string;
+    prompt: string;
+    env_id: string;
+    start_url: string;
+    dataset_name?: string;
+    average_time?: number;
+    average_steps?: number;
+    num_validator_human_scores?: number;
+    default_scoring_config?: Record<string, unknown>;
+    scoring_type?: Api.ScoringType[];
+    output_schema?: Record<string, unknown>;
+    is_sample?: boolean;
+    simulator_artifact_id?: string;
+    metadata?: Api.PlatoTaskMetadata;
+}
+//# sourceMappingURL=PlatoTask.d.ts.map

package/dist/api/types/PlatoTaskMetadata.d.ts

@@ -0,0 +1,18 @@
+export interface PlatoTaskMetadata {
+    reasoning_level?: PlatoTaskMetadata.ReasoningLevel;
+    skills?: string[];
+    capabilities?: string[];
+    tags?: string[];
+    rejected?: boolean;
+}
+export declare namespace PlatoTaskMetadata {
+    const ReasoningLevel: {
+        readonly Level1: "level_1";
+        readonly Level2: "level_2";
+        readonly Level3: "level_3";
+        readonly Level4: "level_4";
+        readonly Level5: "level_5";
+    };
+    type ReasoningLevel = (typeof ReasoningLevel)[keyof typeof ReasoningLevel];
+}
+//# sourceMappingURL=PlatoTaskMetadata.d.ts.map

package/dist/api/types/PostEvaluationResultResponse.d.ts

@@ -0,0 +1,5 @@
+export interface PostEvaluationResultResponse {
+    success?: boolean;
+    message?: string;
+}
+//# sourceMappingURL=PostEvaluationResultResponse.d.ts.map

package/dist/api/types/ProxyUrlResponse.d.ts

@@ -0,0 +1,10 @@
+export interface ProxyUrlResponse {
+    data?: ProxyUrlResponse.Data;
+    error?: string;
+}
+export declare namespace ProxyUrlResponse {
+    interface Data {
+        proxy_url?: string;
+    }
+}
+//# sourceMappingURL=ProxyUrlResponse.d.ts.map

package/dist/api/types/ResetEnvironmentResponse.d.ts

@@ -0,0 +1,11 @@
+export interface ResetEnvironmentResponse {
+    success: boolean;
+    error?: string;
+    data?: ResetEnvironmentResponse.Data;
+}
+export declare namespace ResetEnvironmentResponse {
+    interface Data {
+        run_session_id?: string;
+    }
+}
+//# sourceMappingURL=ResetEnvironmentResponse.d.ts.map

package/dist/api/types/RunningSessionsCountResponse.d.ts

@@ -0,0 +1,5 @@
+export interface RunningSessionsCountResponse {
+    organization_id?: string;
+    running_sessions_count?: number;
+}
+//# sourceMappingURL=RunningSessionsCountResponse.d.ts.map

package/dist/api/types/Sandbox.d.ts

@@ -0,0 +1,9 @@
+export interface Sandbox {
+    job_id: string;
+    public_id: string;
+    job_group_id: string;
+    url?: string;
+    status?: string;
+    correlation_id?: string;
+}
+//# sourceMappingURL=Sandbox.d.ts.map

package/dist/api/types/ScoringType.d.ts

@@ -0,0 +1,6 @@
+export declare const ScoringType: {
+    readonly Output: "output";
+    readonly Mutations: "mutations";
+};
+export type ScoringType = (typeof ScoringType)[keyof typeof ScoringType];
+//# sourceMappingURL=ScoringType.d.ts.map

package/dist/api/types/SetupRootAccessResponse.d.ts

@@ -0,0 +1,6 @@
+export interface SetupRootAccessResponse {
+    success?: boolean;
+    /** Correlation ID for monitoring setup progress via SSE */
+    correlation_id?: string;
+}
+//# sourceMappingURL=SetupRootAccessResponse.d.ts.map

package/dist/api/types/SetupSandboxResponse.d.ts

@@ -0,0 +1,5 @@
+export interface SetupSandboxResponse {
+    /** Correlation ID for monitoring setup progress via SSE */
+    correlation_id: string;
+}
+//# sourceMappingURL=SetupSandboxResponse.d.ts.map

package/dist/api/types/SimConfigCompute.d.ts

@@ -0,0 +1,8 @@
+export interface SimConfigCompute {
+    cpus: number;
+    memory: number;
+    disk: number;
+    app_port: number;
+    plato_messaging_port: number;
+}
+//# sourceMappingURL=SimConfigCompute.d.ts.map

package/dist/api/types/SimConfigDataset.d.ts

@@ -0,0 +1,8 @@
+import type * as Api from "../index.js";
+export interface SimConfigDataset {
+    compute: Api.SimConfigCompute;
+    metadata: Api.SimConfigMetadata;
+    services?: Record<string, Api.SimConfigService>;
+    listeners?: Record<string, Api.SimConfigListener>;
+}
+//# sourceMappingURL=SimConfigDataset.d.ts.map

package/dist/api/types/SimConfigListener.d.ts

@@ -0,0 +1,25 @@
+export interface SimConfigListener {
+    type: SimConfigListener.Type;
+    db_type?: string;
+    db_host?: string;
+    db_port?: number;
+    db_user?: string;
+    db_password?: string;
+    db_database?: string;
+    target_dir?: string;
+    watch_enabled?: boolean;
+    watch_patterns?: string[];
+    ignore_patterns?: string[];
+    seed_data_path?: string;
+    seed_data_paths?: string[];
+    volumes?: string[];
+}
+export declare namespace SimConfigListener {
+    const Type: {
+        readonly Db: "db";
+        readonly File: "file";
+        readonly Proxy: "proxy";
+    };
+    type Type = (typeof Type)[keyof typeof Type];
+}
+//# sourceMappingURL=SimConfigListener.d.ts.map

package/dist/api/types/SimConfigMetadata.d.ts

@@ -0,0 +1,12 @@
+import type * as Api from "../index.js";
+export interface SimConfigMetadata {
+    favicon?: string;
+    name: string;
+    description?: string;
+    source_code_url?: string;
+    start_url?: string;
+    license?: string;
+    variables?: Api.Variable[];
+    flows_path?: string;
+}
+//# sourceMappingURL=SimConfigMetadata.d.ts.map

package/dist/api/types/SimConfigService.d.ts

@@ -0,0 +1,7 @@
+export interface SimConfigService {
+    type: string;
+    file?: string;
+    required_healthy_containers?: string[];
+    healthy_wait_timeout?: number;
+}
+//# sourceMappingURL=SimConfigService.d.ts.map

package/dist/api/types/Simulator.d.ts

@@ -0,0 +1,9 @@
+export interface Simulator {
+    id?: number;
+    name: string;
+    description?: string;
+    enabled: boolean;
+    sim_type?: string;
+    config?: Record<string, unknown>;
+}
+//# sourceMappingURL=Simulator.d.ts.map

package/dist/api/types/SimulatorListItem.d.ts

@@ -0,0 +1,6 @@
+export interface SimulatorListItem {
+    name: string;
+    description?: string;
+    artifact_id?: string;
+}
+//# sourceMappingURL=SimulatorListItem.d.ts.map

package/dist/api/types/SshInfo.d.ts

@@ -0,0 +1,17 @@
+export interface SshInfo {
+    /** Complete SSH command to connect */
+    ssh_command: string;
+    /** SSH host identifier */
+    ssh_host: string;
+    /** Path to SSH config file */
+    ssh_config_path: string;
+    /** Sandbox public ID */
+    public_id: string;
+    /** Generated SSH public key */
+    public_key?: string;
+    /** Path to private key file */
+    private_key_path?: string;
+    /** Correlation ID for monitoring SSH setup */
+    correlation_id?: string;
+}
+//# sourceMappingURL=SshInfo.d.ts.map

package/dist/api/types/StartWorkerResponse.d.ts

@@ -0,0 +1,6 @@
+export interface StartWorkerResponse {
+    status: string;
+    timestamp: string;
+    correlation_id: string;
+}
+//# sourceMappingURL=StartWorkerResponse.d.ts.map

package/dist/api/types/TaskMetadata.d.ts

@@ -0,0 +1,18 @@
+export interface TaskMetadata {
+    reasoningLevel?: TaskMetadata.ReasoningLevel;
+    skills?: string[];
+    capabilities?: string[];
+    tags?: string[];
+    rejected?: boolean;
+}
+export declare namespace TaskMetadata {
+    const ReasoningLevel: {
+        readonly Level1: "level_1";
+        readonly Level2: "level_2";
+        readonly Level3: "level_3";
+        readonly Level4: "level_4";
+        readonly Level5: "level_5";
+    };
+    type ReasoningLevel = (typeof ReasoningLevel)[keyof typeof ReasoningLevel];
+}
+//# sourceMappingURL=TaskMetadata.d.ts.map

package/dist/api/types/TestCase.d.ts

@@ -0,0 +1,34 @@
+import type * as Api from "../index.js";
+export interface TestCase {
+    publicId: string;
+    name: string;
+    prompt: string;
+    startUrl: string;
+    simulator: TestCase.Simulator;
+    averageTimeTaken?: number;
+    averageStepsTaken?: number;
+    defaultScoringConfig?: TestCase.DefaultScoringConfig;
+    scoringTypes?: TestCase.ScoringTypes.Item[];
+    outputSchema?: Record<string, unknown>;
+    isSample?: boolean;
+    simulatorArtifactId?: string;
+    metadataConfig?: Api.TaskMetadata;
+}
+export declare namespace TestCase {
+    interface Simulator {
+        name?: string;
+        id?: number;
+    }
+    interface DefaultScoringConfig {
+        num_sessions_used?: number;
+    }
+    type ScoringTypes = ScoringTypes.Item[];
+    namespace ScoringTypes {
+        const Item: {
+            readonly Output: "output";
+            readonly Mutations: "mutations";
+        };
+        type Item = (typeof Item)[keyof typeof Item];
+    }
+}
+//# sourceMappingURL=TestCase.d.ts.map

package/dist/api/types/TestCasesResponse.d.ts

@@ -0,0 +1,8 @@
+import type * as Api from "../index.js";
+export interface TestCasesResponse {
+    testcases: Api.TestCase[];
+    total?: number;
+    page?: number;
+    page_size?: number;
+}
+//# sourceMappingURL=TestCasesResponse.d.ts.map

package/dist/api/types/Variable.d.ts

@@ -0,0 +1,5 @@
+export interface Variable {
+    name: string;
+    value: string;
+}
+//# sourceMappingURL=Variable.d.ts.map

package/dist/api/types/WorkerReadyResponse.d.ts

@@ -0,0 +1,8 @@
+export interface WorkerReadyResponse {
+    ready: boolean;
+    worker_ip?: string;
+    worker_port?: number;
+    health_status?: Record<string, unknown>;
+    error?: string;
+}
+//# sourceMappingURL=WorkerReadyResponse.d.ts.map

package/dist/api/types/index.d.ts

@@ -0,0 +1,43 @@
+export * from "./ActiveSessionResponse.js";
+export * from "./BackupEnvironmentResponse.js";
+export * from "./CdpUrlResponse.js";
+export * from "./CloseEnvironmentResponse.js";
+export * from "./CreateSandboxResponse.js";
+export * from "./CreateSnapshotResponse.js";
+export * from "./DeleteSandboxResponse.js";
+export * from "./Environment.js";
+export * from "./EnvironmentStateResponse.js";
+export * from "./ErrorResponse.js";
+export * from "./EvaluateResponse.js";
+export * from "./EvaluationResult.js";
+export * from "./HeartbeatResponse.js";
+export * from "./JobStatusResponse.js";
+export * from "./LogResponse.js";
+export * from "./MakeEnvironmentResponse.js";
+export * from "./OperationEvent.js";
+export * from "./PlatoConfig.js";
+export * from "./PlatoTask.js";
+export * from "./PlatoTaskMetadata.js";
+export * from "./PostEvaluationResultResponse.js";
+export * from "./ProxyUrlResponse.js";
+export * from "./ResetEnvironmentResponse.js";
+export * from "./RunningSessionsCountResponse.js";
+export * from "./Sandbox.js";
+export * from "./ScoringType.js";
+export * from "./SetupRootAccessResponse.js";
+export * from "./SetupSandboxResponse.js";
+export * from "./SimConfigCompute.js";
+export * from "./SimConfigDataset.js";
+export * from "./SimConfigListener.js";
+export * from "./SimConfigMetadata.js";
+export * from "./SimConfigService.js";
+export * from "./Simulator.js";
+export * from "./SimulatorListItem.js";
+export * from "./SshInfo.js";
+export * from "./StartWorkerResponse.js";
+export * from "./TaskMetadata.js";
+export * from "./TestCase.js";
+export * from "./TestCasesResponse.js";
+export * from "./Variable.js";
+export * from "./WorkerReadyResponse.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/core/fetcher/APIResponse.d.ts

@@ -0,0 +1,21 @@
+import type { RawResponse } from "./RawResponse.js";
+/**
+ * The response of an API call.
+ * It is a successful response or a failed response.
+ */
+export type APIResponse<Success, Failure> = SuccessfulResponse<Success> | FailedResponse<Failure>;
+export interface SuccessfulResponse<T> {
+    ok: true;
+    body: T;
+    /**
+     * @deprecated Use `rawResponse` instead
+     */
+    headers?: Record<string, any>;
+    rawResponse: RawResponse;
+}
+export interface FailedResponse<T> {
+    ok: false;
+    error: T;
+    rawResponse: RawResponse;
+}
+//# sourceMappingURL=APIResponse.d.ts.map

package/dist/core/fetcher/BinaryResponse.d.ts

@@ -0,0 +1,21 @@
+import type { ResponseWithBody } from "./ResponseWithBody.js";
+export type BinaryResponse = {
+    /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Request/bodyUsed) */
+    bodyUsed: boolean;
+    /**
+     * Returns a ReadableStream of the response body.
+     * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Request/body)
+     */
+    stream: () => ReadableStream<Uint8Array>;
+    /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Request/arrayBuffer) */
+    arrayBuffer: () => Promise<ArrayBuffer>;
+    /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Request/blob) */
+    blob: () => Promise<Blob>;
+    /**
+     * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Request/bytes)
+     * Some versions of the Fetch API may not support this method.
+     */
+    bytes?(): Promise<Uint8Array>;
+};
+export declare function getBinaryResponse(response: ResponseWithBody): BinaryResponse;
+//# sourceMappingURL=BinaryResponse.d.ts.map

package/dist/core/fetcher/EndpointMetadata.d.ts

@@ -0,0 +1,14 @@
+export type SecuritySchemeKey = string;
+/**
+ * A collection of security schemes, where the key is the name of the security scheme and the value is the list of scopes required for that scheme.
+ * All schemes in the collection must be satisfied for authentication to be successful.
+ */
+export type SecuritySchemeCollection = Record<SecuritySchemeKey, AuthScope[]>;
+export type AuthScope = string;
+export type EndpointMetadata = {
+    /**
+     * An array of security scheme collections. Each collection represents an alternative way to authenticate.
+     */
+    security?: SecuritySchemeCollection[];
+};
+//# sourceMappingURL=EndpointMetadata.d.ts.map

package/dist/core/fetcher/EndpointSupplier.d.ts

@@ -0,0 +1,13 @@
+import type { EndpointMetadata } from "./EndpointMetadata.js";
+import type { Supplier } from "./Supplier.js";
+type EndpointSupplierFn<T> = (arg: {
+    endpointMetadata: EndpointMetadata;
+}) => T | Promise<T>;
+export type EndpointSupplier<T> = Supplier<T> | EndpointSupplierFn<T>;
+export declare const EndpointSupplier: {
+    get: <T>(supplier: EndpointSupplier<T>, arg: {
+        endpointMetadata: EndpointMetadata;
+    }) => Promise<T>;
+};
+export {};
+//# sourceMappingURL=EndpointSupplier.d.ts.map

package/dist/core/fetcher/Fetcher.d.ts

@@ -0,0 +1,43 @@
+import type { APIResponse } from "./APIResponse.js";
+import type { EndpointMetadata } from "./EndpointMetadata.js";
+import { EndpointSupplier } from "./EndpointSupplier.js";
+export type FetchFunction = <R = unknown>(args: Fetcher.Args) => Promise<APIResponse<R, Fetcher.Error>>;
+export declare namespace Fetcher {
+    interface Args {
+        url: string;
+        method: string;
+        contentType?: string;
+        headers?: Record<string, string | EndpointSupplier<string | null | undefined> | null | undefined>;
+        queryParameters?: Record<string, unknown>;
+        body?: unknown;
+        timeoutMs?: number;
+        maxRetries?: number;
+        withCredentials?: boolean;
+        abortSignal?: AbortSignal;
+        requestType?: "json" | "file" | "bytes";
+        responseType?: "json" | "blob" | "sse" | "streaming" | "text" | "arrayBuffer" | "binary-response";
+        duplex?: "half";
+        endpointMetadata?: EndpointMetadata;
+    }
+    type Error = FailedStatusCodeError | NonJsonError | TimeoutError | UnknownError;
+    interface FailedStatusCodeError {
+        reason: "status-code";
+        statusCode: number;
+        body: unknown;
+    }
+    interface NonJsonError {
+        reason: "non-json";
+        statusCode: number;
+        rawBody: string;
+    }
+    interface TimeoutError {
+        reason: "timeout";
+    }
+    interface UnknownError {
+        reason: "unknown";
+        errorMessage: string;
+    }
+}
+export declare function fetcherImpl<R = unknown>(args: Fetcher.Args): Promise<APIResponse<R, Fetcher.Error>>;
+export declare const fetcher: FetchFunction;
+//# sourceMappingURL=Fetcher.d.ts.map

package/dist/core/fetcher/Headers.d.ts

@@ -0,0 +1,3 @@
+declare let Headers: typeof globalThis.Headers;
+export { Headers };
+//# sourceMappingURL=Headers.d.ts.map