daytona 0.184.0.alpha.1 → 0.185.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 51f6c85ff29165b3645e8752fede62f4f0e006b6bece9cd4541ad90be2960f93
-  data.tar.gz: 9178ec77c86d9c28f65baa3e0faf76f861f282930259dc2c44f0fbbfd2643a39
+  metadata.gz: '0846ab327fc5ae0c55ee61872fb3c29bf266979387b8f362846d0856dee50b0d'
+  data.tar.gz: 6ea941ba9e0c6182cbd9c364174ff58ec32eba00fa9c252d2decb5131bd19676
 SHA512:
-  metadata.gz: d7eb785153c1bbfe977cf0d00823cbcc0937baa52637c20001cab8237035dcb8c2a18fb2458f8fda6a1bc292a5fb1bec73d9af6853944205176713cb2438dfb8
-  data.tar.gz: 5883ceea8ae8d4ab9e593f4a55b31df562afce803d0119ed71f4958bc53d82b1ca73a3e64152b5c200c165597b64cd1933bbc9169d33cf25cf5b6dd3cc643850
+  metadata.gz: 8f7da0103eee9ba48d742003281d86530482aa1504e4c8d60734841c2c1229b47270c1d646b17cd70071e0fb314feb3c3fa262c92348324dd2015a062d67a853
+  data.tar.gz: 801300d22b0ebc53f76d870a4f98eca73b0bf267b8b877d33f6be41cf3c6c35790971d9abbec4e5241f4335ef7c0aa44b2e9958ea8fe7579d562e778fb8a49de

data/lib/daytona/code_interpreter.rb

@@ -108,40 +108,40 @@ module Daytona
 
       puts "[DEBUG] Connecting to WebSocket: #{ws_url}" if ENV['DEBUG']
 
-      ws = WebSocket::Client::Simple.connect(ws_url, headers:)
-
-      ws.on :open do
-        puts '[DEBUG] WebSocket opened, sending request' if ENV['DEBUG']
-        ws.send(JSON.dump(request))
-      end
+      ws = WebSocket::Client::Simple.connect(ws_url, headers:) do |client|
+        client.on :open do
+          puts '[DEBUG] WebSocket opened, sending request' if ENV['DEBUG']
+          client.send(JSON.dump(request))
+        end
 
-      ws.on :message do |msg|
-        puts "[DEBUG] Received message (length=#{msg.data.length}): #{msg.data.inspect[0..200]}" if ENV['DEBUG']
+        client.on :message do |msg|
+          puts "[DEBUG] Received message (length=#{msg.data.length}): #{msg.data.inspect[0..200]}" if ENV['DEBUG']
 
-        interpreter.send(:handle_message, msg.data, result, on_stdout, on_stderr, on_error, completion_queue)
-      end
-
-      ws.on :error do |e|
-        puts "[DEBUG] WebSocket error: #{e.message}" if ENV['DEBUG']
-        completion_queue.push({ type: :error, error: e })
-      end
+          interpreter.send(:handle_message, msg.data, result, on_stdout, on_stderr, on_error, completion_queue)
+        end
 
-      ws.on :close do |e|
-        if ENV['DEBUG']
-          code = e&.code || 'nil'
-          reason = e&.reason || 'nil'
-          puts "[DEBUG] WebSocket closed: code=#{code}, reason=#{reason}"
+        client.on :error do |e|
+          puts "[DEBUG] WebSocket error: #{e.message}" if ENV['DEBUG']
+          completion_queue.push({ type: :error, error: e })
         end
-        error_info = interpreter.send(:handle_close, e)
-        if error_info
-          completion_queue.push({ type: :error_from_close, error: error_info })
-        else
-          completion_queue.push({ type: :close })
+
+        client.on :close do |e|
+          if ENV['DEBUG']
+            code = e&.code || 'nil'
+            reason = e&.reason || 'nil'
+            puts "[DEBUG] WebSocket closed: code=#{code}, reason=#{reason}"
+          end
+          error_info = interpreter.send(:handle_close, e)
+          if error_info
+            completion_queue.push({ type: :error_from_close, error: error_info })
+          else
+            completion_queue.push({ type: :close })
+          end
         end
       end
 
       no_timeout = timeout.is_a?(Numeric) && timeout <= 0
