rl-rock 1.2.1

package/dist/index.d.mts

@@ -0,0 +1,1308 @@
+import { z } from 'zod';
+import { ChildProcess } from 'child_process';
+
+/**
+ * ROCK status codes enumeration
+ */
+/**
+ * Status codes with phrase descriptions
+ */
+declare enum Codes {
+    /**
+     * Success codes (2xxx)
+     */
+    OK = 2000,
+    /**
+     * Client error codes (4xxx)
+     */
+    BAD_REQUEST = 4000,
+    /**
+     * Server error codes (5xxx)
+     */
+    INTERNAL_SERVER_ERROR = 5000,
+    /**
+     * Command/execution error codes (6xxx)
+     */
+    COMMAND_ERROR = 6000
+}
+/**
+ * Human-readable reason phrases for status codes
+ */
+declare const ReasonPhrases: Record<Codes, string>;
+/**
+ * Get the reason phrase for a given status code
+ */
+declare function getReasonPhrase(code: Codes): string;
+/**
+ * Check if a status code indicates success (2xxx range)
+ */
+declare function isSuccess(code: Codes): boolean;
+/**
+ * Check if a status code indicates a client error (4xxx range)
+ */
+declare function isClientError(code: Codes): boolean;
+/**
+ * Check if a status code indicates a server error (5xxx range)
+ */
+declare function isServerError(code: Codes): boolean;
+/**
+ * Check if a status code indicates a command error (6xxx range)
+ */
+declare function isCommandError(code: Codes): boolean;
+/**
+ * Check if a status code indicates any kind of error
+ */
+declare function isError(code: Codes): boolean;
+
+/**
+ * Request types
+ */
+
+/**
+ * Command execution request
+ */
+declare const CommandSchema: z.ZodObject<{
+    command: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>;
+    timeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    cwd: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    command: string | string[];
+    timeout: number;
+    env?: Record<string, string> | undefined;
+    cwd?: string | undefined;
+}, {
+    command: string | string[];
+    timeout?: number | undefined;
+    env?: Record<string, string> | undefined;
+    cwd?: string | undefined;
+}>;
+type Command = z.infer<typeof CommandSchema>;
+/**
+ * Bash session creation request
+ */
+declare const CreateBashSessionRequestSchema: z.ZodObject<{
+    session: z.ZodDefault<z.ZodString>;
+    startupSource: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    envEnable: z.ZodDefault<z.ZodBoolean>;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    remoteUser: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    session: string;
+    startupSource: string[];
+    envEnable: boolean;
+    env?: Record<string, string> | undefined;
+    remoteUser?: string | undefined;
+}, {
+    env?: Record<string, string> | undefined;
+    session?: string | undefined;
+    startupSource?: string[] | undefined;
+    envEnable?: boolean | undefined;
+    remoteUser?: string | undefined;
+}>;
+type CreateBashSessionRequest = z.infer<typeof CreateBashSessionRequestSchema>;
+/**
+ * Bash action for session execution
+ */
+declare const BashActionSchema: z.ZodObject<{
+    command: z.ZodString;
+    session: z.ZodDefault<z.ZodString>;
+    timeout: z.ZodOptional<z.ZodNumber>;
+    check: z.ZodDefault<z.ZodEnum<["silent", "raise", "ignore"]>>;
+}, "strip", z.ZodTypeAny, {
+    command: string;
+    session: string;
+    check: "silent" | "raise" | "ignore";
+    timeout?: number | undefined;
+}, {
+    command: string;
+    timeout?: number | undefined;
+    session?: string | undefined;
+    check?: "silent" | "raise" | "ignore" | undefined;
+}>;
+type BashAction = z.infer<typeof BashActionSchema>;
+/**
+ * Write file request
+ */
+declare const WriteFileRequestSchema: z.ZodObject<{
+    content: z.ZodString;
+    path: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    content: string;
+}, {
+    path: string;
+    content: string;
+}>;
+type WriteFileRequest = z.infer<typeof WriteFileRequestSchema>;
+/**
+ * Read file request
+ */
+declare const ReadFileRequestSchema: z.ZodObject<{
+    path: z.ZodString;
+    encoding: z.ZodOptional<z.ZodString>;
+    errors: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    encoding?: string | undefined;
+    errors?: string | undefined;
+}, {
+    path: string;
+    encoding?: string | undefined;
+    errors?: string | undefined;
+}>;
+type ReadFileRequest = z.infer<typeof ReadFileRequestSchema>;
+/**
+ * Upload file request
+ */
+declare const UploadRequestSchema: z.ZodObject<{
+    sourcePath: z.ZodString;
+    targetPath: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    sourcePath: string;
+    targetPath: string;
+}, {
+    sourcePath: string;
+    targetPath: string;
+}>;
+type UploadRequest = z.infer<typeof UploadRequestSchema>;
+/**
+ * Close session request
+ */
+declare const CloseSessionRequestSchema: z.ZodObject<{
+    session: z.ZodDefault<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    session: string;
+}, {
+    session?: string | undefined;
+}>;
+type CloseSessionRequest = z.infer<typeof CloseSessionRequestSchema>;
+/**
+ * Chown request
+ */
+declare const ChownRequestSchema: z.ZodObject<{
+    remoteUser: z.ZodString;
+    paths: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    recursive: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    remoteUser: string;
+    paths: string[];
+    recursive: boolean;
+}, {
+    remoteUser: string;
+    paths?: string[] | undefined;
+    recursive?: boolean | undefined;
+}>;
+type ChownRequest = z.infer<typeof ChownRequestSchema>;
+/**
+ * Chmod request
+ */
+declare const ChmodRequestSchema: z.ZodObject<{
+    paths: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    mode: z.ZodDefault<z.ZodString>;
+    recursive: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    paths: string[];
+    recursive: boolean;
+    mode: string;
+}, {
+    paths?: string[] | undefined;
+    recursive?: boolean | undefined;
+    mode?: string | undefined;
+}>;
+type ChmodRequest = z.infer<typeof ChmodRequestSchema>;
+
+/**
+ * Response types
+ */
+
+/**
+ * Base sandbox response
+ */
+declare const SandboxResponseSchema: z.ZodObject<{
+    code: z.ZodOptional<z.ZodNativeEnum<typeof Codes>>;
+    exitCode: z.ZodOptional<z.ZodNumber>;
+    failureReason: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    code?: Codes | undefined;
+    exitCode?: number | undefined;
+    failureReason?: string | undefined;
+}, {
+    code?: Codes | undefined;
+    exitCode?: number | undefined;
+    failureReason?: string | undefined;
+}>;
+type SandboxResponse = z.infer<typeof SandboxResponseSchema>;
+/**
+ * Is alive response
+ */
+declare const IsAliveResponseSchema: z.ZodObject<{
+    isAlive: z.ZodBoolean;
+    message: z.ZodDefault<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+    isAlive: boolean;
+}, {
+    isAlive: boolean;
+    message?: string | undefined;
+}>;
+type IsAliveResponse = z.infer<typeof IsAliveResponseSchema>;
+/**
+ * Sandbox status response
+ */
+declare const SandboxStatusResponseSchema: z.ZodObject<{
+    sandboxId: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    portMapping: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    hostName: z.ZodOptional<z.ZodString>;
+    hostIp: z.ZodOptional<z.ZodString>;
+    isAlive: z.ZodDefault<z.ZodBoolean>;
+    image: z.ZodOptional<z.ZodString>;
+    gatewayVersion: z.ZodOptional<z.ZodString>;
+    sweRexVersion: z.ZodOptional<z.ZodString>;
+    userId: z.ZodOptional<z.ZodString>;
+    experimentId: z.ZodOptional<z.ZodString>;
+    namespace: z.ZodOptional<z.ZodString>;
+    cpus: z.ZodOptional<z.ZodNumber>;
+    memory: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    isAlive: boolean;
+    status?: Record<string, unknown> | undefined;
+    sandboxId?: string | undefined;
+    portMapping?: Record<string, unknown> | undefined;
+    hostName?: string | undefined;
+    hostIp?: string | undefined;
+    image?: string | undefined;
+    gatewayVersion?: string | undefined;
+    sweRexVersion?: string | undefined;
+    userId?: string | undefined;
+    experimentId?: string | undefined;
+    namespace?: string | undefined;
+    cpus?: number | undefined;
+    memory?: string | undefined;
+}, {
+    status?: Record<string, unknown> | undefined;
+    isAlive?: boolean | undefined;
+    sandboxId?: string | undefined;
+    portMapping?: Record<string, unknown> | undefined;
+    hostName?: string | undefined;
+    hostIp?: string | undefined;
+    image?: string | undefined;
+    gatewayVersion?: string | undefined;
+    sweRexVersion?: string | undefined;
+    userId?: string | undefined;
+    experimentId?: string | undefined;
+    namespace?: string | undefined;
+    cpus?: number | undefined;
+    memory?: string | undefined;
+}>;
+type SandboxStatusResponse = z.infer<typeof SandboxStatusResponseSchema>;
+/**
+ * Command execution response
+ */
+declare const CommandResponseSchema: z.ZodObject<{
+    stdout: z.ZodDefault<z.ZodString>;
+    stderr: z.ZodDefault<z.ZodString>;
+    exitCode: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    stdout: string;
+    stderr: string;
+    exitCode?: number | undefined;
+}, {
+    exitCode?: number | undefined;
+    stdout?: string | undefined;
+    stderr?: string | undefined;
+}>;
+type CommandResponse = z.infer<typeof CommandResponseSchema>;
+/**
+ * Write file response
+ */
+declare const WriteFileResponseSchema: z.ZodObject<{
+    success: z.ZodDefault<z.ZodBoolean>;
+    message: z.ZodDefault<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+    success: boolean;
+}, {
+    message?: string | undefined;
+    success?: boolean | undefined;
+}>;
+type WriteFileResponse = z.infer<typeof WriteFileResponseSchema>;
+/**
+ * Read file response
+ */
+declare const ReadFileResponseSchema: z.ZodObject<{
+    content: z.ZodDefault<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    content: string;
+}, {
+    content?: string | undefined;
+}>;
+type ReadFileResponse = z.infer<typeof ReadFileResponseSchema>;
+/**
+ * Upload response
+ */
+declare const UploadResponseSchema: z.ZodObject<{
+    success: z.ZodDefault<z.ZodBoolean>;
+    message: z.ZodDefault<z.ZodString>;
+    fileName: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+    success: boolean;
+    fileName?: string | undefined;
+}, {
+    message?: string | undefined;
+    success?: boolean | undefined;
+    fileName?: string | undefined;
+}>;
+type UploadResponse = z.infer<typeof UploadResponseSchema>;
+/**
+ * Bash observation (execution result)
+ */
+declare const ObservationSchema: z.ZodObject<{
+    output: z.ZodDefault<z.ZodString>;
+    exitCode: z.ZodOptional<z.ZodNumber>;
+    failureReason: z.ZodDefault<z.ZodString>;
+    expectString: z.ZodDefault<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    failureReason: string;
+    output: string;
+    expectString: string;
+    exitCode?: number | undefined;
+}, {
+    exitCode?: number | undefined;
+    failureReason?: string | undefined;
+    output?: string | undefined;
+    expectString?: string | undefined;
+}>;
+type Observation = z.infer<typeof ObservationSchema>;
+/**
+ * Create session response
+ */
+declare const CreateSessionResponseSchema: z.ZodObject<{
+    output: z.ZodDefault<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    output: string;
+}, {
+    output?: string | undefined;
+}>;
+type CreateSessionResponse = z.infer<typeof CreateSessionResponseSchema>;
+/**
+ * Close session response
+ */
+declare const CloseSessionResponseSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+type CloseSessionResponse = z.infer<typeof CloseSessionResponseSchema>;
+/**
+ * Close response
+ */
+declare const CloseResponseSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+type CloseResponse = z.infer<typeof CloseResponseSchema>;
+/**
+ * Chown response
+ */
+declare const ChownResponseSchema: z.ZodObject<{
+    success: z.ZodDefault<z.ZodBoolean>;
+    message: z.ZodDefault<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+    success: boolean;
+}, {
+    message?: string | undefined;
+    success?: boolean | undefined;
+}>;
+type ChownResponse = z.infer<typeof ChownResponseSchema>;
+/**
+ * Chmod response
+ */
+declare const ChmodResponseSchema: z.ZodObject<{
+    success: z.ZodDefault<z.ZodBoolean>;
+    message: z.ZodDefault<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+    success: boolean;
+}, {
+    message?: string | undefined;
+    success?: boolean | undefined;
+}>;
+type ChmodResponse = z.infer<typeof ChmodResponseSchema>;
+/**
+ * Execute bash session response
+ */
+declare const ExecuteBashSessionResponseSchema: z.ZodObject<{
+    success: z.ZodDefault<z.ZodBoolean>;
+    message: z.ZodDefault<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+    success: boolean;
+}, {
+    message?: string | undefined;
+    success?: boolean | undefined;
+}>;
+type ExecuteBashSessionResponse = z.infer<typeof ExecuteBashSessionResponseSchema>;
+/**
+ * OSS setup response
+ */
+declare const OssSetupResponseSchema: z.ZodObject<{
+    success: z.ZodDefault<z.ZodBoolean>;
+    message: z.ZodDefault<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+    success: boolean;
+}, {
+    message?: string | undefined;
+    success?: boolean | undefined;
+}>;
+type OssSetupResponse = z.infer<typeof OssSetupResponseSchema>;
+
+/**
+ * Common constants
+ */
+/**
+ * Run mode type
+ */
+type RunModeType$1 = 'normal' | 'nohup';
+/**
+ * Run mode enum
+ */
+declare const RunMode: {
+    NORMAL: "normal";
+    NOHUP: "nohup";
+};
+/**
+ * Constants class (deprecated, use envs module instead)
+ * @deprecated Use envs module instead
+ */
+declare class Constants {
+    static readonly BASE_URL_PRODUCT = "";
+    static readonly BASE_URL_ALIYUN = "";
+    static readonly BASE_URL_INNER = "";
+    static readonly BASE_URL_PRE = "";
+    static readonly BASE_URL_LOCAL = "";
+    static readonly REQUEST_TIMEOUT_SECONDS = 180;
+}
+/**
+ * PID prefix and suffix for nohup output parsing
+ */
+declare const PID_PREFIX = "__ROCK_PID_START__";
+declare const PID_SUFFIX = "__ROCK_PID_END__";
+
+/**
+ * ROCK Exception classes
+ */
+
+/**
+ * Base ROCK exception
+ */
+declare class RockException extends Error {
+    protected _code: Codes | null;
+    constructor(message: string, code?: Codes);
+    get code(): Codes | null;
+}
+/**
+ * Invalid parameter exception (deprecated)
+ * @deprecated Use BadRequestRockError instead
+ */
+declare class InvalidParameterRockException extends RockException {
+    constructor(message: string);
+}
+/**
+ * Bad request error (4xxx)
+ */
+declare class BadRequestRockError extends RockException {
+    constructor(message: string, code?: Codes);
+}
+/**
+ * Internal server error (5xxx)
+ */
+declare class InternalServerRockError extends RockException {
+    constructor(message: string, code?: Codes);
+}
+/**
+ * Command execution error (6xxx)
+ */
+declare class CommandRockError extends RockException {
+    constructor(message: string, code?: Codes);
+}
+/**
+ * Raise appropriate exception based on status code
+ */
+declare function raiseForCode(code: Codes | null | undefined, message: string): void;
+/**
+ * Convert RockException to SandboxResponse
+ */
+declare function fromRockException(e: RockException): SandboxResponse;
+
+/**
+ * HTTP utilities class
+ */
+declare class HttpUtils {
+    private static defaultTimeout;
+    private static defaultConnectTimeout;
+    /**
+     * Create axios instance with default config
+     */
+    private static createClient;
+    /**
+     * Send POST request
+     */
+    static post<T = unknown>(url: string, headers: Record<string, string>, data: Record<string, unknown>, readTimeout?: number): Promise<T>;
+    /**
+     * Send GET request
+     */
+    static get<T = unknown>(url: string, headers: Record<string, string>): Promise<T>;
+    /**
+     * Send multipart/form-data request
+     */
+    static postMultipart<T = unknown>(url: string, headers: Record<string, string>, data?: Record<string, string | number | boolean>, files?: Record<string, File | Buffer | [string, Buffer, string]>): Promise<T>;
+    /**
+     * Guess MIME type from filename
+     */
+    static guessContentType(filename: string): string;
+}
+
+/**
+ * Retry utilities
+ */
+/**
+ * Retry options
+ */
+interface RetryOptions {
+    maxAttempts?: number;
+    delaySeconds?: number;
+    backoff?: number;
+    jitter?: boolean;
+}
+/**
+ * Retry decorator for async functions
+ */
+declare function retryAsync<T>(fn: () => Promise<T>, options?: RetryOptions): Promise<T>;
+/**
+ * Sleep utility
+ */
+declare function sleep(ms: number): Promise<void>;
+/**
+ * Create a retry wrapper for a function
+ */
+declare function withRetry<T extends (...args: unknown[]) => Promise<unknown>>(fn: T, options?: RetryOptions): T;
+
+/**
+ * Deprecated decorator utilities
+ */
+/**
+ * Mark a function as deprecated
+ */
+declare function deprecated(reason?: string): (target: unknown, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+/**
+ * Mark a class as deprecated
+ */
+declare function deprecatedClass(reason?: string): <T extends new (...args: any[]) => any>(constructor: T) => T;
+
+/**
+ * System utilities
+ */
+/**
+ * Check if running in Node.js environment
+ */
+declare function isNode(): boolean;
+/**
+ * Check if running in browser environment
+ */
+declare function isBrowser(): boolean;
+/**
+ * Get environment variable
+ */
+declare function getEnv(key: string, defaultValue?: string): string | undefined;
+/**
+ * Get required environment variable
+ */
+declare function getRequiredEnv(key: string): string;
+/**
+ * Check if environment variable is set
+ */
+declare function isEnvSet(key: string): boolean;
+
+/**
+ * EnvHub data model definitions
+ */
+
+/**
+ * EnvHub client configuration
+ */
+declare const EnvHubClientConfigSchema: z.ZodObject<{
+    baseUrl: z.ZodDefault<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    baseUrl: string;
+}, {
+    baseUrl?: string | undefined;
+}>;
+type EnvHubClientConfig = z.infer<typeof EnvHubClientConfigSchema>;
+/**
+ * Rock environment info
+ */
+declare const RockEnvInfoSchema: z.ZodObject<{
+    envName: z.ZodString;
+    image: z.ZodString;
+    owner: z.ZodDefault<z.ZodString>;
+    createAt: z.ZodDefault<z.ZodString>;
+    updateAt: z.ZodDefault<z.ZodString>;
+    description: z.ZodDefault<z.ZodString>;
+    tags: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    extraSpec: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    image: string;
+    envName: string;
+    owner: string;
+    createAt: string;
+    updateAt: string;
+    description: string;
+    tags: string[];
+    extraSpec?: Record<string, unknown> | undefined;
+}, {
+    image: string;
+    envName: string;
+    owner?: string | undefined;
+    createAt?: string | undefined;
+    updateAt?: string | undefined;
+    description?: string | undefined;
+    tags?: string[] | undefined;
+    extraSpec?: Record<string, unknown> | undefined;
+}>;
+type RockEnvInfo = z.infer<typeof RockEnvInfoSchema>;
+/**
+ * Create RockEnvInfo from plain object
+ */
+declare function createRockEnvInfo(data: Record<string, unknown>): RockEnvInfo;
+/**
+ * Convert RockEnvInfo to plain object (snake_case for API)
+ */
+declare function rockEnvInfoToDict(env: RockEnvInfo): Record<string, unknown>;
+
+/**
+ * EnvHub client for communicating with EnvHub server
+ */
+
+/**
+ * EnvHub error exception
+ */
+declare class EnvHubError extends Error {
+    constructor(message: string);
+}
+/**
+ * EnvHub client for communicating with EnvHub server
+ */
+declare class EnvHubClient {
+    private config;
+    private baseUrl;
+    private headers;
+    constructor(config?: Partial<EnvHubClientConfig>);
+    /**
+     * Register or update an environment
+     */
+    register(options: {
+        envName: string;
+        image: string;
+        owner?: string;
+        description?: string;
+        tags?: string[];
+        extraSpec?: Record<string, unknown>;
+    }): Promise<RockEnvInfo>;
+    /**
+     * Get environment by name
+     */
+    getEnv(envName: string): Promise<RockEnvInfo>;
+    /**
+     * List environments
+     */
+    listEnvs(options?: {
+        owner?: string;
+        tags?: string[];
+    }): Promise<RockEnvInfo[]>;
+    /**
+     * Delete environment
+     */
+    deleteEnv(envName: string): Promise<boolean>;
+    /**
+     * Health check
+     */
+    healthCheck(): Promise<Record<string, string>>;
+}
+
+/**
+ * RockEnv - Gym-style environment interface
+ */
+/**
+ * Step result tuple type
+ */
+type StepResult = [
+    observation: unknown,
+    reward: number,
+    terminated: boolean,
+    truncated: boolean,
+    info: Record<string, unknown>
+];
+/**
+ * Reset result tuple type
+ */
+type ResetResult = [observation: unknown, info: Record<string, unknown>];
+/**
+ * RockEnv configuration
+ */
+interface RockEnvConfig {
+    envId: string;
+}
+/**
+ * RockEnv - Gym-style environment for ROCK
+ */
+declare class RockEnv {
+    private readonly envId;
+    private sandboxId;
+    private isClosed;
+    private client;
+    constructor(config: RockEnvConfig);
+    /**
+     * Initialize environment instance
+     */
+    private initializeEnvironment;
+    /**
+     * Execute an action step
+     *
+     * @param action - Action ID to execute
+     * @returns Tuple containing observation, reward, terminated, truncated, info
+     */
+    step(action: string | number): Promise<StepResult>;
+    /**
+     * Reset environment to initial state
+     *
+     * @param seed - Optional random seed
+     * @returns Tuple containing initial observation and info
+     */
+    reset(seed?: number): Promise<ResetResult>;
+    /**
+     * Close environment and clean up resources
+     */
+    close(): Promise<void>;
+    /**
+     * Parse step result from API response
+     */
+    private parseStepResult;
+    /**
+     * Parse reset result from API response
+     */
+    private parseResetResult;
+    /**
+     * Ensure environment is not closed
+     */
+    private ensureNotClosed;
+}
+
+/**
+ * Environment factory function
+ */
+
+/**
+ * Create a Rock environment instance
+ *
+ * @param envId - Environment ID
+ * @param options - Environment options
+ * @returns RockEnv instance
+ */
+declare function make(envId: string, options?: Record<string, unknown>): RockEnv;
+
+/**
+ * Sandbox configuration
+ */
+
+/**
+ * Base configuration schema
+ */
+declare const BaseConfigSchema: z.ZodObject<{
+    baseUrl: z.ZodDefault<z.ZodString>;
+    xrlAuthorization: z.ZodOptional<z.ZodString>;
+    extraHeaders: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    baseUrl: string;
+    extraHeaders: Record<string, string>;
+    xrlAuthorization?: string | undefined;
+}, {
+    baseUrl?: string | undefined;
+    xrlAuthorization?: string | undefined;
+    extraHeaders?: Record<string, string> | undefined;
+}>;
+type BaseConfig = z.infer<typeof BaseConfigSchema>;
+/**
+ * Sandbox configuration schema
+ */
+declare const SandboxConfigSchema: z.ZodObject<{
+    baseUrl: z.ZodDefault<z.ZodString>;
+    xrlAuthorization: z.ZodOptional<z.ZodString>;
+    extraHeaders: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+} & {
+    image: z.ZodDefault<z.ZodString>;
+    autoClearSeconds: z.ZodDefault<z.ZodNumber>;
+    routeKey: z.ZodOptional<z.ZodString>;
+    startupTimeout: z.ZodDefault<z.ZodNumber>;
+    memory: z.ZodDefault<z.ZodString>;
+    cpus: z.ZodDefault<z.ZodNumber>;
+    userId: z.ZodOptional<z.ZodString>;
+    experimentId: z.ZodOptional<z.ZodString>;
+    cluster: z.ZodDefault<z.ZodString>;
+    namespace: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    image: string;
+    cpus: number;
+    memory: string;
+    baseUrl: string;
+    extraHeaders: Record<string, string>;
+    autoClearSeconds: number;
+    startupTimeout: number;
+    cluster: string;
+    userId?: string | undefined;
+    experimentId?: string | undefined;
+    namespace?: string | undefined;
+    xrlAuthorization?: string | undefined;
+    routeKey?: string | undefined;
+}, {
+    image?: string | undefined;
+    userId?: string | undefined;
+    experimentId?: string | undefined;
+    namespace?: string | undefined;
+    cpus?: number | undefined;
+    memory?: string | undefined;
+    baseUrl?: string | undefined;
+    xrlAuthorization?: string | undefined;
+    extraHeaders?: Record<string, string> | undefined;
+    autoClearSeconds?: number | undefined;
+    routeKey?: string | undefined;
+    startupTimeout?: number | undefined;
+    cluster?: string | undefined;
+}>;
+type SandboxConfig = z.infer<typeof SandboxConfigSchema>;
+/**
+ * Sandbox group configuration schema
+ */
+declare const SandboxGroupConfigSchema: z.ZodObject<{
+    baseUrl: z.ZodDefault<z.ZodString>;
+    xrlAuthorization: z.ZodOptional<z.ZodString>;
+    extraHeaders: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+} & {
+    image: z.ZodDefault<z.ZodString>;
+    autoClearSeconds: z.ZodDefault<z.ZodNumber>;
+    routeKey: z.ZodOptional<z.ZodString>;
+    startupTimeout: z.ZodDefault<z.ZodNumber>;
+    memory: z.ZodDefault<z.ZodString>;
+    cpus: z.ZodDefault<z.ZodNumber>;
+    userId: z.ZodOptional<z.ZodString>;
+    experimentId: z.ZodOptional<z.ZodString>;
+    cluster: z.ZodDefault<z.ZodString>;
+    namespace: z.ZodOptional<z.ZodString>;
+} & {
+    size: z.ZodDefault<z.ZodNumber>;
+    startConcurrency: z.ZodDefault<z.ZodNumber>;
+    startRetryTimes: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    image: string;
+    cpus: number;
+    memory: string;
+    baseUrl: string;
+    extraHeaders: Record<string, string>;
+    autoClearSeconds: number;
+    startupTimeout: number;
+    cluster: string;
+    size: number;
+    startConcurrency: number;
+    startRetryTimes: number;
+    userId?: string | undefined;
+    experimentId?: string | undefined;
+    namespace?: string | undefined;
+    xrlAuthorization?: string | undefined;
+    routeKey?: string | undefined;
+}, {
+    image?: string | undefined;
+    userId?: string | undefined;
+    experimentId?: string | undefined;
+    namespace?: string | undefined;
+    cpus?: number | undefined;
+    memory?: string | undefined;
+    baseUrl?: string | undefined;
+    xrlAuthorization?: string | undefined;
+    extraHeaders?: Record<string, string> | undefined;
+    autoClearSeconds?: number | undefined;
+    routeKey?: string | undefined;
+    startupTimeout?: number | undefined;
+    cluster?: string | undefined;
+    size?: number | undefined;
+    startConcurrency?: number | undefined;
+    startRetryTimes?: number | undefined;
+}>;
+type SandboxGroupConfig = z.infer<typeof SandboxGroupConfigSchema>;
+/**
+ * Create sandbox config with defaults
+ */
+declare function createSandboxConfig(config?: Partial<SandboxConfig>): SandboxConfig;
+/**
+ * Create sandbox group config with defaults
+ */
+declare function createSandboxGroupConfig(config?: Partial<SandboxGroupConfig>): SandboxGroupConfig;
+
+/**
+ * Deploy - Sandbox resource deployment manager
+ */
+
+/**
+ * Deploy - Manages deployment of local directories to sandbox
+ */
+declare class Deploy {
+    private sandbox;
+    private workingDir;
+    constructor(sandbox: Sandbox);
+    /**
+     * Get the current working directory
+     */
+    getWorkingDir(): string | null;
+    /**
+     * Deploy local directory to sandbox
+     *
+     * @param localPath - Local directory path
+     * @param targetPath - Target path in sandbox (optional)
+     * @returns The target path in sandbox
+     */
+    deployWorkingDir(localPath: string, targetPath?: string): Promise<string>;
+    /**
+     * Format command template supporting ${} and <<>> syntax
+     *
+     * @param template - Template string with placeholders
+     * @param kwargs - Additional substitution variables
+     * @returns Formatted string
+     */
+    format(template: string, kwargs?: Record<string, string>): string;
+}
+
+/**
+ * FileSystem - File system operations for sandbox
+ */
+
+/**
+ * Abstract file system interface
+ */
+declare abstract class FileSystem {
+    protected sandbox: AbstractSandbox;
+    constructor(sandbox: AbstractSandbox);
+    abstract chown(request: ChownRequest): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    abstract chmod(request: ChmodRequest): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    abstract uploadDir(sourceDir: string, targetDir: string, extractTimeout?: number): Promise<Observation>;
+}
+/**
+ * Linux file system implementation
+ */
+declare class LinuxFileSystem extends FileSystem {
+    constructor(sandbox: AbstractSandbox);
+    chown(request: ChownRequest): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    chmod(request: ChmodRequest): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    uploadDir(sourceDir: string, targetDir: string, extractTimeout?: number): Promise<Observation>;
+}
+
+/**
+ * Sandbox types
+ */
+/**
+ * Run mode type
+ */
+type RunModeType = 'normal' | 'nohup';
+/**
+ * Speedup type enum
+ */
+declare enum SpeedupType {
+    APT = "apt",
+    PIP = "pip",
+    GITHUB = "github"
+}
+
+/**
+ * Network - Network management for sandbox
+ */
+
+/**
+ * Network management for sandbox
+ */
+declare class Network {
+    private sandbox;
+    constructor(sandbox: Sandbox);
+    /**
+     * Configure acceleration for package managers or network resources
+     *
+     * @param speedupType - Type of speedup configuration
+     * @param speedupValue - Speedup value (mirror URL or IP address)
+     * @param timeout - Execution timeout in seconds
+     * @returns Observation with execution result
+     */
+    speedup(speedupType: SpeedupType, speedupValue: string, timeout?: number): Promise<Observation>;
+    private buildAptSpeedupCommand;
+    private buildPipSpeedupCommand;
+    private buildGithubSpeedupCommand;
+}
+
+/**
+ * Process - Process management for sandbox execution
+ */
+
+/**
+ * Process management for sandbox execution
+ */
+declare class Process {
+    private sandbox;
+    constructor(sandbox: Sandbox);
+    /**
+     * Execute a script in the sandbox
+     *
+     * @param scriptContent - The script content to execute
+     * @param scriptName - Optional custom script name
+     * @param waitTimeout - Maximum time to wait for script completion
+     * @param waitInterval - Interval between process checks
+     * @param cleanup - Whether to delete the script file after execution
+     * @returns Observation with execution result
+     */
+    executeScript(options: {
+        scriptContent: string;
+        scriptName?: string;
+        waitTimeout?: number;
+        waitInterval?: number;
+        cleanup?: boolean;
+    }): Promise<Observation>;
+}
+
+/**
+ * RemoteUser - Remote user management for sandbox
+ */
+
+/**
+ * Abstract remote user interface
+ */
+declare abstract class RemoteUser {
+    protected sandbox: AbstractSandbox;
+    protected currentUser: string;
+    constructor(sandbox: AbstractSandbox);
+    getCurrentUser(): string;
+    abstract createRemoteUser(userName: string): Promise<boolean>;
+    abstract isUserExist(userName: string): Promise<boolean>;
+}
+/**
+ * Linux remote user implementation
+ */
+declare class LinuxRemoteUser extends RemoteUser {
+    constructor(sandbox: AbstractSandbox);
+    createRemoteUser(userName: string): Promise<boolean>;
+    isUserExist(userName: string): Promise<boolean>;
+}
+
+/**
+ * Sandbox client - Core sandbox management
+ */
+
+/**
+ * Abstract sandbox interface
+ */
+declare abstract class AbstractSandbox {
+    abstract isAlive(): Promise<IsAliveResponse>;
+    abstract createSession(request: CreateBashSessionRequest): Promise<CreateSessionResponse>;
+    abstract execute(command: Command): Promise<CommandResponse>;
+    abstract read_file(request: ReadFileRequest): Promise<ReadFileResponse>;
+    abstract write_file(request: WriteFileRequest): Promise<WriteFileResponse>;
+    abstract upload(request: UploadRequest): Promise<UploadResponse>;
+    abstract closeSession(request: CloseSessionRequest): Promise<CloseSessionResponse>;
+    abstract close(): Promise<void>;
+}
+/**
+ * Sandbox - Main sandbox client
+ */
+declare class Sandbox extends AbstractSandbox {
+    private config;
+    private url;
+    private routeKey;
+    private sandboxId;
+    private hostName;
+    private hostIp;
+    private cluster;
+    private deploy;
+    private fs;
+    private network;
+    private process;
+    private remoteUser;
+    constructor(config?: Partial<SandboxConfig>);
+    getSandboxId(): string;
+    getHostName(): string | null;
+    getHostIp(): string | null;
+    getCluster(): string;
+    getUrl(): string;
+    getFs(): LinuxFileSystem;
+    getNetwork(): Network;
+    getProcess(): Process;
+    getRemoteUser(): LinuxRemoteUser;
+    getDeploy(): Deploy;
+    getConfig(): SandboxConfig;
+    private buildHeaders;
+    private addUserDefinedTags;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    isAlive(): Promise<IsAliveResponse>;
+    getStatus(): Promise<SandboxStatusResponse>;
+    execute(command: Command): Promise<CommandResponse>;
+    createSession(request: CreateBashSessionRequest): Promise<CreateSessionResponse>;
+    closeSession(request: CloseSessionRequest): Promise<CloseSessionResponse>;
+    arun(cmd: string, options?: {
+        session?: string;
+        mode?: RunModeType;
+        waitTimeout?: number;
+        waitInterval?: number;
+        responseLimitedBytesInNohup?: number;
+        ignoreOutput?: boolean;
+        outputFile?: string;
+    }): Promise<Observation>;
+    private runInSession;
+    private arunWithNohup;
+    private waitForProcessCompletion;
+    write_file(request: WriteFileRequest): Promise<WriteFileResponse>;
+    read_file(request: ReadFileRequest): Promise<ReadFileResponse>;
+    upload(request: UploadRequest): Promise<UploadResponse>;
+    uploadByPath(sourcePath: string, targetPath: string): Promise<UploadResponse>;
+    close(): Promise<void>;
+    toString(): string;
+}
+/**
+ * SandboxGroup - Group of sandboxes with concurrent operations
+ */
+declare class SandboxGroup {
+    private config;
+    private sandboxList;
+    constructor(config?: Partial<SandboxGroupConfig>);
+    getSandboxList(): Sandbox[];
+    start(): Promise<void>;
+    stop(): Promise<void>;
+}
+
+/**
+ * Sandbox utilities
+ */
+
+/**
+ * Decorator to add timing and logging to functions
+ */
+declare function withTimeLogging(operationName: string): (target: unknown, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+/**
+ * Run command with retry
+ */
+declare function arunWithRetry(sandbox: Sandbox, cmd: string, session: string, mode: RunModeType, options?: {
+    waitTimeout?: number;
+    waitInterval?: number;
+    maxAttempts?: number;
+    errorMsg?: string;
+}): Promise<Observation>;
+/**
+ * Extract nohup PID from output
+ */
+declare function extractNohupPid(output: string): number | null;
+
+/**
+ * Model client for LLM interaction
+ */
+/**
+ * Model client configuration
+ */
+interface ModelClientConfig {
+    logFileName?: string;
+}
+/**
+ * Model client for LLM interaction
+ */
+declare class ModelClient {
+    private logFile;
+    constructor(config?: ModelClientConfig);
+    /**
+     * Anti-call LLM - input is response, output is next request
+     */
+    antiCallLlm(index: number, lastResponse?: string): Promise<string>;
+    /**
+     * Push response to log file
+     */
+    pushResponse(index: number, lastResponse: string): Promise<void>;
+    /**
+     * Pop request from log file
+     */
+    popRequest(index: number): Promise<string>;
+    /**
+     * Wait for first request
+     */
+    waitForFirstRequest(): Promise<void>;
+    private parseRequestLine;
+    private parseResponseLine;
+    private readLastRequestLine;
+    private readLastResponseLine;
+    private appendResponse;
+    private constructResponse;
+    private sleep;
+}
+
+/**
+ * Model service for managing local LLM service
+ */
+
+/**
+ * Model service configuration
+ */
+interface ModelServiceConfig {
+    modelServiceType?: string;
+    configFile?: string;
+    host?: string;
+    port?: number;
+    proxyBaseUrl?: string;
+    retryableStatusCodes?: string;
+    requestTimeout?: number;
+}
+/**
+ * Model service for managing local LLM service
+ */
+declare class ModelService {
+    private process;
+    /**
+     * Start sandbox service
+     */
+    startSandboxService(config?: ModelServiceConfig): ChildProcess;
+    /**
+     * Start and wait for service to be available
+     */
+    start(config?: ModelServiceConfig & {
+        timeoutSeconds?: number;
+    }): Promise<string>;
+    /**
+     * Start watching agent
+     */
+    startWatchAgent(agentPid: number, host?: string, port?: number): Promise<void>;
+    /**
+     * Stop service
+     */
+    stop(pid: string): Promise<void>;
+    /**
+     * Wait for service to be available
+     */
+    private waitServiceAvailable;
+    private sleep;
+}
+
+/**
+ * ROCK TypeScript SDK
+ * Main entry point
+ */
+declare const VERSION = "1.2.1";
+
+export { BadRequestRockError, type BaseConfig, type BashAction, BashActionSchema, type ChmodRequest, ChmodRequestSchema, type ChmodResponse, ChmodResponseSchema, type ChownRequest, ChownRequestSchema, type ChownResponse, ChownResponseSchema, type CloseResponse, CloseResponseSchema, type CloseSessionRequest, CloseSessionRequestSchema, type CloseSessionResponse, CloseSessionResponseSchema, Codes, type Command, type CommandResponse, CommandResponseSchema, CommandRockError, CommandSchema, Constants, type CreateBashSessionRequest, CreateBashSessionRequestSchema, type CreateSessionResponse, CreateSessionResponseSchema, Deploy, EnvHubClient, type EnvHubClientConfig, EnvHubClientConfigSchema, EnvHubError, type ExecuteBashSessionResponse, ExecuteBashSessionResponseSchema, HttpUtils, InternalServerRockError, InvalidParameterRockException, type IsAliveResponse, IsAliveResponseSchema, LinuxFileSystem, LinuxRemoteUser, ModelClient, type ModelClientConfig, ModelService, type ModelServiceConfig, Network, type Observation, ObservationSchema, type OssSetupResponse, OssSetupResponseSchema, PID_PREFIX, PID_SUFFIX, Process, type ReadFileRequest, ReadFileRequestSchema, type ReadFileResponse, ReadFileResponseSchema, ReasonPhrases, type ResetResult, RockEnv, type RockEnvConfig, type RockEnvInfo, RockEnvInfoSchema, RockException, RunMode, type RunModeType$1 as RunModeType, Sandbox, type SandboxConfig, SandboxConfigSchema, SandboxGroup, type SandboxGroupConfig, SandboxGroupConfigSchema, type SandboxResponse, SandboxResponseSchema, type RunModeType as SandboxRunModeType, type SandboxStatusResponse, SandboxStatusResponseSchema, SpeedupType, type StepResult, type UploadRequest, UploadRequestSchema, type UploadResponse, UploadResponseSchema, VERSION, type WriteFileRequest, WriteFileRequestSchema, type WriteFileResponse, WriteFileResponseSchema, arunWithRetry, createRockEnvInfo, createSandboxConfig, createSandboxGroupConfig, deprecated, deprecatedClass, extractNohupPid as extractNohupPidFromSandbox, fromRockException, getEnv, getReasonPhrase, getRequiredEnv, isBrowser, isClientError, isCommandError, isEnvSet, isError, isNode, isServerError, isSuccess, make, raiseForCode, retryAsync, rockEnvInfoToDict, sleep, withRetry, withTimeLogging };