daytona 0.200.0 → 0.201.0

data/lib/daytona/sandbox.rb

@@ -5,6 +5,7 @@
 
 require 'time'
 require 'timeout'
+require_relative 'utils/file_url_signing'
 
 module Daytona
   # A single point-in-time sample of historical Sandbox resource usage.
@@ -196,6 +197,8 @@ module Daytona
       @analytics_api_url_provider = analytics_api_url_provider
       @subscription_manager = subscription_manager
       @sub_id = nil
+      @signing_key = nil
+      @signing_key_fetched_at = 0
 
       # Create toolbox API clients with dynamic configuration
       @toolbox_api_config = build_toolbox_api_config
@@ -435,8 +438,8 @@ module Daytona
     #   puts "Sandbox user home: #{user_home_dir}"
     def get_user_home_dir
       @info_api.get_user_home_dir.dir
-    rescue StandardError => e
-      raise Sdk::Error, "Failed to get user home directory: #{e.message}"
+    rescue *Sdk::API_ERROR_CLASSES => e
+      raise Sdk.wrap_error(e, 'Failed to get user home directory')
     end
 
     # Gets the working directory path inside the Sandbox.
@@ -449,8 +452,8 @@ module Daytona
     #   puts "Sandbox working directory: #{work_dir}"
     def get_work_dir
       @info_api.get_work_dir.dir
-    rescue StandardError => e
-      raise Sdk::Error, "Failed to get working directory path: #{e.message}"
+    rescue *Sdk::API_ERROR_CLASSES => e
+      raise Sdk.wrap_error(e, 'Failed to get working directory path')
     end
 
     # Updates the Sandbox daemon's process environment. Newly spawned processes, sessions
@@ -524,6 +527,76 @@ module Daytona
       sandbox_api.get_port_preview_url(id, port)
     end
 
+    # Creates a pre-signed URL for downloading a file from the Sandbox.
+    #
+    # The URL works with any HTTP client without auth headers and stays valid across
+    # sandbox restarts (downloads succeed only while the sandbox is running). The signing
+    # key is cached locally for up to 15 seconds; if the key was rotated from another
+    # client, URLs may be rejected until the cache refreshes.
+    #
+    # @param path [String] Path to the file in the Sandbox.
+    # @param ttl_seconds [Integer, nil] How long the URL stays valid, in seconds.
+    #   Defaults to 3600. Zero or negative means the URL never expires.
+    # @return [String] Pre-signed download URL.
+    # @raise [Daytona::Sdk::Error] if the signing key cannot be fetched.
+    #
+    # @example
+    #   url = sandbox.download_url('/home/user/report.pdf')
+    #   # curl "$url" -o report.pdf
+    def download_url(path, ttl_seconds: nil)
+      Utils::FileUrlSigning.build_signed_file_url(
+        @toolbox_proxy_url,
+        id,
+        '/files/download',
+        'GET',
+        path,
+        ensure_signing_key,
+        ttl_seconds
+      )
+    end
+
+    # Creates a pre-signed URL for uploading a file to the Sandbox.
+    #
+    # Send a POST request with the file as multipart/form-data. The URL works with any
+    # HTTP client without auth headers. The signing key is cached locally for up to
+    # 15 seconds; if the key was rotated from another client, URLs may be rejected
+    # until the cache refreshes.
+    #
+    # @param path [String] Destination path for the uploaded file in the Sandbox.
+    # @param ttl_seconds [Integer, nil] How long the URL stays valid, in seconds.
+    #   Defaults to 3600. Zero or negative means the URL never expires.
+    # @return [String] Pre-signed upload URL.
+    # @raise [Daytona::Sdk::Error] if the signing key cannot be fetched.
+    #
+    # @example
+    #   url = sandbox.upload_url('/home/user/data.bin')
+    #   # curl -X POST -F "file=@local.bin" "$url"
+    def upload_url(path, ttl_seconds: nil)
+      Utils::FileUrlSigning.build_signed_file_url(
+        @toolbox_proxy_url,
+        id,
+        '/files/upload-v2',
+        'POST',
+        path,
+        ensure_signing_key,
+        ttl_seconds
+      )
+    end
+
+    # Rotates the sandbox signing key, invalidating all previously signed URLs.
+    #
+    # @return [void]
+    # @raise [DaytonaApiClient::ApiError] if the signing key rotation request fails.
+    #
+    # @example
+    #   sandbox.rotate_signing_key
+    #   puts 'All previously signed URLs are now invalid.'
+    def rotate_signing_key
+      @signing_key = @sandbox_api.rotate_signing_key(id)
+      @signing_key_fetched_at = Time.now.to_f
+      nil
+    end
+
     # Creates a signed preview URL for the sandbox at the specified port.
     #
     # @param port [Integer] The port to open the preview link on
