daytona 0.184.0.alpha.1 → 0.184.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 51f6c85ff29165b3645e8752fede62f4f0e006b6bece9cd4541ad90be2960f93
-  data.tar.gz: 9178ec77c86d9c28f65baa3e0faf76f861f282930259dc2c44f0fbbfd2643a39
+  metadata.gz: a915942565b3350f301af5bc17108ed23fd4c17ab2fabf794c55d061f7001b05
+  data.tar.gz: b7c4ae7fb09fd196a84b5b63fb06e66300ca16ef30d18f5b87c8026e0aa0366c
 SHA512:
-  metadata.gz: d7eb785153c1bbfe977cf0d00823cbcc0937baa52637c20001cab8237035dcb8c2a18fb2458f8fda6a1bc292a5fb1bec73d9af6853944205176713cb2438dfb8
-  data.tar.gz: 5883ceea8ae8d4ab9e593f4a55b31df562afce803d0119ed71f4958bc53d82b1ca73a3e64152b5c200c165597b64cd1933bbc9169d33cf25cf5b6dd3cc643850
+  metadata.gz: a849bfb163dbd2ec05b7fbc152877d702195526bf28c1c74e3da19b79d454d338deed08f4bc503998594ba65549f1b7960af64383bc6da67402751faebd09d45
+  data.tar.gz: 7769c3074cda40aad265165e41755e6e6de16144a36b1bbc1e739f8b3e5b9c20d0d57c4eec20dccaa97322b412068c663f3d86f2ecf1514c3cb18aceb39337c7

data/lib/daytona/code_interpreter.rb

@@ -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

@@ -9,6 +9,7 @@ module Daytona
   SandboxState = DaytonaApiClient::SandboxState
   SandboxListSortField = DaytonaApiClient::SandboxListSortField
   SandboxListSortDirection = DaytonaApiClient::SandboxListSortDirection
+  GpuType = DaytonaApiClient::GpuType
 
   class PaginatedResource
     # @return [Array<Object>]

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]

data/lib/daytona/file_system.rb

@@ -46,8 +46,8 @@ module Daytona
     def create_folder(path, mode)
       Sdk.logger.debug("Creating folder #{path} with mode #{mode}")
       toolbox_api.create_folder(path, mode)
-    rescue *Sdk::API_ERROR_CLASSES => e
-      raise Sdk.wrap_error(e, 'Failed to create folder')
+    rescue StandardError => e
+      raise Sdk::Error, "Failed to create folder: #{e.message}"
     end
 
     # Deletes a file from the Sandbox.
@@ -65,8 +65,8 @@ module Daytona
     #   sandbox.fs.delete_file("workspace/old_dir", recursive: true)
     def delete_file(path, recursive: false)
       toolbox_api.delete_file(path, { recursive: })
-    rescue *Sdk::API_ERROR_CLASSES => e
-      raise Sdk.wrap_error(e, 'Failed to delete file')
+    rescue StandardError => e
+      raise Sdk::Error, "Failed to delete file: #{e.message}"
     end
 
     # Gets detailed information about a file or directory, including its
@@ -89,8 +89,8 @@ module Daytona
     #   puts "Path is a directory" if info.is_dir
     def get_file_info(path)
       toolbox_api.get_file_info(path)
-    rescue *Sdk::API_ERROR_CLASSES => e
-      raise Sdk.wrap_error(e, 'Failed to get file info')
+    rescue StandardError => e
+      raise Sdk::Error, "Failed to get file info: #{e.message}"
     end
 
     # Lists files and directories in a given path and returns their information, similar to the ls -l command.
@@ -114,8 +114,8 @@ module Daytona
     #   puts "Subdirectories: #{dirs.map(&:name).join(', ')}"
     def list_files(path)
       toolbox_api.list_files({ path: })
-    rescue *Sdk::API_ERROR_CLASSES => e
-      raise Sdk.wrap_error(e, 'Failed to list files')
+    rescue StandardError => e
+      raise Sdk::Error, "Failed to list files: #{e.message}"
     end
 
     # Downloads a file from the Sandbox. Returns the file contents as a string.
@@ -150,8 +150,8 @@ module Daytona
       else
         file
       end
-    rescue *Sdk::API_ERROR_CLASSES => e
-      raise Sdk.wrap_error(e, 'Failed to download file')
+    rescue StandardError => e
+      raise Sdk::Error, "Failed to download file: #{e.message}"
     end
 
     # Downloads a single file from the Sandbox as a stream without buffering the entire