-      max_wait = no_timeout ? nil : (timeout || 600) + 3
+      max_wait = no_timeout ? nil : (timeout || 600) + 30
       start_time = Time.now
       completion_reason = nil
 
@@ -232,8 +232,8 @@ module Daytona
     def create_context(cwd: nil)
       request = DaytonaToolboxApiClient::CreateContextRequest.new(cwd:)
       @toolbox_api.create_interpreter_context(request)
-    rescue *Sdk::API_ERROR_CLASSES => e
-      raise Sdk.wrap_error(e, 'Failed to create interpreter context')
+    rescue StandardError => e
+      raise Sdk::Error, "Failed to create interpreter context: #{e.message}"
     end
 
     # List all user-created interpreter contexts.
@@ -252,8 +252,8 @@ module Daytona
     def list_contexts
       response = @toolbox_api.list_interpreter_contexts
       response.contexts || []
-    rescue *Sdk::API_ERROR_CLASSES => e
-      raise Sdk.wrap_error(e, 'Failed to list interpreter contexts')
+    rescue StandardError => e
+      raise Sdk::Error, "Failed to list interpreter contexts: #{e.message}"
     end
 
     # Delete an interpreter context and shut down all associated processes.
@@ -272,8 +272,8 @@ module Daytona
     def delete_context(context)
       @toolbox_api.delete_interpreter_context(context.id)
       nil
-    rescue *Sdk::API_ERROR_CLASSES => e
-      raise Sdk.wrap_error(e, 'Failed to delete interpreter context')
+    rescue StandardError => e
+      raise Sdk::Error, "Failed to delete interpreter context: #{e.message}"
     end
 
     instrument :run_code, :create_context, :list_contexts, :delete_context,

data/lib/daytona/common/daytona.rb

@@ -46,6 +46,12 @@ module Daytona
     # @return [Boolean, nil] Whether the Sandbox should be ephemeral
     attr_accessor :ephemeral
 
+    # @return [String, nil] ID or name of an existing Sandbox to link the new Sandbox to. The new
+    #   Sandbox will be scheduled on the same runner as the linked Sandbox so a local network can be
+    #   established between them. Linked Sandboxes must be
+    #   ephemeral (auto_delete_interval=0) and cannot themselves be linked to another Sandbox.
+    attr_accessor :linked_sandbox
+
     # Initialize CreateSandboxBaseParams
     #
     # @param language [Symbol, nil] Programming language for the Sandbox
@@ -61,6 +67,7 @@ module Daytona
     # @param network_block_all [Boolean, nil] Whether to block all network access for the Sandbox
     # @param network_allow_list [String, nil] Comma-separated list of allowed CIDR network addresses for the Sandbox
     # @param ephemeral [Boolean, nil] Whether the Sandbox should be ephemeral
+    # @param linked_sandbox [String, nil] ID or name of an existing Sandbox to link the new Sandbox to
     def initialize( # rubocop:disable Metrics/MethodLength, Metrics/ParameterLists
       language: nil,
       os_user: nil,
@@ -74,7 +81,8 @@ module Daytona
       volumes: nil,
       network_block_all: nil,
       network_allow_list: nil,
-      ephemeral: nil
+      ephemeral: nil,
+      linked_sandbox: nil
     )
       @language = language
       @os_user = os_user
@@ -89,6 +97,7 @@ module Daytona
       @network_block_all = network_block_all
       @network_allow_list = network_allow_list
       @ephemeral = ephemeral
+      @linked_sandbox = linked_sandbox
 
       # Handle ephemeral and auto_delete_interval conflict
       handle_ephemeral_auto_delete_conflict
@@ -111,7 +120,8 @@ module Daytona
         volumes:,
         network_block_all:,
         network_allow_list:,
-        ephemeral:
+        ephemeral:,
+        linked_sandbox:
       }.compact
     end
 

data/lib/daytona/common/resources.rb

@@ -17,18 +17,23 @@ module Daytona
     # @return [Integer, nil] Number of GPUs to allocate
     attr_reader :gpu
 
