@daytonaio/sdk 0.184.0-alpha.1 → 0.184.0

package/cjs/errors/DaytonaError.d.ts

@@ -5,116 +5,172 @@ import { AxiosHeaders } from 'axios';
 import type { AxiosError } from 'axios';
 export type ResponseHeaders = InstanceType<typeof AxiosHeaders>;
 /**
- * Wire-format `source` identifiers set by the translation layer when a
- * Daytona service stamps them on the wire envelope. `source = undefined`
- * means the response did not carry a structured envelope (treat as opaque).
- */
-export declare const SOURCE_API = "DAYTONA_API";
-export declare const SOURCE_DAEMON = "DAYTONA_DAEMON";
-export declare const SOURCE_PROXY = "DAYTONA_PROXY";
-/**
- * Base error for Daytona SDK. `statusCode` and `code` are populated only
- * for errors translated from a server response. `source` is `undefined`
- * unless the caller (or the translation layer) sets it.
+ * Base error for Daytona SDK.
+ *
+ * @example
+ * ```ts
+ * try {
+ *   await daytona.get('missing-sandbox')
+ * } catch (error) {
+ *   if (error instanceof DaytonaError) {
+ *     console.log(error.statusCode)
+ *     console.log(error.errorCode)
+ *     console.log(error.message)
+ *   }
+ * }
+ * ```
  */
 export declare class DaytonaError extends Error {
+    /** HTTP status code if available */
     statusCode?: number;
-    code?: string;
-    readonly source?: string;
+    /** Machine-readable error code if available */
+    errorCode?: string;
+    /** Response headers if available */
     headers?: ResponseHeaders;
-    constructor(message: string, statusCode?: number, headers?: ResponseHeaders, code?: string, source?: string);
-}
-export declare class DaytonaBadRequestError extends DaytonaError {
-}
-export declare class DaytonaAuthenticationError extends DaytonaError {
-}
-export declare class DaytonaForbiddenError extends DaytonaError {
+    constructor(message: string, statusCode?: number, headers?: ResponseHeaders, errorCode?: string);
 }
+/**
+ * Error thrown when a resource is not found (HTTP 404).
+ *
+ * @example
+ * ```ts
+ * try {
+ *   await sandbox.fs.downloadFile('/workspace/missing.txt')
+ * } catch (error) {
+ *   if (error instanceof DaytonaNotFoundError) {
+ *     console.log(error.statusCode)
+ *   }
+ * }
+ * ```
+ */
 export declare class DaytonaNotFoundError extends DaytonaError {
 }
-export declare class DaytonaTimeoutError extends DaytonaError {
-}
-export declare class DaytonaConflictError extends DaytonaError {
-}
-export declare class DaytonaGoneError extends DaytonaError {
-}
-export declare class DaytonaUnprocessableEntityError extends DaytonaError {
-}
+/**
+ * Error thrown when rate limit is exceeded.
+ *
+ * @example
+ * ```ts
+ * try {
+ *   for await (const sandbox of daytona.list()) {
+ *     console.log(sandbox.id)
+ *   }
+ * } catch (error) {
+ *   if (error instanceof DaytonaRateLimitError) {
+ *     console.log(error.errorCode)
+ *   }
+ * }
+ * ```
+ */
 export declare class DaytonaRateLimitError extends DaytonaError {
 }
-export declare class DaytonaInternalServerError extends DaytonaError {
-}
-export declare class DaytonaBadGatewayError extends DaytonaError {
-}
-export declare class DaytonaServiceUnavailableError extends DaytonaError {
-}
 /**
- * @deprecated Use {@link DaytonaBadRequestError} instead. Re-exported so
- * existing `catch (err) { if (err instanceof DaytonaValidationError) ... }`
- * blocks keep working.
+ * Error thrown when authentication fails (HTTP 401).
+ *
+ * @example
+ * ```ts
+ * try {
+ *   for await (const sandbox of daytona.list()) {
+ *     console.log(sandbox.id)
+ *   }
+ * } catch (error) {
+ *   if (error instanceof DaytonaAuthenticationError) {
+ *     console.log(error.statusCode)
+ *   }
+ * }
+ * ```
  */