@@ -189,8 +189,8 @@ module Daytona
                                    timeout: timeout, on_progress: on_progress,
                                    cancel_event: cancel_event, &)
       nil
-    rescue *Sdk::API_ERROR_CLASSES, Sdk::Error => e
-      raise Sdk.wrap_error(e, 'Failed to download file')
+    rescue StandardError => e
+      raise Sdk::Error, "Failed to download file: #{e.message}"
     end
 
     # Uploads a file to the specified path in the Sandbox. If a file already exists at
@@ -229,8 +229,8 @@ module Daytona
           toolbox_api.upload_file(remote_path, file)
         end
       end
-    rescue *Sdk::API_ERROR_CLASSES => e
-      raise Sdk.wrap_error(e, 'Failed to upload file')
+    rescue StandardError => e
+      raise Sdk::Error, "Failed to upload file: #{e.message}"
     end
 
     # Streams +source+ to the Sandbox without buffering its contents in memory, with
@@ -259,8 +259,8 @@ module Daytona
       FileTransfer.stream_upload(api_client: toolbox_api.api_client, remote_path: remote_path,
                                  source: source, timeout: timeout, on_progress: on_progress,
                                  cancel_event: cancel_event)
-    rescue *Sdk::API_ERROR_CLASSES, Sdk::Error => e
-      raise Sdk.wrap_error(e, 'Failed to upload file')
+    rescue StandardError => e
+      raise Sdk::Error, "Failed to upload file: #{e.message}"
     end
 
     # Uploads multiple files to the Sandbox. If files already exist at the destination paths,
@@ -280,8 +280,8 @@ module Daytona
     #   sandbox.fs.upload_files(files)
     def upload_files(files)
       files.each { |file_upload| upload_file(file_upload.source, file_upload.destination) }
-    rescue *Sdk::API_ERROR_CLASSES => e
-      raise Sdk.wrap_error(e, 'Failed to upload files')
+    rescue StandardError => e
+      raise Sdk::Error, "Failed to upload files: #{e.message}"
     end
 
     # Searches for files containing a pattern, similar to the grep command.
@@ -301,8 +301,8 @@ module Daytona
     #   end
     def find_files(path, pattern)
       toolbox_api.find_in_files(path, pattern)
-    rescue *Sdk::API_ERROR_CLASSES => e
-      raise Sdk.wrap_error(e, 'Failed to find files')
+    rescue StandardError => e
+      raise Sdk::Error, "Failed to find files: #{e.message}"
     end
 
     # Searches for files and directories whose names match the specified pattern.
@@ -325,8 +325,8 @@ module Daytona
     #   puts "Found #{result.files.length} test files"
     def search_files(path, pattern)
       toolbox_api.search_files(path, pattern)
-    rescue *Sdk::API_ERROR_CLASSES => e
-      raise Sdk.wrap_error(e, 'Failed to search files')
+    rescue StandardError => e
+      raise Sdk::Error, "Failed to search files: #{e.message}"
     end
 
     # Moves or renames a file or directory. The parent directory of the destination must exist.
@@ -358,8 +358,8 @@ module Daytona
     #   )
     def move_files(source, destination)
       toolbox_api.move_file(source, destination)
-    rescue *Sdk::API_ERROR_CLASSES => e
-      raise Sdk.wrap_error(e, 'Failed to move files')
+    rescue StandardError => e
+      raise Sdk::Error, "Failed to move files: #{e.message}"
     end
 
     # Performs search and replace operations across multiple files.
@@ -394,8 +394,8 @@ module Daytona
         new_value: new_value
       )
       toolbox_api.replace_in_files(replace_request)
-    rescue *Sdk::API_ERROR_CLASSES => e
-      raise Sdk.wrap_error(e, 'Failed to replace in files')
+    rescue StandardError => e
+      raise Sdk::Error, "Failed to replace in files: #{e.message}"
     end
 
     # Sets permissions and ownership for a file or directory. Any of the parameters can be nil
@@ -429,8 +429,8 @@ module Daytona
       opts[:group] = group if group
 
       toolbox_api.set_file_permissions(path, opts)
-    rescue *Sdk::API_ERROR_CLASSES => e
-      raise Sdk.wrap_error(e, 'Failed to set file permissions')
+    rescue StandardError => e
+      raise Sdk::Error, "Failed to set file permissions: #{e.message}"
     end
 
     instrument :create_folder, :delete_file, :get_file_info, :list_files, :download_file,