+    # @return [String, Array<String>, nil] Preferred GPU type for the Sandbox
+    attr_reader :gpu_type
+
     # @param cpu [Integer, nil] Number of CPU cores to allocate
     # @param memory [Integer, nil] Amount of memory in GiB to allocate
     # @param disk [Integer, nil] Amount of disk space in GiB to allocate
     # @param gpu [Integer, nil] Number of GPUs to allocate
-    def initialize(cpu: nil, memory: nil, disk: nil, gpu: nil)
+    # @param gpu_type [String, Array<String>, nil] Preferred GPU type for the Sandbox
+    def initialize(cpu: nil, memory: nil, disk: nil, gpu: nil, gpu_type: nil)
       @cpu = cpu
       @memory = memory
       @disk = disk
       @gpu = gpu
+      @gpu_type = gpu_type
     end
 
     # @return [Hash] Hash representation of the resources
-    def to_h = { cpu:, memory:, disk:, gpu: }.compact
+    def to_h = { cpu:, memory:, disk:, gpu:, gpu_type: }.compact
   end
 end

data/lib/daytona/common/response.rb

@@ -6,9 +6,11 @@
 module Daytona
   # Re-export of api-client enum constants under the Daytona namespace so
   # SDK consumers never need to import from DaytonaApiClient directly.
+  SandboxClass = DaytonaApiClient::SandboxClass
   SandboxState = DaytonaApiClient::SandboxState
   SandboxListSortField = DaytonaApiClient::SandboxListSortField
   SandboxListSortDirection = DaytonaApiClient::SandboxListSortDirection
+  GpuType = DaytonaApiClient::GpuType
 
   class PaginatedResource
     # @return [Array<Object>]

data/lib/daytona/common/snapshot.rb

@@ -23,17 +23,22 @@ module Daytona
     #   Defaults to organization default region if not specified.
     attr_reader :region_id
 
+    # @return [DaytonaApiClient::SandboxClass, nil] Target sandbox class.
+    attr_reader :sandbox_class
+
     # @param name [String] Name of the snapshot
     # @param image [String, Daytona::Image] Image of the snapshot
     # @param resources [Daytona::Resources, nil] Resources of the snapshot
     # @param entrypoint [Array<String>, nil] Entrypoint of the snapshot
     # @param region_id [String, nil] ID of the region where the snapshot will be available
-    def initialize(name:, image:, resources: nil, entrypoint: nil, region_id: nil)
+    # @param sandbox_class [DaytonaApiClient::SandboxClass, nil] Target sandbox class
+    def initialize(name:, image:, resources: nil, entrypoint: nil, region_id: nil, sandbox_class: nil)
       @name = name
       @image = image
       @resources = resources
       @entrypoint = entrypoint
       @region_id = region_id
+      @sandbox_class = sandbox_class
     end
   end
 

data/lib/daytona/computer_use.rb

@@ -33,8 +33,8 @@ module Daytona
       #   puts "Mouse is at: #{position.x}, #{position.y}"
       def position
         toolbox_api.get_mouse_position
-      rescue *Sdk::API_ERROR_CLASSES => e
-        raise Sdk.wrap_error(e, 'Failed to get mouse position')
+      rescue StandardError => e
+        raise Sdk::Error, "Failed to get mouse position: #{e.message}"
       end
 
       # Moves the mouse cursor to the specified coordinates.
@@ -50,8 +50,8 @@ module Daytona
       def move(x:, y:)
         request = DaytonaToolboxApiClient::MouseMoveRequest.new(x:, y:)
         toolbox_api.move_mouse(request)
-      rescue *Sdk::API_ERROR_CLASSES => e
-        raise Sdk.wrap_error(e, 'Failed to move mouse')
+      rescue StandardError => e
+        raise Sdk::Error, "Failed to move mouse: #{e.message}"
       end
 
       # Clicks the mouse at the specified coordinates.
@@ -75,8 +75,8 @@ module Daytona
       def click(x:, y:, button: 'left', double: false)
         request = DaytonaToolboxApiClient::MouseClickRequest.new(x:, y:, button:, double:)
         toolbox_api.click(request)