@@ -570,8 +643,8 @@ module Daytona
     def refresh_activity
       sandbox_api.update_last_activity(id)
       nil
-    rescue StandardError => e
-      raise Sdk::Error, "Failed to refresh sandbox activity: #{e.message}"
+    rescue *Sdk::API_ERROR_CLASSES => e
+      raise Sdk.wrap_error(e, 'Failed to refresh sandbox activity')
     end
 
     # Revokes an SSH access token for the sandbox.
@@ -619,8 +692,8 @@ module Daytona
           error_states: [DaytonaApiClient::SandboxState::ERROR, DaytonaApiClient::SandboxState::BUILD_FAILED]
         )
       end
-    rescue StandardError => e
-      raise Sdk::Error, "Failed to recover sandbox: #{e.message}"
+    rescue *Sdk::API_ERROR_CLASSES => e
+      raise Sdk.wrap_error(e, 'Failed to recover sandbox')
     end
 
     # Stops the Sandbox and waits for it to be stopped.
@@ -841,7 +914,8 @@ module Daytona
                :update_network_settings, :update_secrets, :update_env,
                :create_ssh_access, :delete, :get_user_home_dir, :get_work_dir, :get_metrics, :get_metrics_latest,
                :labels=,
-               :preview_url, :create_signed_preview_url, :expire_signed_preview_url,
+               :preview_url, :download_url, :upload_url, :rotate_signing_key,
+               :create_signed_preview_url, :expire_signed_preview_url,
                :refresh, :refresh_activity, :revoke_ssh_access, :start, :recover, :stop,
                :create_lsp_server, :validate_ssh_access, :wait_for_sandbox_start,
                :wait_for_sandbox_stop, :resize, :wait_for_resize_complete,
@@ -964,6 +1038,16 @@ module Daytona
       @toolbox_api_config.base_path = uri.path.empty? ? '/' : uri.path
     end
 
+    def ensure_signing_key
+      key = @signing_key
+      if key.nil? || (Time.now.to_f - @signing_key_fetched_at) > 15
+        key = @sandbox_api.get_sandbox_signing_key(id)
+        @signing_key = key
+        @signing_key_fetched_at = Time.now.to_f
+      end
+      key
+    end
+
     # @params sandbox_dto [DaytonaApiClient::Sandbox, DaytonaApiClient::SandboxListItem]
     # @return [void]
     def process_response(sandbox_dto) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize

data/lib/daytona/sdk/deprecated.rb

@@ -0,0 +1,18 @@
+# Copyright Daytona Platforms Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+# frozen_string_literal: true
+
+# =============================================================================
+# Backward-compatibility aliases. New functionality belongs in errors.rb, not
+# here. Every name below exists solely so pre-typed-error-model user code
+# keeps working, and this file can be removed as a whole in a future major
+# release.
+# =============================================================================
+module Daytona
+  module Sdk
+    # @deprecated Use {BadRequestError} instead. Kept as an alias so existing
+    #   `rescue Daytona::Sdk::ValidationError` blocks keep working.
+    ValidationError = BadRequestError
+  end
+end

data/lib/daytona/sdk/errors.rb