-export declare const DaytonaValidationError: typeof DaytonaBadRequestError;
-/** @deprecated Use {@link DaytonaBadRequestError} instead. */
-export type DaytonaValidationError = DaytonaBadRequestError;
+export declare class DaytonaAuthenticationError extends DaytonaError {
+}
 /**
- * @deprecated Use {@link DaytonaForbiddenError} instead.
+ * Error thrown when the request is forbidden (HTTP 403).
+ *
+ * @example
+ * ```ts
+ * try {
+ *   await daytona.get('sandbox-without-access')
+ * } catch (error) {
+ *   if (error instanceof DaytonaAuthorizationError) {
+ *     console.log(error.message)
+ *   }
+ * }
+ * ```
  */
-export declare const DaytonaAuthorizationError: typeof DaytonaForbiddenError;
-/** @deprecated Use {@link DaytonaForbiddenError} instead. */
-export type DaytonaAuthorizationError = DaytonaForbiddenError;
-/** Network connection failure (can't connect or mid-request drop). */
-export declare class DaytonaConnectionError extends DaytonaError {
-}
-/** Transport-layer timeout (connect / read). Subclass of DaytonaConnectionError. */
-export declare class DaytonaConnectionTimeoutError extends DaytonaConnectionError {
-}
-export declare class DaytonaGitAuthFailedError extends DaytonaAuthenticationError {
-}
-export declare class DaytonaGitRepoNotFoundError extends DaytonaNotFoundError {
+export declare class DaytonaAuthorizationError extends DaytonaError {
 }
-export declare class DaytonaGitBranchNotFoundError extends DaytonaNotFoundError {
-}
-export declare class DaytonaGitBranchExistsError extends DaytonaConflictError {
-}
-export declare class DaytonaGitPushRejectedError extends DaytonaConflictError {
-}
-export declare class DaytonaGitDirtyWorktreeError extends DaytonaConflictError {
-}
-export declare class DaytonaGitMergeConflictError extends DaytonaConflictError {
-}
-export declare class DaytonaFileNotFoundError extends DaytonaNotFoundError {
-}
-export declare class DaytonaFileAccessDeniedError extends DaytonaForbiddenError {
-}
-export declare class DaytonaLspServerNotInitializedError extends DaytonaBadRequestError {
-}
-export declare class DaytonaProcessExecutionTimeoutError extends DaytonaTimeoutError {
-}
-export declare class DaytonaProcessNotFoundError extends DaytonaNotFoundError {
-}
-export declare class DaytonaSessionEndedError extends DaytonaGoneError {
-}
-export declare class DaytonaCommandAlreadyCompletedError extends DaytonaGoneError {
+/**
+ * Error thrown when a resource conflict occurs (HTTP 409).
+ *
+ * @example
+ * ```ts
+ * try {
+ *   await daytona.create({ name: 'existing-sandbox' })
+ * } catch (error) {
+ *   if (error instanceof DaytonaConflictError) {
+ *     console.log(error.errorCode)
+ *   }
+ * }
+ * ```
+ */
+export declare class DaytonaConflictError extends DaytonaError {
 }
-export declare class DaytonaA11yUnavailableError extends DaytonaServiceUnavailableError {
+/**
+ * Error thrown when input validation fails (HTTP 400 or client-side validation).
+ *
+ * @example
+ * ```ts
+ * try {
+ *   Image.debianSlim('3.8' as never)
+ * } catch (error) {
+ *   if (error instanceof DaytonaValidationError) {
+ *     console.log(error.message)
+ *   }
+ * }
+ * ```
+ */
+export declare class DaytonaValidationError extends DaytonaError {
 }
-export declare class DaytonaRecordingStillActiveError extends DaytonaConflictError {
+/**
+ * Error thrown when a timeout occurs.
+ *
+ * @example
+ * ```ts
+ * try {
+ *   await sandbox.waitUntilStarted(1)
+ * } catch (error) {
+ *   if (error instanceof DaytonaTimeoutError) {
+ *     console.log(error.message)
+ *   }
+ * }
+ * ```
+ */
+export declare class DaytonaTimeoutError extends DaytonaError {
 }
-export declare class DaytonaRecordingFfmpegNotFoundError extends DaytonaServiceUnavailableError {
+/**
+ * Error thrown when a network connection fails.
+ *
+ * @example
+ * ```ts
+ * try {
+ *   await ptyHandle.waitForConnection()
+ * } catch (error) {
+ *   if (error instanceof DaytonaConnectionError) {
+ *     console.log(error.message)
+ *   }
+ * }
+ * ```
+ */
+export declare class DaytonaConnectionError extends DaytonaError {
 }
-/** Maps an HTTP status code to the corresponding Daytona error class. */
+/**
+ * Maps an HTTP status code to the corresponding Daytona error class.
+ */
 export declare function errorClassFromStatusCode(statusCode?: number): typeof DaytonaError;
 /**
  * Creates the appropriate Daytona error subclass from structured error metadata.
- *
- * Resolution order: (source, code) override -> HTTP status code -> DaytonaError.
  */
-export declare function createDaytonaError(message: string, statusCode?: number, headers?: ResponseHeaders, code?: string, source?: string): DaytonaError;
+export declare function createDaytonaError(message: string, statusCode?: number, headers?: ResponseHeaders, errorCode?: string): DaytonaError;
 /**
- * Creates the appropriate Daytona error subclass from an Axios error. Maps
- * client-side timeouts to DaytonaConnectionTimeoutError, networking failures
- * (no response received) to DaytonaConnectionError, and HTTP responses to
- * the most specific subclass via `createDaytonaError`.
+ * Creates the appropriate Daytona error subclass from an Axios error.
  */
 export declare function createAxiosDaytonaError(error: AxiosError): DaytonaError;
 //# sourceMappingURL=DaytonaError.d.ts.map

package/cjs/errors/DaytonaError.js

@@ -4,201 +4,193 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DaytonaRecordingFfmpegNotFoundError = exports.DaytonaRecordingStillActiveError = exports.DaytonaA11yUnavailableError = exports.DaytonaCommandAlreadyCompletedError = exports.DaytonaSessionEndedError = exports.DaytonaProcessNotFoundError = exports.DaytonaProcessExecutionTimeoutError = exports.DaytonaLspServerNotInitializedError = exports.DaytonaFileAccessDeniedError = exports.DaytonaFileNotFoundError = exports.DaytonaGitMergeConflictError = exports.DaytonaGitDirtyWorktreeError = exports.DaytonaGitPushRejectedError = exports.DaytonaGitBranchExistsError = exports.DaytonaGitBranchNotFoundError = exports.DaytonaGitRepoNotFoundError = exports.DaytonaGitAuthFailedError = exports.DaytonaConnectionTimeoutError = exports.DaytonaConnectionError = exports.DaytonaAuthorizationError = exports.DaytonaValidationError = exports.DaytonaServiceUnavailableError = exports.DaytonaBadGatewayError = exports.DaytonaInternalServerError = exports.DaytonaRateLimitError = exports.DaytonaUnprocessableEntityError = exports.DaytonaGoneError = exports.DaytonaConflictError = exports.DaytonaTimeoutError = exports.DaytonaNotFoundError = exports.DaytonaForbiddenError = exports.DaytonaAuthenticationError = exports.DaytonaBadRequestError = exports.DaytonaError = exports.SOURCE_PROXY = exports.SOURCE_DAEMON = exports.SOURCE_API = void 0;
+exports.DaytonaConnectionError = exports.DaytonaTimeoutError = exports.DaytonaValidationError = exports.DaytonaConflictError = exports.DaytonaAuthorizationError = exports.DaytonaAuthenticationError = exports.DaytonaRateLimitError = exports.DaytonaNotFoundError = exports.DaytonaError = void 0;
 exports.errorClassFromStatusCode = errorClassFromStatusCode;
 exports.createDaytonaError = createDaytonaError;
 exports.createAxiosDaytonaError = createAxiosDaytonaError;
 /**
- * Wire-format `source` identifiers set by the translation layer when a
- * Daytona service stamps them on the wire envelope. `source = undefined`
- * means the response did not carry a structured envelope (treat as opaque).
- */
-exports.SOURCE_API = 'DAYTONA_API';
-exports.SOURCE_DAEMON = 'DAYTONA_DAEMON';
-exports.SOURCE_PROXY = 'DAYTONA_PROXY';
-/**
- * Base error for Daytona SDK. `statusCode` and `code` are populated only
- * for errors translated from a server response. `source` is `undefined`
- * unless the caller (or the translation layer) sets it.
+ * Base error for Daytona SDK.
+ *
+ * @example
+ * ```ts
+ * try {
+ *   await daytona.get('missing-sandbox')
+ * } catch (error) {
+ *   if (error instanceof DaytonaError) {
+ *     console.log(error.statusCode)
+ *     console.log(error.errorCode)
+ *     console.log(error.message)
+ *   }
+ * }
+ * ```
  */
 class DaytonaError extends Error {
+    /** HTTP status code if available */
     statusCode;
-    code;
-    source;
+    /** Machine-readable error code if available */
+    errorCode;
+    /** Response headers if available */
     headers;
-    constructor(message, statusCode, headers, code, source) {
+    constructor(message, statusCode, headers, errorCode) {
         super(message);
         this.name = new.target.name;
         this.statusCode = statusCode;
         this.headers = headers;
-        this.code = code;
-        this.source = source;
+        this.errorCode = errorCode;
     }
 }
 exports.DaytonaError = DaytonaError;
-// HTTP-status classes — one per status code Daytona services emit.
-// Names follow HTTP terminology (BadRequest=400, Forbidden=403).
-class DaytonaBadRequestError extends DaytonaError {
-}
-exports.DaytonaBadRequestError = DaytonaBadRequestError;
-class DaytonaAuthenticationError extends DaytonaError {
-}
-exports.DaytonaAuthenticationError = DaytonaAuthenticationError;
-class DaytonaForbiddenError extends DaytonaError {
-}
-exports.DaytonaForbiddenError = DaytonaForbiddenError;
+/**
+ * Error thrown when a resource is not found (HTTP 404).
+ *
+ * @example
+ * ```ts
+ * try {
+ *   await sandbox.fs.downloadFile('/workspace/missing.txt')
+ * } catch (error) {
+ *   if (error instanceof DaytonaNotFoundError) {
+ *     console.log(error.statusCode)
+ *   }
+ * }
+ * ```
+ */
 class DaytonaNotFoundError extends DaytonaError {
 }
 exports.DaytonaNotFoundError = DaytonaNotFoundError;
-class DaytonaTimeoutError extends DaytonaError {
-}
-exports.DaytonaTimeoutError = DaytonaTimeoutError;
-class DaytonaConflictError extends DaytonaError {
-}
-exports.DaytonaConflictError = DaytonaConflictError;
-class DaytonaGoneError extends DaytonaError {
-}
-exports.DaytonaGoneError = DaytonaGoneError;
-class DaytonaUnprocessableEntityError extends DaytonaError {
-}
-exports.DaytonaUnprocessableEntityError = DaytonaUnprocessableEntityError;
+/**
+ * Error thrown when rate limit is exceeded.
+ *
+ * @example
+ * ```ts
+ * try {
+ *   for await (const sandbox of daytona.list()) {
+ *     console.log(sandbox.id)
+ *   }
+ * } catch (error) {
+ *   if (error instanceof DaytonaRateLimitError) {
+ *     console.log(error.errorCode)
+ *   }
+ * }
+ * ```
+ */
 class DaytonaRateLimitError extends DaytonaError {
 }
 exports.DaytonaRateLimitError = DaytonaRateLimitError;
-class DaytonaInternalServerError extends DaytonaError {
-}
-exports.DaytonaInternalServerError = DaytonaInternalServerError;
-class DaytonaBadGatewayError extends DaytonaError {
-}
-exports.DaytonaBadGatewayError = DaytonaBadGatewayError;
-class DaytonaServiceUnavailableError extends DaytonaError {
-}
-exports.DaytonaServiceUnavailableError = DaytonaServiceUnavailableError;
 /**
- * @deprecated Use {@link DaytonaBadRequestError} instead. Re-exported so
- * existing `catch (err) { if (err instanceof DaytonaValidationError) ... }`
- * blocks keep working.
+ * Error thrown when authentication fails (HTTP 401).
+ *
+ * @example
+ * ```ts
+ * try {
+ *   for await (const sandbox of daytona.list()) {
+ *     console.log(sandbox.id)
+ *   }
+ * } catch (error) {
+ *   if (error instanceof DaytonaAuthenticationError) {
+ *     console.log(error.statusCode)
+ *   }
+ * }
+ * ```
  */
-exports.DaytonaValidationError = DaytonaBadRequestError;
+class DaytonaAuthenticationError extends DaytonaError {
+}
+exports.DaytonaAuthenticationError = DaytonaAuthenticationError;
 /**
- * @deprecated Use {@link DaytonaForbiddenError} instead.
+ * Error thrown when the request is forbidden (HTTP 403).
+ *
+ * @example
+ * ```ts
+ * try {
+ *   await daytona.get('sandbox-without-access')
+ * } catch (error) {
+ *   if (error instanceof DaytonaAuthorizationError) {
+ *     console.log(error.message)
+ *   }
+ * }
+ * ```
  */
-exports.DaytonaAuthorizationError = DaytonaForbiddenError;
-/** Network connection failure (can't connect or mid-request drop). */
-class DaytonaConnectionError extends DaytonaError {
-}
-exports.DaytonaConnectionError = DaytonaConnectionError;
-/** Transport-layer timeout (connect / read). Subclass of DaytonaConnectionError. */
-class DaytonaConnectionTimeoutError extends DaytonaConnectionError {
-}
-exports.DaytonaConnectionTimeoutError = DaytonaConnectionTimeoutError;
-// Domain-specific subclasses. Each inherits from the HTTP-status class that
-// matches its server-side status, so callers can catch either level.
-// --- Git (daemon) ---
-class DaytonaGitAuthFailedError extends DaytonaAuthenticationError {
-}
-exports.DaytonaGitAuthFailedError = DaytonaGitAuthFailedError;
-class DaytonaGitRepoNotFoundError extends DaytonaNotFoundError {
-}
-exports.DaytonaGitRepoNotFoundError = DaytonaGitRepoNotFoundError;
-class DaytonaGitBranchNotFoundError extends DaytonaNotFoundError {
+class DaytonaAuthorizationError extends DaytonaError {
 }
-exports.DaytonaGitBranchNotFoundError = DaytonaGitBranchNotFoundError;
-class DaytonaGitBranchExistsError extends DaytonaConflictError {
-}
-exports.DaytonaGitBranchExistsError = DaytonaGitBranchExistsError;
-class DaytonaGitPushRejectedError extends DaytonaConflictError {
-}
-exports.DaytonaGitPushRejectedError = DaytonaGitPushRejectedError;
-class DaytonaGitDirtyWorktreeError extends DaytonaConflictError {
-}
-exports.DaytonaGitDirtyWorktreeError = DaytonaGitDirtyWorktreeError;
-class DaytonaGitMergeConflictError extends DaytonaConflictError {
-}
-exports.DaytonaGitMergeConflictError = DaytonaGitMergeConflictError;
-// --- Filesystem (daemon) ---
-class DaytonaFileNotFoundError extends DaytonaNotFoundError {
-}
-exports.DaytonaFileNotFoundError = DaytonaFileNotFoundError;
-class DaytonaFileAccessDeniedError extends DaytonaForbiddenError {
-}
-exports.DaytonaFileAccessDeniedError = DaytonaFileAccessDeniedError;
-// --- LSP (daemon) ---
-class DaytonaLspServerNotInitializedError extends DaytonaBadRequestError {
-}
-exports.DaytonaLspServerNotInitializedError = DaytonaLspServerNotInitializedError;
-// --- Process / session (daemon) ---
-class DaytonaProcessExecutionTimeoutError extends DaytonaTimeoutError {
-}
-exports.DaytonaProcessExecutionTimeoutError = DaytonaProcessExecutionTimeoutError;
-class DaytonaProcessNotFoundError extends DaytonaNotFoundError {
-}
-exports.DaytonaProcessNotFoundError = DaytonaProcessNotFoundError;
-class DaytonaSessionEndedError extends DaytonaGoneError {
-}
-exports.DaytonaSessionEndedError = DaytonaSessionEndedError;
-class DaytonaCommandAlreadyCompletedError extends DaytonaGoneError {
-}
-exports.DaytonaCommandAlreadyCompletedError = DaytonaCommandAlreadyCompletedError;
-// --- Computer-use (daemon) ---
-class DaytonaA11yUnavailableError extends DaytonaServiceUnavailableError {
+exports.DaytonaAuthorizationError = DaytonaAuthorizationError;
+/**
+ * Error thrown when a resource conflict occurs (HTTP 409).
+ *
+ * @example
+ * ```ts
+ * try {
+ *   await daytona.create({ name: 'existing-sandbox' })
+ * } catch (error) {
+ *   if (error instanceof DaytonaConflictError) {
+ *     console.log(error.errorCode)
+ *   }
+ * }
+ * ```
+ */
+class DaytonaConflictError extends DaytonaError {
 }
-exports.DaytonaA11yUnavailableError = DaytonaA11yUnavailableError;
-class DaytonaRecordingStillActiveError extends DaytonaConflictError {
+exports.DaytonaConflictError = DaytonaConflictError;
+/**
+ * Error thrown when input validation fails (HTTP 400 or client-side validation).
+ *
+ * @example
+ * ```ts
+ * try {
+ *   Image.debianSlim('3.8' as never)
+ * } catch (error) {
+ *   if (error instanceof DaytonaValidationError) {
+ *     console.log(error.message)
+ *   }
+ * }
+ * ```
+ */
+class DaytonaValidationError extends DaytonaError {
 }
-exports.DaytonaRecordingStillActiveError = DaytonaRecordingStillActiveError;
-class DaytonaRecordingFfmpegNotFoundError extends DaytonaServiceUnavailableError {
+exports.DaytonaValidationError = DaytonaValidationError;
+/**
+ * Error thrown when a timeout occurs.
+ *
+ * @example
+ * ```ts
+ * try {
+ *   await sandbox.waitUntilStarted(1)
+ * } catch (error) {
+ *   if (error instanceof DaytonaTimeoutError) {
+ *     console.log(error.message)
+ *   }
+ * }
+ * ```
+ */
+class DaytonaTimeoutError extends DaytonaError {
 }
-exports.DaytonaRecordingFfmpegNotFoundError = DaytonaRecordingFfmpegNotFoundError;
+exports.DaytonaTimeoutError = DaytonaTimeoutError;
 /**
- * (source, code) → precise DaytonaError subclass. Lookup runs before the
- * HTTP status code fallback, so a domain code wins over the status default.
+ * Error thrown when a network connection fails.
  *
- * Code strings are kept inline (not imported from the generated clients) so
- * tests that virtual-mock the API client modules don't break module init.
- * Drift is caught by the cross-language code-catalog generator + CI checks.
+ * @example
+ * ```ts
+ * try {
+ *   await ptyHandle.waitForConnection()
+ * } catch (error) {
+ *   if (error instanceof DaytonaConnectionError) {
+ *     console.log(error.message)
+ *   }
+ * }
+ * ```
  */
-const CODE_TO_ERROR_CLASS = {
-    // Daemon
-    'DAYTONA_DAEMON|GIT_AUTH_FAILED': DaytonaGitAuthFailedError,
-    'DAYTONA_DAEMON|GIT_REPO_NOT_FOUND': DaytonaGitRepoNotFoundError,
-    'DAYTONA_DAEMON|GIT_BRANCH_NOT_FOUND': DaytonaGitBranchNotFoundError,
-    'DAYTONA_DAEMON|GIT_BRANCH_EXISTS': DaytonaGitBranchExistsError,
-    'DAYTONA_DAEMON|GIT_PUSH_REJECTED': DaytonaGitPushRejectedError,
-    'DAYTONA_DAEMON|GIT_DIRTY_WORKTREE': DaytonaGitDirtyWorktreeError,
-    'DAYTONA_DAEMON|GIT_MERGE_CONFLICT': DaytonaGitMergeConflictError,
-    'DAYTONA_DAEMON|FILE_NOT_FOUND': DaytonaFileNotFoundError,
-    'DAYTONA_DAEMON|FILE_ACCESS_DENIED': DaytonaFileAccessDeniedError,
-    'DAYTONA_DAEMON|LSP_SERVER_NOT_INITIALIZED': DaytonaLspServerNotInitializedError,
-    'DAYTONA_DAEMON|PROCESS_EXECUTION_TIMEOUT': DaytonaProcessExecutionTimeoutError,
-    'DAYTONA_DAEMON|PROCESS_NOT_FOUND': DaytonaProcessNotFoundError,
-    'DAYTONA_DAEMON|SESSION_ENDED': DaytonaSessionEndedError,
-    'DAYTONA_DAEMON|COMMAND_ALREADY_COMPLETED': DaytonaCommandAlreadyCompletedError,
-    'DAYTONA_DAEMON|A11Y_UNAVAILABLE': DaytonaA11yUnavailableError,
-    'DAYTONA_DAEMON|RECORDING_STILL_ACTIVE': DaytonaRecordingStillActiveError,
-    'DAYTONA_DAEMON|RECORDING_FFMPEG_NOT_FOUND': DaytonaRecordingFfmpegNotFoundError,
-};
-function lookupErrorClass(source, code) {
-    if (!code || !source)
-        return undefined;
-    return CODE_TO_ERROR_CLASS[`${source}|${code}`];
+class DaytonaConnectionError extends DaytonaError {
 }
+exports.DaytonaConnectionError = DaytonaConnectionError;
 const STATUS_CODE_TO_ERROR = {
-    400: DaytonaBadRequestError,
+    400: DaytonaValidationError,
     401: DaytonaAuthenticationError,
-    403: DaytonaForbiddenError,
+    403: DaytonaAuthorizationError,
     404: DaytonaNotFoundError,
-    408: DaytonaTimeoutError,
     409: DaytonaConflictError,
-    410: DaytonaGoneError,
-    422: DaytonaUnprocessableEntityError,
     429: DaytonaRateLimitError,
-    500: DaytonaInternalServerError,
-    502: DaytonaBadGatewayError,
-    503: DaytonaServiceUnavailableError,
-    504: DaytonaTimeoutError,
 };
-/** Maps an HTTP status code to the corresponding Daytona error class. */
+/**
+ * Maps an HTTP status code to the corresponding Daytona error class.
+ */
 function errorClassFromStatusCode(statusCode) {
     if (statusCode === undefined) {
         return DaytonaError;
@@ -207,12 +199,10 @@ function errorClassFromStatusCode(statusCode) {
 }
 /**
  * Creates the appropriate Daytona error subclass from structured error metadata.
- *
- * Resolution order: (source, code) override -> HTTP status code -> DaytonaError.
  */
-function createDaytonaError(message, statusCode, headers, code, source) {
-    const ErrorClass = lookupErrorClass(source, code) || errorClassFromStatusCode(statusCode);
-    return new ErrorClass(message, statusCode, headers, code, source);
+function createDaytonaError(message, statusCode, headers, errorCode) {
+    const ErrorClass = errorClassFromStatusCode(statusCode);
+    return new ErrorClass(message, statusCode, headers, errorCode);
 }
 function isAxiosTimeoutError(error) {
     return error.code === 'ECONNABORTED' || error.code === 'ETIMEDOUT' || error.message.includes('timeout of');
@@ -224,10 +214,16 @@ function getAxiosResponseDataObject(error) {
     return error.response.data;
 }
 function extractAxiosErrorCode(responseData) {
-    return typeof responseData?.code === 'string' ? responseData.code : undefined;
-}
-function extractAxiosErrorSource(responseData) {
-    return typeof responseData?.source === 'string' ? responseData.source : undefined;
+    if (typeof responseData?.code === 'string') {
+        return responseData.code;
+    }
+    if (typeof responseData?.error_code === 'string') {
+        return responseData.error_code;
+    }
+    if (typeof responseData?.error === 'string') {
+        return responseData.error;
+    }
+    return undefined;
 }
 function extractAxiosErrorMessage(error) {
     if (isAxiosTimeoutError(error)) {
@@ -247,24 +243,20 @@ function extractAxiosErrorMessage(error) {
     return String(message);
 }
 /**
- * Creates the appropriate Daytona error subclass from an Axios error. Maps
- * client-side timeouts to DaytonaConnectionTimeoutError, networking failures
- * (no response received) to DaytonaConnectionError, and HTTP responses to
- * the most specific subclass via `createDaytonaError`.
+ * Creates the appropriate Daytona error subclass from an Axios error.
  */
 function createAxiosDaytonaError(error) {
     const message = extractAxiosErrorMessage(error);
     const statusCode = error.response?.status;
     const headers = error.response?.headers;
     const responseData = getAxiosResponseDataObject(error);
-    const code = extractAxiosErrorCode(responseData);
-    const source = extractAxiosErrorSource(responseData);
+    const errorCode = extractAxiosErrorCode(responseData);
     if (isAxiosTimeoutError(error)) {
-        return new DaytonaConnectionTimeoutError(message, statusCode, headers, code, source);
+        return new DaytonaTimeoutError(message, statusCode, headers, errorCode);
     }
     if (!error.response && (error.request || error.code)) {
-        return new DaytonaConnectionError(message, statusCode, headers, code, source);
+        return new DaytonaConnectionError(message, statusCode, headers, errorCode);
     }
-    return createDaytonaError(message, statusCode, headers, code, source);
+    return createDaytonaError(message, statusCode, headers, errorCode);
 }
 //# sourceMappingURL=DaytonaError.js.map