-      rescue *Sdk::API_ERROR_CLASSES => e
-        raise Sdk.wrap_error(e, 'Failed to click mouse')
+      rescue StandardError => e
+        raise Sdk::Error, "Failed to click mouse: #{e.message}"
       end
 
       # Drags the mouse from start coordinates to end coordinates.
@@ -95,8 +95,8 @@ module Daytona
       def drag(start_x:, start_y:, end_x:, end_y:, button: 'left')
         request = DaytonaToolboxApiClient::MouseDragRequest.new(start_x:, start_y:, end_x:, end_y:, button:)
         toolbox_api.drag(request)
-      rescue *Sdk::API_ERROR_CLASSES => e
-        raise Sdk.wrap_error(e, 'Failed to drag mouse')
+      rescue StandardError => e
+        raise Sdk::Error, "Failed to drag mouse: #{e.message}"
       end
 
       # Scrolls the mouse wheel at the specified coordinates.
@@ -118,8 +118,8 @@ module Daytona
         request = DaytonaToolboxApiClient::MouseScrollRequest.new(x:, y:, direction:, amount:)
         toolbox_api.scroll(request)
         true
-      rescue *Sdk::API_ERROR_CLASSES => e
-        raise Sdk.wrap_error(e, 'Failed to scroll mouse')
+      rescue StandardError => e
+        raise Sdk::Error, "Failed to scroll mouse: #{e.message}"
       end
 
       instrument :position, :move, :click, :drag, :scroll, component: 'Mouse'
@@ -164,8 +164,8 @@ module Daytona
       def type(text:, delay: nil)
         request = DaytonaToolboxApiClient::KeyboardTypeRequest.new(text:, delay:)
         toolbox_api.type_text(request)
-      rescue *Sdk::API_ERROR_CLASSES => e
-        raise Sdk.wrap_error(e, 'Failed to type text')
+      rescue StandardError => e
+        raise Sdk::Error, "Failed to type text: #{e.message}"
       end
 
       # Presses a key with optional modifiers.
@@ -187,8 +187,8 @@ module Daytona
       def press(key:, modifiers: nil)
         request = DaytonaToolboxApiClient::KeyboardPressRequest.new(key:, modifiers: modifiers || [])
         toolbox_api.press_key(request)
-      rescue *Sdk::API_ERROR_CLASSES => e
-        raise Sdk.wrap_error(e, 'Failed to press key')
+      rescue StandardError => e
+        raise Sdk::Error, "Failed to press key: #{e.message}"
       end
 
       # Presses a hotkey combination.
@@ -209,8 +209,8 @@ module Daytona
       def hotkey(keys:)
         request = DaytonaToolboxApiClient::KeyboardHotkeyRequest.new(keys:)
         toolbox_api.press_hotkey(request)
-      rescue *Sdk::API_ERROR_CLASSES => e
-        raise Sdk.wrap_error(e, 'Failed to press hotkey')
+      rescue StandardError => e
+        raise Sdk::Error, "Failed to press hotkey: #{e.message}"
       end
 
       instrument :type, :press, :hotkey, component: 'Keyboard'
@@ -254,8 +254,8 @@ module Daytona
       #   with_cursor = sandbox.computer_use.screenshot.take_full_screen(show_cursor: true)
       def take_full_screen(show_cursor: false)
         toolbox_api.take_screenshot(show_cursor:)
-      rescue *Sdk::API_ERROR_CLASSES => e
-        raise Sdk.wrap_error(e, 'Failed to take screenshot')
+      rescue StandardError => e
+        raise Sdk::Error, "Failed to take screenshot: #{e.message}"
       end
 
       # Takes a screenshot of a specific region.
@@ -271,8 +271,8 @@ module Daytona
       #   puts "Captured region: #{screenshot.region.width}x#{screenshot.region.height}"
       def take_region(region:, show_cursor: false)
         toolbox_api.take_region_screenshot(region.height, region.width, region.y, region.x, show_cursor:)
-      rescue *Sdk::API_ERROR_CLASSES => e
-        raise Sdk.wrap_error(e, 'Failed to take region screenshot')
+      rescue StandardError => e
+        raise Sdk::Error, "Failed to take region screenshot: #{e.message}"
       end
 
       # Takes a compressed screenshot of the entire screen.