@@ -0,0 +1,279 @@
+# Copyright Daytona Platforms Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+# frozen_string_literal: true
+
+require 'json'
+
+module Daytona
+  module Sdk # rubocop:disable Metrics/ModuleLength
+    # ApiError classes raised by the generated OpenAPI clients. Kept here so
+    # the error module can resolve them without depending on `sdk.rb`.
+    API_ERROR_CLASSES = [DaytonaApiClient::ApiError, DaytonaToolboxApiClient::ApiError].freeze
+
+    # Wire-format `source` values set by the translation layer when a
+    # Daytona service stamps them on the wire envelope. `nil` source means
+    # the response did not carry a structured envelope (treat as opaque).
+    SOURCE_API     = 'DAYTONA_API'
+    SOURCE_DAEMON  = 'DAYTONA_DAEMON'
+    SOURCE_PROXY   = 'DAYTONA_PROXY'
+
+    # ---------------------------------------------------------------------
+    # Base
+    # ---------------------------------------------------------------------
+
+    # Base class for every error raised by the Daytona SDK.
+    #
+    # @example Catching any SDK error
+    #   begin
+    #     daytona.create(params)
+    #   rescue Daytona::Sdk::Error => e
+    #     puts e.status_code, e.code, e.source
+    #   end
+    class Error < StandardError
+      def initialize(message = nil, status_code: nil, code: nil, source: nil, headers: nil)
+        super(message)
+        @status_code = status_code
+        @code = code
+        @source = source
+        @headers = headers
+      end
+
+      def status_code = @status_code || metadata_from_cause[:status_code]
+
+      def code = @code || metadata_from_cause[:code]
+
+      def headers = @headers || metadata_from_cause[:headers] || {}
+
+      # Returns the originating service, or `nil` if unknown. Falls back to
+      # metadata carried by `cause` so a re-raised ApiError keeps its
+      # server-stamped source.
+      def source = @source || metadata_from_cause[:source]
+
+      private
+
+      def metadata_from_cause
+        @metadata_from_cause ||= Sdk.api_error_details(cause)
+      end
+    end
+
+    # ---------------------------------------------------------------------
+    # HTTP status-class errors
+    # ---------------------------------------------------------------------
+
+    # HTTP 400 — request was rejected as malformed or invalid.
+    class BadRequestError < Error; end
+
+    # HTTP 401 — authentication failed or credentials missing.
+    class AuthenticationError < Error; end
+
+    # HTTP 403 — caller is authenticated but not allowed.
+    class ForbiddenError < Error; end
+
+    # HTTP 404 — target resource does not exist.
+    class NotFoundError < Error; end
+
+    # HTTP 408 / 504 / client-side timeouts.
+    class TimeoutError < Error; end
+
+    # HTTP 409 — request conflicts with current resource state.
+    class ConflictError < Error; end
+
+    # HTTP 410 — resource is permanently gone.
+    class GoneError < Error; end
+
+    # HTTP 422 — request is well-formed but semantically invalid.
+    class UnprocessableEntityError < Error; end
+
+    # HTTP 429 — rate limit was exceeded.
+    class RateLimitError < Error; end
+
+    # Generic 5xx fallback when a more specific class doesn't apply.
+    class ServerError < Error; end
+
+    # HTTP 500 — server-side bug or unhandled condition.
+    class InternalServerError < ServerError; end
+
+    # HTTP 502 — an upstream dependency rejected or dropped the request.
+    class BadGatewayError < ServerError; end
+
+    # HTTP 503 — the service is temporarily refusing traffic.
+    class ServiceUnavailableError < ServerError; end
+
+    # Transport-level failure (no HTTP response received).
+    class ConnectionError < Error; end
+
+    # Transport-level timeout. Subclass of ConnectionError so callers that
+    # catch the broader connection-failure category also match.
+    class ConnectionTimeoutError < ConnectionError; end
+
+    # ---------------------------------------------------------------------
+    # Domain subclasses — each inherits from the HTTP-status parent that
+    # matches its server-side status code.
+    # ---------------------------------------------------------------------
+
+    # Daemon: git
+    class GitAuthFailedError < AuthenticationError; end
+    class GitRepoNotFoundError < NotFoundError; end
+    class GitBranchNotFoundError < NotFoundError; end
+    class GitBranchExistsError < ConflictError; end
+    class GitPushRejectedError < ConflictError; end
+    class GitDirtyWorktreeError < ConflictError; end
+    class GitMergeConflictError < ConflictError; end
+
+    # Daemon: filesystem
+    class FileNotFoundError < NotFoundError; end
+    class FileAccessDeniedError < ForbiddenError; end
+
+    # Daemon: LSP
+    class LspServerNotInitializedError < BadRequestError; end
+
+    # Daemon: process / session
+    class ProcessExecutionTimeoutError < TimeoutError; end
+    class ProcessNotFoundError < NotFoundError; end
+    class SessionEndedError < GoneError; end
+    class CommandAlreadyCompletedError < GoneError; end
+
+    # Daemon: computer-use
+    class A11yUnavailableError < ServiceUnavailableError; end
+    class RecordingStillActiveError < ConflictError; end
+    class RecordingFfmpegNotFoundError < ServiceUnavailableError; end
+
+    # ---------------------------------------------------------------------
+    # Routing tables
+    # ---------------------------------------------------------------------
+
+    STATUS_CODE_TO_ERROR = {
+      400 => BadRequestError,
+      401 => AuthenticationError,
+      403 => ForbiddenError,
+      404 => NotFoundError,
+      408 => TimeoutError,
+      409 => ConflictError,
+      410 => GoneError,
+      422 => UnprocessableEntityError,
+      429 => RateLimitError,
+      500 => InternalServerError,
+      502 => BadGatewayError,
+      503 => ServiceUnavailableError,
+      504 => TimeoutError
+    }.freeze
+
+    # (source, code) tuple → exception class. Resolved BEFORE the status
+    # code, so a server-stamped domain code always wins over the generic
+    # status class.
+    CODE_TO_ERROR = {
+      # Daemon: git
+      [SOURCE_DAEMON, 'GIT_AUTH_FAILED'] => GitAuthFailedError,
+      [SOURCE_DAEMON, 'GIT_REPO_NOT_FOUND'] => GitRepoNotFoundError,
+      [SOURCE_DAEMON, 'GIT_BRANCH_NOT_FOUND'] => GitBranchNotFoundError,
+      [SOURCE_DAEMON, 'GIT_BRANCH_EXISTS'] => GitBranchExistsError,
+      [SOURCE_DAEMON, 'GIT_PUSH_REJECTED'] => GitPushRejectedError,
+      [SOURCE_DAEMON, 'GIT_DIRTY_WORKTREE'] => GitDirtyWorktreeError,
+      [SOURCE_DAEMON, 'GIT_MERGE_CONFLICT'] => GitMergeConflictError,
+
+      # Daemon: filesystem
+      [SOURCE_DAEMON, 'FILE_NOT_FOUND'] => FileNotFoundError,
+      [SOURCE_DAEMON, 'FILE_ACCESS_DENIED'] => FileAccessDeniedError,
+
+      # Daemon: LSP
+      [SOURCE_DAEMON, 'LSP_SERVER_NOT_INITIALIZED'] => LspServerNotInitializedError,
+
+      # Daemon: process / session
+      [SOURCE_DAEMON, 'PROCESS_EXECUTION_TIMEOUT'] => ProcessExecutionTimeoutError,
+      [SOURCE_DAEMON, 'PROCESS_NOT_FOUND'] => ProcessNotFoundError,
+      [SOURCE_DAEMON, 'SESSION_ENDED'] => SessionEndedError,
+      [SOURCE_DAEMON, 'COMMAND_ALREADY_COMPLETED'] => CommandAlreadyCompletedError,
+
+      # Daemon: computer-use
+      [SOURCE_DAEMON, 'A11Y_UNAVAILABLE'] => A11yUnavailableError,
+      [SOURCE_DAEMON, 'RECORDING_STILL_ACTIVE'] => RecordingStillActiveError,
+      [SOURCE_DAEMON, 'RECORDING_FFMPEG_NOT_FOUND'] => RecordingFfmpegNotFoundError
+    }.freeze
+
+    # ---------------------------------------------------------------------
+    # Public translation helpers (module-level functions on Daytona::Sdk)
+    # ---------------------------------------------------------------------
+
+    # Translate an OpenAPI-client error into the most specific Daytona SDK
+    # exception. Accepts an optional `prefix` that's prepended to the
+    # message for context (e.g. "Failed to create sandbox"). When `error`
+    # is already an `Sdk::Error` (e.g. raised by the streaming transfer
+    # helpers for cancel/timeout), its class is preserved and only the
+    # message is prefixed.
+    def self.wrap_error(error, prefix = nil)
+      if error.is_a?(Error)
+        message = prefix ? "#{prefix}: #{error.message}" : error.message
+        return error.class.new(message, status_code: error.status_code, code: error.code,
+                                        source: error.source, headers: error.headers)
+      end
+
+      details = api_error_details(error)
+      base_message = parsed_message(error) || error.message
+      message = prefix ? "#{prefix}: #{base_message}" : base_message
+      error_class_for(details).new(message, **details.slice(:status_code, :code, :source, :headers))
+    end
+
+    # Extract status code, code, source and headers from a raised OpenAPI
+    # error. Returns an empty hash when the error is not one of the
+    # generated client types.
+    def self.api_error_details(error)
+      return {} unless API_ERROR_CLASSES.any? { |c| error.is_a?(c) }
+
+      data = parse_error_body(error.respond_to?(:response_body) ? error.response_body : nil)
+      {
+        status_code: error.respond_to?(:code) ? error.code : nil,
+        code: data[:code],
+        source: data[:source],
+        headers: error.respond_to?(:response_headers) ? error.response_headers : nil
+      }
+    end
+
+    # Choose the exception class for a parsed error: (source, code) match
+    # wins, then HTTP status code, then the base Error.
+    def self.error_class_for(details)
+      code = details[:code]
+      source = details[:source]
+      if code && source
+        cls = CODE_TO_ERROR[[source, code]]
+        return cls if cls
+      end
+      status_code = details[:status_code]
+      exact_status_error = STATUS_CODE_TO_ERROR[status_code]
+      return exact_status_error if exact_status_error
+
+      return ServerError if status_code.is_a?(Integer) && status_code >= 500
+
+      Error
+    end
+
+    def self.parse_error_body(response_body)
+      return {} if response_body.nil? || response_body.empty?
+
+      data = JSON.parse(response_body)
+      return {} unless data.is_a?(Hash)
+
+      {
+        message: string_or_nil(data['message']) || string_or_nil(data['error']),
+        code: string_or_nil(data['code'] || data['error_code']),
+        source: string_or_nil(data['source'])
+      }
+    rescue JSON::ParserError
+      {}
+    end
+
+    # @api private
+    def self.parsed_message(error)
+      return nil unless API_ERROR_CLASSES.any? { |c| error.is_a?(c) }
+      return nil unless error.respond_to?(:response_body)
+
+      parse_error_body(error.response_body)[:message]
+    end
+
+    def self.string_or_nil(value)
+      value.is_a?(String) && !value.empty? ? value : nil
+    end
+
+    private_class_method :error_class_for, :parse_error_body, :parsed_message, :string_or_nil
+  end
+end

