@fastgpt-sdk/sandbox-adapter 0.0.30 → 0.0.32

package/dist/adapters/BaseSandboxAdapter.d.ts

@@ -9,7 +9,7 @@ import type { ContentReplaceEntry, DirectoryEntry, ExecuteOptions, ExecuteResult
  * Subclasses can override the polyfill service in their constructor.
  */
 export declare abstract class BaseSandboxAdapter implements ISandbox {
-    abstract readonly id: SandboxId;
+    abstract readonly id?: SandboxId;
     abstract readonly provider: string;
     protected _status: SandboxStatus;
     protected polyfillService?: CommandPolyfillService;
@@ -22,6 +22,7 @@ export declare abstract class BaseSandboxAdapter implements ISandbox {
     abstract delete(): Promise<void>;
     abstract getInfo(): Promise<SandboxInfo | null>;
     waitUntilReady(timeoutMs?: number): Promise<void>;
+    waitUntilDeleted(timeoutMs?: number): Promise<void>;
     renewExpiration(_additionalSeconds: number): Promise<void>;
     abstract execute(command: string, options?: ExecuteOptions): Promise<ExecuteResult>;
     executeStream(command: string, handlers: StreamHandlers, options?: ExecuteOptions): Promise<void>;

package/dist/adapters/E2BAdapter/type.d.ts

@@ -4,7 +4,7 @@
 export interface E2BConfig {
     /** E2B API Key */
     apiKey: string;
-    /** 可选的沙盒 ID，用于连接到已存在的沙盒 */
+    /** 的沙盒 ID，用于连接到已存在的沙盒 */
     sandboxId: string;
     /** 可选的模板 ID，用于创建新沙盒 */
     template?: string;

package/dist/adapters/OpenSandboxAdapter/index.d.ts

@@ -12,8 +12,9 @@ export type SandboxRuntimeType = 'docker' | 'kubernetes';
  * Connection configuration options for OpenSandboxAdapter.
  */
 export interface OpenSandboxConnectionConfig {
+    sessionId: string;
     /** Base URL for the OpenSandbox API */
-    baseUrl?: string;
+    baseUrl: string;
     /** API key for authentication */
     apiKey?: string;
     /** SDK request timeout in seconds */
@@ -50,14 +51,15 @@ export interface OpenSandboxConnectionConfig {
  */
 export declare class OpenSandboxAdapter extends BaseSandboxAdapter {
     private connectionConfig;
-    private createConfig?;
+    private createConfig;
     readonly provider: "opensandbox";
     readonly runtime: SandboxRuntimeType;
     private _sandbox?;
     private _connection;
-    private _id;
-    constructor(connectionConfig?: OpenSandboxConnectionConfig, createConfig?: OpenSandboxConfigType | undefined);
-    get id(): SandboxId;
+    private _id?;
+    constructor(connectionConfig: OpenSandboxConnectionConfig, createConfig: OpenSandboxConfigType);
+    get id(): SandboxId | undefined;
+    private set sandbox(value);
     private get sandbox();
     private createConnectionConfig;
     private static readonly STATE_MAP;
@@ -67,9 +69,11 @@ export declare class OpenSandboxAdapter extends BaseSandboxAdapter {
     private convertResourceLimits;
     private parseResourceLimits;
     private extractExitCode;
+    private getSandboxBySessionId;
     ensureRunning(): Promise<void>;
     create(): Promise<void>;
     connect(sandboxId: string): Promise<void>;
+    private resume;
     start(): Promise<void>;
     stop(): Promise<void>;
     delete(): Promise<void>;
@@ -85,11 +89,6 @@ export declare class OpenSandboxAdapter extends BaseSandboxAdapter {
      * @returns Endpoint with host, port, protocol and url fields
      */
     getEndpoint(port: number): Promise<Endpoint>;
-    /**
-     * Convert SDK Endpoint (no-scheme string) to our Endpoint type.
-     * SDK format: "localhost:44772" or "domain/route/.../44772"
-     */
-    private convertSdkEndpoint;
     getInfo(): Promise<SandboxInfo | null>;
     renewExpiration(additionalSeconds: number): Promise<void>;
     execute(command: string, options?: ExecuteOptions): Promise<ExecuteResult>;

package/dist/adapters/OpenSandboxAdapter/type.d.ts

@@ -1,5 +1,5 @@
 import { ImageSpec, NetworkPolicy, ResourceLimits } from '@/types';
-import type { Volume } from '@alibaba-group/opensandbox';
+import type { Volume } from '../../../opensandbox';
 /**
  * Configuration for creating a sandbox.
  */

package/dist/adapters/SealosDevboxAdapter/index.d.ts

@@ -18,7 +18,6 @@ export declare class SealosDevboxAdapter extends BaseSandboxAdapter {
     constructor(config: SealosDevboxConfig);
     get id(): SandboxId;
     private StatusAdapt;
-    private waitUntilDeleted;
     getInfo(): Promise<SandboxInfo | null>;
     ensureRunning(): Promise<void>;
     create(): Promise<void>;

package/dist/adapters/index.d.ts

@@ -6,7 +6,7 @@ export { SealosDevboxAdapter } from './SealosDevboxAdapter';
 export type { SealosDevboxConfig } from './SealosDevboxAdapter';
 export { OpenSandboxAdapter } from './OpenSandboxAdapter';
 export type { OpenSandboxConfigType, OpenSandboxConnectionConfig } from './OpenSandboxAdapter';
-export type { Volume as OpenSandboxVolume } from '@alibaba-group/opensandbox';
+export type { Volume as OpenSandboxVolume } from '../../opensandbox';
 export { E2BAdapter } from './E2BAdapter';
 export type { E2BConfig } from './E2BAdapter';
 export type SandboxProviderType = 'opensandbox' | 'sealosdevbox' | 'e2b';

package/dist/index.cjs

@@ -47519,7 +47519,19 @@ class BaseSandboxAdapter {
       }
       await this.sleep(checkInterval);
     }
-    throw new SandboxReadyTimeoutError(this.id, timeoutMs);
+    throw new SandboxReadyTimeoutError(this.id ?? "Unknown", timeoutMs);
+  }
+  async waitUntilDeleted(timeoutMs = 120000) {
+    const startTime = Date.now();
+    const checkInterval = 1000;
+    while (Date.now() - startTime < timeoutMs) {
+      const data = await this.getInfo().catch(() => true);
+      if (!data) {
+        return;
+      }
+      await this.sleep(checkInterval);
+    }
+    throw new SandboxReadyTimeoutError(this.id ?? "Unknown", timeoutMs);
   }
   async renewExpiration(_additionalSeconds) {
     throw new FeatureNotSupportedError("Sandbox expiration renewal not supported by this provider", "renewExpiration", this.provider);
@@ -47854,18 +47866,6 @@ class SealosDevboxAdapter extends BaseSandboxAdapter {
         return "Error";
     }
   }
-  async waitUntilDeleted() {
-    const startTime = Date.now();
-    const checkInterval = 1000;
-    while (Date.now() - startTime < 120000) {
-      const data = await this.getInfo().catch(() => true);
-      if (!data) {
-        return;
-      }
-      await this.sleep(checkInterval);
-    }
-    throw new TimeoutError("Sandbox not deleted", 120000, "waitUntilDeleted");
-  }
   async getInfo() {
     try {
       const res = await this.api.info(this._id);
@@ -47995,8 +47995,8 @@ class OpenSandboxAdapter extends BaseSandboxAdapter {
   runtime;
   _sandbox;
   _connection;
-  _id = "";
-  constructor(connectionConfig = {}, createConfig) {
+  _id;
+  constructor(connectionConfig, createConfig) {
     super();
     this.connectionConfig = connectionConfig;
     this.createConfig = createConfig;
@@ -48007,6 +48007,10 @@ class OpenSandboxAdapter extends BaseSandboxAdapter {
   get id() {
     return this._id;
   }
+  set sandbox(sandbox) {
+    this._sandbox = sandbox;
+    this._id = sandbox?.id;
+  }
   get sandbox() {
     if (!this._sandbox) {
       throw new SandboxStateError("Sandbox not initialized. Call create() or connect() first.", "UnExist", "Running");
@@ -48015,9 +48019,6 @@ class OpenSandboxAdapter extends BaseSandboxAdapter {
   }
   createConnectionConfig() {
     const { baseUrl, apiKey, requestTimeoutSeconds, debug, useServerProxy } = this.connectionConfig;
-    if (!baseUrl) {
-      return new import_opensandbox.ConnectionConfig({ apiKey, requestTimeoutSeconds, debug, useServerProxy });
-    }
     return new import_opensandbox.ConnectionConfig({
       domain: baseUrl,
       apiKey,
@@ -48128,32 +48129,74 @@ class OpenSandboxAdapter extends BaseSandboxAdapter {
     }
     return 0;
   }
+  async getSandboxBySessionId() {
+    const manager = import_opensandbox.SandboxManager.create({ connectionConfig: this._connection });
+    const result = await manager.listSandboxInfos({
+      metadata: { sessionId: this.connectionConfig.sessionId }
+    });
+    const val = result.items[0];
+    if (val) {
+      const status = this.mapStatus(val.status);
+      return {
+        id: val.id,
+        status
+      };
+    }
+  }
   async ensureRunning() {
-    return this.create();
+    const sandbox = await this.getSandboxBySessionId();
+    if (sandbox) {
+      switch (sandbox.status.state) {
+        case "UnExist":
+          await this.create();
+          break;
+        case "Running":
+          await this.connect(sandbox.id);
+          break;
+        case "Creating":
+        case "Starting":
+          await this.waitUntilReady();
+          break;
+        case "Stopping":
+        case "Stopped":
+          await this.resume(sandbox.id);
+          break;
+        case "Deleting":
+          await this.waitUntilDeleted();
+          await this.create();
+          break;
+        case "Error":
+          throw new ConnectionError(`Sandbox error: ${sandbox.status.message}`);
+        default:
+          throw new ConnectionError(`Sandbox state ${sandbox.status.state} not supported`);
+      }
+    } else {
+      await this.create();
+    }
   }
   async create() {
-    if (!this.createConfig) {
-      throw new Error("createConfig is required to create a sandbox. Pass it as the third argument to createSandbox().");
-    }
     const cfg = this.createConfig;
     try {
       this._status = { state: "Creating" };
       const image = this.convertImageSpec(cfg.image);
       const resource = this.convertResourceLimits(cfg.resourceLimits);
-      this._sandbox = await import_opensandbox.Sandbox.create({
+      this.sandbox = await import_opensandbox.Sandbox.create({
         connectionConfig: this._connection,
         image,
         entrypoint: cfg.entrypoint,
         timeoutSeconds: cfg.timeoutSeconds ?? null,
         resource,
         env: cfg.env,
-        metadata: cfg.metadata,
+        metadata: {
+          ...cfg.metadata,
+          sessionId: this.connectionConfig.sessionId
+        },
         volumes: cfg.volumes,
         skipHealthCheck: cfg.skipHealthCheck,
         readyTimeoutSeconds: cfg.readyTimeoutSeconds,
         healthCheckPollingInterval: cfg.healthCheckPollingInterval
       });
-      this._id = this._sandbox.id;
+      await this.waitUntilReady();
       this._status = { state: "Running" };
     } catch (error) {
       this._status = { state: "Error", message: String(error) };
@@ -48163,31 +48206,51 @@ class OpenSandboxAdapter extends BaseSandboxAdapter {
   async connect(sandboxId) {
     try {
       this._status = { state: "Starting" };
-      this._sandbox = await import_opensandbox.Sandbox.connect({
+      this.sandbox = await import_opensandbox.Sandbox.connect({
         sandboxId,
         connectionConfig: this._connection,
         skipHealthCheck: this.createConfig?.skipHealthCheck,
         readyTimeoutSeconds: this.createConfig?.readyTimeoutSeconds,
         healthCheckPollingInterval: this.createConfig?.healthCheckPollingInterval
       });
-      this._id = this._sandbox.id;
       this._status = { state: "Running" };
     } catch (error) {
       this._status = { state: "Error", message: String(error) };
       throw new ConnectionError(`Failed to connect to sandbox ${sandboxId}`, this.connectionConfig.baseUrl, error);
     }
   }
+  async resume(sandboxId) {
+    try {
+      this._status = { state: "Starting" };
+      this.sandbox = await import_opensandbox.Sandbox.resume({
+        sandboxId,
+        connectionConfig: this._connection,
+        skipHealthCheck: this.createConfig?.skipHealthCheck,
+        readyTimeoutSeconds: this.createConfig?.readyTimeoutSeconds,
+        healthCheckPollingInterval: this.createConfig?.healthCheckPollingInterval
+      });
+      this._status = { state: "Running" };
+    } catch (error) {
+      this._status = { state: "Error", message: String(error) };
+      throw new ConnectionError(`Failed to resume sandbox ${sandboxId}`, this.connectionConfig.baseUrl, error);
+    }
+  }
   async start() {
     try {
       this._status = { state: "Starting" };
-      this._sandbox = await this.sandbox.resume();
-      this._id = this.sandbox.id;
+      this.sandbox = await this.sandbox.resume();
+      await this.waitUntilReady();
       this._status = { state: "Running" };
     } catch (error) {
-      if (error && typeof error === "object" && "code" in error && error.code === "SANDBOX::API_NOT_SUPPORTED") {
-        throw new FeatureNotSupportedError("Start/resume not supported by this runtime", "start", this.provider);
+      const code = error instanceof import_opensandbox.SandboxException ? error.error.code : undefined;
+      switch (code) {
+        case "DOCKER::SANDBOX_NOT_PAUSED":
+          return;
+        case "SANDBOX::API_NOT_SUPPORTED":
+          throw new FeatureNotSupportedError("Start/resume not supported by this runtime", "start", this.provider);
+        default:
+          throw new CommandExecutionError("Failed to start sandbox", "start", error instanceof Error ? error : undefined);
       }
-      throw new CommandExecutionError("Failed to start sandbox", "start", error instanceof Error ? error : undefined);
     }
   }
   async stop() {
@@ -48196,6 +48259,10 @@ class OpenSandboxAdapter extends BaseSandboxAdapter {
       await this.sandbox.pause();
       this._status = { state: "Stopped" };
     } catch (error) {
+      const message = error instanceof import_opensandbox.SandboxException ? error.error.message : undefined;
+      if (message?.includes("already paused")) {
+        return;
+      }
       if (error && typeof error === "object" && "code" in error && error.code === "SANDBOX::API_NOT_SUPPORTED") {
         throw new FeatureNotSupportedError("Stop/pause not supported by this runtime", "stop", this.provider);
       }
@@ -48206,43 +48273,38 @@ class OpenSandboxAdapter extends BaseSandboxAdapter {
     try {
       this._status = { state: "Deleting" };
       await this.sandbox.kill();
-      this._sandbox = undefined;
-      this._id = "";
+      this.sandbox = undefined;
       this._status = { state: "UnExist" };
     } catch (error) {
       throw new CommandExecutionError("Failed to delete sandbox", "delete", error instanceof Error ? error : undefined);
     }
   }
   async close() {
-    if (this._sandbox) {
-      await this._sandbox.close();
-    }
+    await this.sandbox.close();
   }
   async getEndpoint(port) {
     const sdkEndpoint = await this.sandbox.getEndpoint(port);
-    return this.convertSdkEndpoint(sdkEndpoint, port);
-  }
-  convertSdkEndpoint(sdkEndpoint, requestedPort) {
     const raw = sdkEndpoint.endpoint;
     const colonIdx = raw.lastIndexOf(":");
     const hasPathBeforeColon = colonIdx !== -1 && raw.slice(0, colonIdx).includes("/");
     if (colonIdx !== -1 && !hasPathBeforeColon) {
       const host = raw.slice(0, colonIdx);
       const parsedPort = parseInt(raw.slice(colonIdx + 1), 10);
-      const port = isNaN(parsedPort) ? requestedPort : parsedPort;
+      const portNumber = isNaN(parsedPort) ? port : parsedPort;
       const protocol = port === 443 ? "https" : "http";
-      return { host, port, protocol, url: `${protocol}://${raw}` };
+      return { host, port: portNumber, protocol, url: `${protocol}://${raw}` };
     }
     return {
       host: raw,
-      port: requestedPort,
+      port,
       protocol: "https",
       url: `https://${raw}`
     };
   }
   async getInfo() {
-    if (!this._sandbox)
+    if (!this._sandbox) {
       return null;
+    }
     try {
       const info = await this.sandbox.getInfo();
       return {

package/dist/index.d.ts

@@ -2,3 +2,4 @@ export * from './adapters';
 export * from './errors';
 export * from './interfaces';
 export * from './types';
+export type { Volume as SandboxVolume } from '../opensandbox';

package/dist/index.js

@@ -47503,7 +47503,19 @@ class BaseSandboxAdapter {
       }
       await this.sleep(checkInterval);
     }
-    throw new SandboxReadyTimeoutError(this.id, timeoutMs);
+    throw new SandboxReadyTimeoutError(this.id ?? "Unknown", timeoutMs);
+  }
+  async waitUntilDeleted(timeoutMs = 120000) {
+    const startTime = Date.now();
+    const checkInterval = 1000;
+    while (Date.now() - startTime < timeoutMs) {
+      const data = await this.getInfo().catch(() => true);
+      if (!data) {
+        return;
+      }
+      await this.sleep(checkInterval);
+    }
+    throw new SandboxReadyTimeoutError(this.id ?? "Unknown", timeoutMs);
   }
   async renewExpiration(_additionalSeconds) {
     throw new FeatureNotSupportedError("Sandbox expiration renewal not supported by this provider", "renewExpiration", this.provider);
@@ -47838,18 +47850,6 @@ class SealosDevboxAdapter extends BaseSandboxAdapter {
         return "Error";
     }
   }
-  async waitUntilDeleted() {
-    const startTime = Date.now();
-    const checkInterval = 1000;
-    while (Date.now() - startTime < 120000) {
-      const data = await this.getInfo().catch(() => true);
-      if (!data) {
-        return;
-      }
-      await this.sleep(checkInterval);
-    }
-    throw new TimeoutError("Sandbox not deleted", 120000, "waitUntilDeleted");
-  }
   async getInfo() {
     try {
       const res = await this.api.info(this._id);
@@ -47979,8 +47979,8 @@ class OpenSandboxAdapter extends BaseSandboxAdapter {
   runtime;
   _sandbox;
   _connection;
-  _id = "";
-  constructor(connectionConfig = {}, createConfig) {
+  _id;
+  constructor(connectionConfig, createConfig) {
     super();
     this.connectionConfig = connectionConfig;
     this.createConfig = createConfig;
@@ -47991,6 +47991,10 @@ class OpenSandboxAdapter extends BaseSandboxAdapter {
   get id() {
     return this._id;
   }
+  set sandbox(sandbox) {
+    this._sandbox = sandbox;
+    this._id = sandbox?.id;
+  }
   get sandbox() {
     if (!this._sandbox) {
       throw new SandboxStateError("Sandbox not initialized. Call create() or connect() first.", "UnExist", "Running");
@@ -47999,9 +48003,6 @@ class OpenSandboxAdapter extends BaseSandboxAdapter {
   }
   createConnectionConfig() {
     const { baseUrl, apiKey, requestTimeoutSeconds, debug, useServerProxy } = this.connectionConfig;
-    if (!baseUrl) {
-      return new import_opensandbox.ConnectionConfig({ apiKey, requestTimeoutSeconds, debug, useServerProxy });
-    }
     return new import_opensandbox.ConnectionConfig({
       domain: baseUrl,
       apiKey,
@@ -48112,32 +48113,74 @@ class OpenSandboxAdapter extends BaseSandboxAdapter {
     }
     return 0;
   }
+  async getSandboxBySessionId() {
+    const manager = import_opensandbox.SandboxManager.create({ connectionConfig: this._connection });
+    const result = await manager.listSandboxInfos({
+      metadata: { sessionId: this.connectionConfig.sessionId }
+    });
+    const val = result.items[0];
+    if (val) {
+      const status = this.mapStatus(val.status);
+      return {
+        id: val.id,
+        status
+      };
+    }
+  }
   async ensureRunning() {
-    return this.create();
+    const sandbox = await this.getSandboxBySessionId();
+    if (sandbox) {
+      switch (sandbox.status.state) {
+        case "UnExist":
+          await this.create();
+          break;
+        case "Running":
+          await this.connect(sandbox.id);
+          break;
+        case "Creating":
+        case "Starting":
+          await this.waitUntilReady();
+          break;
+        case "Stopping":
+        case "Stopped":
+          await this.resume(sandbox.id);
+          break;
+        case "Deleting":
+          await this.waitUntilDeleted();
+          await this.create();
+          break;
+        case "Error":
+          throw new ConnectionError(`Sandbox error: ${sandbox.status.message}`);
+        default:
+          throw new ConnectionError(`Sandbox state ${sandbox.status.state} not supported`);
+      }
+    } else {
+      await this.create();
+    }
   }
   async create() {
-    if (!this.createConfig) {
-      throw new Error("createConfig is required to create a sandbox. Pass it as the third argument to createSandbox().");
-    }
     const cfg = this.createConfig;
     try {
       this._status = { state: "Creating" };
       const image = this.convertImageSpec(cfg.image);
       const resource = this.convertResourceLimits(cfg.resourceLimits);
-      this._sandbox = await import_opensandbox.Sandbox.create({
+      this.sandbox = await import_opensandbox.Sandbox.create({
         connectionConfig: this._connection,
         image,
         entrypoint: cfg.entrypoint,
         timeoutSeconds: cfg.timeoutSeconds ?? null,
         resource,
         env: cfg.env,
-        metadata: cfg.metadata,
+        metadata: {
+          ...cfg.metadata,
+          sessionId: this.connectionConfig.sessionId
+        },
         volumes: cfg.volumes,
         skipHealthCheck: cfg.skipHealthCheck,
         readyTimeoutSeconds: cfg.readyTimeoutSeconds,
         healthCheckPollingInterval: cfg.healthCheckPollingInterval
       });
-      this._id = this._sandbox.id;
+      await this.waitUntilReady();
       this._status = { state: "Running" };
     } catch (error) {
       this._status = { state: "Error", message: String(error) };
@@ -48147,31 +48190,51 @@ class OpenSandboxAdapter extends BaseSandboxAdapter {
   async connect(sandboxId) {
     try {
       this._status = { state: "Starting" };
-      this._sandbox = await import_opensandbox.Sandbox.connect({
+      this.sandbox = await import_opensandbox.Sandbox.connect({
         sandboxId,
         connectionConfig: this._connection,
         skipHealthCheck: this.createConfig?.skipHealthCheck,
         readyTimeoutSeconds: this.createConfig?.readyTimeoutSeconds,
         healthCheckPollingInterval: this.createConfig?.healthCheckPollingInterval
       });
-      this._id = this._sandbox.id;
       this._status = { state: "Running" };
     } catch (error) {
       this._status = { state: "Error", message: String(error) };
       throw new ConnectionError(`Failed to connect to sandbox ${sandboxId}`, this.connectionConfig.baseUrl, error);
     }
   }
+  async resume(sandboxId) {
+    try {
+      this._status = { state: "Starting" };
+      this.sandbox = await import_opensandbox.Sandbox.resume({
+        sandboxId,
+        connectionConfig: this._connection,
+        skipHealthCheck: this.createConfig?.skipHealthCheck,
+        readyTimeoutSeconds: this.createConfig?.readyTimeoutSeconds,
+        healthCheckPollingInterval: this.createConfig?.healthCheckPollingInterval
+      });
+      this._status = { state: "Running" };
+    } catch (error) {
+      this._status = { state: "Error", message: String(error) };
+      throw new ConnectionError(`Failed to resume sandbox ${sandboxId}`, this.connectionConfig.baseUrl, error);
+    }
+  }
   async start() {
     try {
       this._status = { state: "Starting" };
-      this._sandbox = await this.sandbox.resume();
-      this._id = this.sandbox.id;
+      this.sandbox = await this.sandbox.resume();
+      await this.waitUntilReady();
       this._status = { state: "Running" };
     } catch (error) {
-      if (error && typeof error === "object" && "code" in error && error.code === "SANDBOX::API_NOT_SUPPORTED") {
-        throw new FeatureNotSupportedError("Start/resume not supported by this runtime", "start", this.provider);
+      const code = error instanceof import_opensandbox.SandboxException ? error.error.code : undefined;
+      switch (code) {
+        case "DOCKER::SANDBOX_NOT_PAUSED":
+          return;
+        case "SANDBOX::API_NOT_SUPPORTED":
+          throw new FeatureNotSupportedError("Start/resume not supported by this runtime", "start", this.provider);
+        default:
+          throw new CommandExecutionError("Failed to start sandbox", "start", error instanceof Error ? error : undefined);
       }
-      throw new CommandExecutionError("Failed to start sandbox", "start", error instanceof Error ? error : undefined);
     }
   }
   async stop() {
@@ -48180,6 +48243,10 @@ class OpenSandboxAdapter extends BaseSandboxAdapter {
       await this.sandbox.pause();
       this._status = { state: "Stopped" };
     } catch (error) {
+      const message = error instanceof import_opensandbox.SandboxException ? error.error.message : undefined;
+      if (message?.includes("already paused")) {
+        return;
+      }
       if (error && typeof error === "object" && "code" in error && error.code === "SANDBOX::API_NOT_SUPPORTED") {
         throw new FeatureNotSupportedError("Stop/pause not supported by this runtime", "stop", this.provider);
       }
@@ -48190,43 +48257,38 @@ class OpenSandboxAdapter extends BaseSandboxAdapter {
     try {
       this._status = { state: "Deleting" };
       await this.sandbox.kill();
-      this._sandbox = undefined;
-      this._id = "";
+      this.sandbox = undefined;
       this._status = { state: "UnExist" };
     } catch (error) {
       throw new CommandExecutionError("Failed to delete sandbox", "delete", error instanceof Error ? error : undefined);
     }
   }
   async close() {
-    if (this._sandbox) {
-      await this._sandbox.close();
-    }
+    await this.sandbox.close();
   }
   async getEndpoint(port) {
     const sdkEndpoint = await this.sandbox.getEndpoint(port);
-    return this.convertSdkEndpoint(sdkEndpoint, port);
-  }
-  convertSdkEndpoint(sdkEndpoint, requestedPort) {
     const raw = sdkEndpoint.endpoint;
     const colonIdx = raw.lastIndexOf(":");
     const hasPathBeforeColon = colonIdx !== -1 && raw.slice(0, colonIdx).includes("/");
     if (colonIdx !== -1 && !hasPathBeforeColon) {
       const host = raw.slice(0, colonIdx);
       const parsedPort = parseInt(raw.slice(colonIdx + 1), 10);
-      const port = isNaN(parsedPort) ? requestedPort : parsedPort;
+      const portNumber = isNaN(parsedPort) ? port : parsedPort;
       const protocol = port === 443 ? "https" : "http";
-      return { host, port, protocol, url: `${protocol}://${raw}` };
+      return { host, port: portNumber, protocol, url: `${protocol}://${raw}` };
     }
     return {
       host: raw,
-      port: requestedPort,
+      port,
       protocol: "https",
       url: `https://${raw}`
     };
   }
   async getInfo() {
-    if (!this._sandbox)
+    if (!this._sandbox) {
       return null;
+    }
     try {
       const info = await this.sandbox.getInfo();
       return {

package/dist/interfaces/ISandboxLifecycle.d.ts

@@ -5,7 +5,7 @@ import type { SandboxId, SandboxInfo, SandboxStatus } from '../types';
  */
 export interface ISandboxLifecycle {
     /** Unique identifier for this sandbox */
-    readonly id: SandboxId;
+    readonly id?: SandboxId;
     /** Current status of the sandbox */
     readonly status: SandboxStatus;
     /**
@@ -39,6 +39,7 @@ export interface ISandboxLifecycle {
      * @throws {SandboxReadyTimeoutError} If timeout is exceeded
      */
     waitUntilReady(timeoutMs?: number): Promise<void>;
+    waitUntilDeleted(timeoutMs?: number): Promise<void>;
     /**
      * Renew the sandbox expiration, extending its lifetime.
      * Not all providers support this.