@@ -303,8 +303,8 @@ module Daytona
           format: options.fmt,
           show_cursor: options.show_cursor
         )
-      rescue *Sdk::API_ERROR_CLASSES => e
-        raise Sdk.wrap_error(e, 'Failed to take compressed screenshot')
+      rescue StandardError => e
+        raise Sdk::Error, "Failed to take compressed screenshot: #{e.message}"
       end
 
       # Takes a compressed screenshot of a specific region.
@@ -334,8 +334,8 @@ module Daytona
           format: options.fmt,
           show_cursor: options.show_cursor
         )
-      rescue *Sdk::API_ERROR_CLASSES => e
-        raise Sdk.wrap_error(e, 'Failed to take compressed region screenshot')
+      rescue StandardError => e
+        raise Sdk::Error, "Failed to take compressed region screenshot: #{e.message}"
       end
 
       instrument :take_full_screen, :take_region, :take_compressed, :take_compressed_region,
@@ -380,8 +380,8 @@ module Daytona
       #   end
       def info
         toolbox_api.get_display_info
-      rescue *Sdk::API_ERROR_CLASSES => e
-        raise Sdk.wrap_error(e, 'Failed to get display info')
+      rescue StandardError => e
+        raise Sdk::Error, "Failed to get display info: #{e.message}"
       end
 
       # Gets the list of open windows.
@@ -397,8 +397,8 @@ module Daytona
       #   end
       def windows
         toolbox_api.get_windows
-      rescue *Sdk::API_ERROR_CLASSES => e
-        raise Sdk.wrap_error(e, 'Failed to get windows')
+      rescue StandardError => e
+        raise Sdk::Error, "Failed to get windows: #{e.message}"
       end
 
       instrument :info, :windows, component: 'Display'
@@ -446,8 +446,8 @@ module Daytona
         opts[:max_depth] = max_depth unless max_depth.nil?
 
         toolbox_api.get_accessibility_tree(opts)
-      rescue *Sdk::API_ERROR_CLASSES => e
-        raise Sdk.wrap_error(e, 'Failed to get accessibility tree')
+      rescue StandardError => e
+        raise Sdk::Error, "Failed to get accessibility tree: #{e.message}"
       end
 
       # Finds AT-SPI accessibility nodes matching the provided filters.
@@ -482,8 +482,8 @@ module Daytona
 
         request = DaytonaToolboxApiClient::FindAccessibilityNodesRequest.new(attrs)
         toolbox_api.find_accessibility_nodes(request)
-      rescue *Sdk::API_ERROR_CLASSES => e
-        raise Sdk.wrap_error(e, 'Failed to find accessibility nodes')
+      rescue StandardError => e
+        raise Sdk::Error, "Failed to find accessibility nodes: #{e.message}"
       end
 
       # Focuses an AT-SPI accessibility node.
@@ -496,8 +496,8 @@ module Daytona
       def focus_node(id:)
         request = DaytonaToolboxApiClient::AccessibilityNodeRequest.new(id:)
         toolbox_api.focus_accessibility_node(request)
-      rescue *Sdk::API_ERROR_CLASSES => e
-        raise Sdk.wrap_error(e, 'Failed to focus accessibility node')
+      rescue StandardError => e
+        raise Sdk::Error, "Failed to focus accessibility node: #{e.message}"
       end
 
       # Invokes an AT-SPI accessibility node action.
@@ -514,8 +514,8 @@ module Daytona
 
         request = DaytonaToolboxApiClient::AccessibilityInvokeRequest.new(attrs)
         toolbox_api.invoke_accessibility_node(request)
-      rescue *Sdk::API_ERROR_CLASSES => e
-        raise Sdk.wrap_error(e, 'Failed to invoke accessibility node')
+      rescue StandardError => e
+        raise Sdk::Error, "Failed to invoke accessibility node: #{e.message}"
       end
 
       # Sets an AT-SPI accessibility node value.
@@ -529,8 +529,8 @@ module Daytona
       def set_node_value(id:, value:)
         request = DaytonaToolboxApiClient::AccessibilitySetValueRequest.new(id:, value:)
         toolbox_api.set_accessibility_node_value(request)