data/lib/daytona/sdk/file_download_patch.rb

@@ -0,0 +1,131 @@
+# Copyright Daytona Platforms Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+# frozen_string_literal: true
+
+# Patches the OpenAPI-generated `download_file` and `call_api` helpers in both
+# API clients so that streaming responses (return_type == 'File') do not lose
+# the response body when the server returns an error status.
+#
+# Background:
+#   For File downloads the generated `download_file` attaches Typhoeus
+#   `on_body` callbacks to stream the response into a Tempfile. The presence
+#   of `on_body` prevents Typhoeus from populating `response.body`, which
+#   means the daemon's structured error envelope (code/source/message) is
+#   discarded when the response is an error. The generated `call_api` then
+#   raises `ApiError` with an empty `response_body`.
+#
+# Fix:
+#   * In `download_file`, defer tempfile creation until `on_headers` and
+#     inspect the status code. For 2xx responses, behave exactly like the
+#     upstream code. For non-2xx responses, accumulate the body into a
+#     buffer stored as an instance variable on the ApiClient.
+#   * In `call_api`, rescue the `ApiError`, and if our buffer is populated,
+#     re-raise with `response_body` set to the buffered envelope.
+
+require 'tempfile'
+
+module Daytona
+  module Sdk
+    # rubocop:disable Metrics/AbcSize, Metrics/BlockLength, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+    module FileDownloadPatch
+      def self.apply!(api_client_class, api_error_class)
+        return if api_client_class.method_defined?(:_daytona_orig_call_api)
+
+        api_client_class.class_eval do
+          define_method(:_daytona_error_body_key) do
+            @daytona_error_body_key ||= :"daytona_file_download_error_body_#{object_id}"
+          end
+
+          define_method(:download_file) do |request, &block|
+            tempfile = nil
+            encoding = nil
+            stream_to_tempfile = false
+            error_body = String.new.b
+            Thread.current.thread_variable_set(_daytona_error_body_key, nil)
+
+            request.on_headers do |response|
+              stream_to_tempfile = response.code && response.code >= 200 && response.code < 300
+              next unless stream_to_tempfile
+
+              content_disposition = response.headers['Content-Disposition']
+              if content_disposition && content_disposition =~ /filename=/i
+                filename = content_disposition[/filename=['"]?([^'"\s]+)['"]?/, 1]
+                prefix = sanitize_filename(filename)
+              else
+                prefix = 'download-'
+              end
+              prefix += '-' unless prefix.end_with?('-')
+              encoding = response.body.encoding
+              tempfile = Tempfile.open(prefix, @config.temp_folder_path, encoding: encoding)
+            end
+
+            request.on_body do |chunk|
+              if stream_to_tempfile
+                chunk.force_encoding(encoding)
+                tempfile.write(chunk)
+              else
+                error_body << chunk.b
+              end
+            end
+
+            request.on_complete do
+              if stream_to_tempfile
+                if tempfile.nil?
+                  raise api_error_class,
+                        "Failed to create the tempfile based on the HTTP response from the server: #{request.inspect}"
+                end
+                tempfile.close
+                @config.logger.info(
+                  "Temp file written to #{tempfile.path}, please copy the file to a proper folder " \
+                  "with e.g. `FileUtils.cp(tempfile.path, '/new/file/path')` otherwise the temp file " \
+                  'will be deleted automatically with GC. It\'s also recommended to delete the temp file ' \
+                  'explicitly with `tempfile.delete`'
+                )
+                block&.call(tempfile)
+              else
+                Thread.current.thread_variable_set(_daytona_error_body_key, error_body) unless error_body.empty?
+              end
+            end
+          end
+
+          alias_method :_daytona_orig_call_api, :call_api
+
+          define_method(:call_api) do |http_method, path, opts = {}|
+            _daytona_orig_call_api(http_method, path, opts)
+          rescue api_error_class => e
+            error_body = Thread.current.thread_variable_get(_daytona_error_body_key)
+            if opts[:return_type] == 'File' && error_body && !error_body.empty?
+              new_err = api_error_class.new(
+                code: e.code,
+                response_headers: e.response_headers,
+                response_body: error_body
+              )
+              raise new_err, e.message
+            end
+            raise
+          ensure
+            Thread.current.thread_variable_set(_daytona_error_body_key, nil)
+          end
+
+          private :_daytona_error_body_key
+        end
+      end
+    end
+    # rubocop:enable Metrics/AbcSize, Metrics/BlockLength, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+  end
+end
+
+if Object.const_defined?(:DaytonaApiClient) &&
+   DaytonaApiClient.const_defined?(:ApiClient) &&
+   DaytonaApiClient.const_defined?(:ApiError)
+  Daytona::Sdk::FileDownloadPatch.apply!(DaytonaApiClient::ApiClient, DaytonaApiClient::ApiError)
+end
+
+if Object.const_defined?(:DaytonaToolboxApiClient) &&
+   DaytonaToolboxApiClient.const_defined?(:ApiClient) &&
+   DaytonaToolboxApiClient.const_defined?(:ApiError)
+  Daytona::Sdk::FileDownloadPatch.apply!(
+    DaytonaToolboxApiClient::ApiClient, DaytonaToolboxApiClient::ApiError
+  )
+end