-      rescue *Sdk::API_ERROR_CLASSES => e
-        raise Sdk.wrap_error(e, 'Failed to set accessibility node value')
+      rescue StandardError => e
+        raise Sdk::Error, "Failed to set accessibility node value: #{e.message}"
       end
 
       instrument :get_tree, :find_nodes, :focus_node, :invoke_node, :set_node_value,
@@ -627,8 +627,8 @@ module Daytona
       def start(label: nil)
         request = DaytonaToolboxApiClient::StartRecordingRequest.new(label:)
         toolbox_api.start_recording(request: request)
-      rescue *Sdk::API_ERROR_CLASSES => e
-        raise Sdk.wrap_error(e, 'Failed to start recording')
+      rescue StandardError => e
+        raise Sdk::Error, "Failed to start recording: #{e.message}"
       end
 
       # Stops an active screen recording session.
@@ -644,8 +644,8 @@ module Daytona
       def stop(id:)
         request = DaytonaToolboxApiClient::StopRecordingRequest.new(id: id)
         toolbox_api.stop_recording(request)
-      rescue *Sdk::API_ERROR_CLASSES => e
-        raise Sdk.wrap_error(e, 'Failed to stop recording')
+      rescue StandardError => e
+        raise Sdk::Error, "Failed to stop recording: #{e.message}"
       end
 
       # Lists all recordings (active and completed).
@@ -661,8 +661,8 @@ module Daytona
       #   end
       def list
         toolbox_api.list_recordings
-      rescue *Sdk::API_ERROR_CLASSES => e
-        raise Sdk.wrap_error(e, 'Failed to list recordings')
+      rescue StandardError => e
+        raise Sdk::Error, "Failed to list recordings: #{e.message}"
       end
 
       # Gets details of a specific recording by ID.
@@ -678,8 +678,8 @@ module Daytona
       #   puts "Duration: #{recording.duration_seconds} seconds"
       def get(id:)
         toolbox_api.get_recording(id)
-      rescue *Sdk::API_ERROR_CLASSES => e
-        raise Sdk.wrap_error(e, 'Failed to get recording')
+      rescue StandardError => e
+        raise Sdk::Error, "Failed to get recording: #{e.message}"
       end
 
       # Deletes a recording by ID.
@@ -693,8 +693,8 @@ module Daytona
       #   puts "Recording deleted"
       def delete(id:)
         toolbox_api.delete_recording(id)
-      rescue *Sdk::API_ERROR_CLASSES => e
-        raise Sdk.wrap_error(e, 'Failed to delete recording')
+      rescue StandardError => e
+        raise Sdk::Error, "Failed to delete recording: #{e.message}"
       end
 
       # Downloads a recording file and saves it to a local path.
@@ -815,8 +815,8 @@ module Daytona
     #   puts "Computer use processes started: #{result.message}"
     def start
       toolbox_api.start_computer_use
-    rescue *Sdk::API_ERROR_CLASSES => e
-      raise Sdk.wrap_error(e, 'Failed to start computer use')
+    rescue StandardError => e
+      raise Sdk::Error, "Failed to start computer use: #{e.message}"
     end
 
     # Stops all computer use processes.
@@ -829,8 +829,8 @@ module Daytona
     #   puts "Computer use processes stopped: #{result.message}"
     def stop
       toolbox_api.stop_computer_use
-    rescue *Sdk::API_ERROR_CLASSES => e
-      raise Sdk.wrap_error(e, 'Failed to stop computer use')
+    rescue StandardError => e
+      raise Sdk::Error, "Failed to stop computer use: #{e.message}"
     end
 
     # Gets the status of all computer use processes.
@@ -843,8 +843,8 @@ module Daytona
     #   puts "Computer use status: #{response.status}"
     def status
       toolbox_api.get_computer_use_status
-    rescue *Sdk::API_ERROR_CLASSES => e
-      raise Sdk.wrap_error(e, 'Failed to get computer use status')
+    rescue StandardError => e
+      raise Sdk::Error, "Failed to get computer use status: #{e.message}"
     end
 
     # Gets the status of a specific VNC process.
@@ -858,8 +858,8 @@ module Daytona
     #   no_vnc_status = sandbox.computer_use.get_process_status("novnc")
     def get_process_status(process_name:)
       toolbox_api.get_process_status(process_name, sandbox_id)
-    rescue *Sdk::API_ERROR_CLASSES => e
-      raise Sdk.wrap_error(e, 'Failed to get process status')
+    rescue StandardError => e
+      raise Sdk::Error, "Failed to get process status: #{e.message}"
     end
 
     # Restarts a specific VNC process.
@@ -873,8 +873,8 @@ module Daytona
     #   puts "XFCE4 process restarted: #{result.message}"
     def restart_process(process_name:)
       toolbox_api.restart_process(process_name, sandbox_id)
-    rescue *Sdk::API_ERROR_CLASSES => e
-      raise Sdk.wrap_error(e, 'Failed to restart process')
+    rescue StandardError => e
+      raise Sdk::Error, "Failed to restart process: #{e.message}"
     end
 
     # Gets logs for a specific VNC process.
@@ -888,8 +888,8 @@ module Daytona
     #   puts "NoVNC logs: #{logs}"
     def get_process_logs(process_name:)
       toolbox_api.get_process_logs(process_name, sandbox_id)
-    rescue *Sdk::API_ERROR_CLASSES => e
-      raise Sdk.wrap_error(e, 'Failed to get process logs')
+    rescue StandardError => e
+      raise Sdk::Error, "Failed to get process logs: #{e.message}"
     end
 
     # Gets error logs for a specific VNC process.
@@ -903,8 +903,8 @@ module Daytona
     #   puts "X11VNC errors: #{errors}"
     def get_process_errors(process_name:)
       toolbox_api.get_process_errors(process_name, sandbox_id)
-    rescue *Sdk::API_ERROR_CLASSES => e
-      raise Sdk.wrap_error(e, 'Failed to get process errors')
+    rescue StandardError => e
+      raise Sdk::Error, "Failed to get process errors: #{e.message}"
     end
 
     instrument :start, :stop, :status, :get_process_status, :restart_process,

data/lib/daytona/daytona.rb

@@ -90,12 +90,9 @@ module Daytona
     #
     # @param id [String]
     # @return [Daytona::Sandbox]
-    # @raise [Daytona::Sdk::Error]
     def get(id)
       sandbox_dto = sandbox_api.get_sandbox(id)
       to_sandbox(sandbox_dto:)
-    rescue *Sdk::API_ERROR_CLASSES => e
-      raise Sdk.wrap_error(e, "Failed to get sandbox #{id}")
     end
 
     # Iterates over Sandboxes matching the given query.
@@ -181,8 +178,6 @@ module Daytona
       }.compact
 
       sandbox_api.list_sandboxes(opts)
-    rescue *Sdk::API_ERROR_CLASSES => e
-      raise Sdk.wrap_error(e, 'Failed to list sandboxes')
     end
 
     instrument :fetch_sandbox_page, component: 'Daytona.list'
@@ -219,7 +214,8 @@ module Daytona
         auto_delete_interval: params.auto_delete_interval,
         volumes: params.volumes,
         network_block_all: params.network_block_all,
-        network_allow_list: params.network_allow_list
+        network_allow_list: params.network_allow_list,
+        linked_sandbox: params.linked_sandbox
       )
 
       create_sandbox.snapshot = params.snapshot if params.respond_to?(:snapshot)
@@ -240,6 +236,10 @@ module Daytona
         create_sandbox.memory = params.resources&.memory
         create_sandbox.disk = params.resources&.disk
         create_sandbox.gpu = params.resources&.gpu
+        if params.resources&.gpu_type
+          create_sandbox.gpu_type =
+            params.resources.gpu_type.is_a?(Array) ? params.resources.gpu_type : [params.resources.gpu_type]
+        end
       end
 
       response = sandbox_api.create_sandbox(create_sandbox)
@@ -267,8 +267,6 @@ module Daytona
       end
 
       sandbox
-    rescue *Sdk::API_ERROR_CLASSES => e
-      raise Sdk.wrap_error(e, 'Failed to create sandbox')
     end
 
     # @return [void]