data/lib/daytona/sdk/version.rb

@@ -5,6 +5,6 @@
 
 module Daytona
   module Sdk
-    VERSION = '0.200.0'
+    VERSION = '0.201.0'
   end
 end

data/lib/daytona/sdk.rb

@@ -3,6 +3,7 @@
 # Copyright Daytona Platforms Inc.
 # SPDX-License-Identifier: Apache-2.0
 
+require 'json'
 require 'logger'
 
 require 'daytona_api_client'
@@ -12,6 +13,9 @@ require 'toml'
 require 'websocket-client-simple'
 
 require_relative 'sdk/version'
+require_relative 'sdk/errors'
+require_relative 'sdk/deprecated'
+require_relative 'sdk/file_download_patch'
 require_relative 'config'
 require_relative 'otel'
 require_relative 'common/charts'
@@ -47,15 +51,9 @@ require_relative 'process'
 
 module Daytona
   module Sdk
-    class Error < StandardError; end
-    class TimeoutError < Error; end
-    class AuthenticationError < Error; end
-    class ForbiddenError < Error; end
-    class NotFoundError < Error; end
-    class ConflictError < Error; end
-    class ValidationError < Error; end
-    class RateLimitError < Error; end
-    class ServerError < Error; end
+    # The error hierarchy and translation helpers live in `sdk/errors.rb`.
+    # This file just provides cross-cutting bits that need to be loaded
+    # alongside them.
 
     def self.logger = @logger ||= Logger.new($stdout, level: Logger::INFO)
   end

data/lib/daytona/snapshot_service.rb

@@ -147,7 +147,8 @@ module Daytona
         aws_access_key_id: push_access_creds.access_key,
         aws_secret_access_key: push_access_creds.secret,
         aws_session_token: push_access_creds.session_token,
-        bucket_name: push_access_creds.bucket
+        bucket_name: push_access_creds.bucket,
+        region: push_access_creds.region
       )
 
       image.context_list.map do |context|