@daytonaio/sdk 0.9.0 → 0.10.0

package/dist/Workspace.js

@@ -1,23 +1,75 @@
 "use strict";
+/**
+ * The Daytona SDK core Sandbox functionality.
+ *
+ * Provides the main Workspace class representing a Daytona Sandbox that coordinates file system,
+ * Git, process execution, and LSP functionality. It serves as the central point
+ * for interacting with Daytona Sandboxes.
+ *
+ * The Sandbox must be in a 'started' state before performing operations.
+ *
+ * @module Workspace
+ *
+ * @example
+ * // Create and initialize workspace
+ * const daytona = new Daytona();
+ * const workspace = await daytona.create();
+ *
+ * // File operations
+ * await workspace.fs.uploadFile(
+ *   '/app/config.json',
+ *   new File(['{"setting": "value"}'], 'config.json')
+ * );
+ * const contentBlob = await workspace.fs.downloadFile('/app/config.json');
+ *
+ * // Git operations
+ * await workspace.git.clone('https://github.com/user/repo.git');
+ *
+ * // Process execution
+ * const response = await workspace.process.executeCommand('ls -la');
+ * console.log(response.result);
+ *
+ * // LSP functionality
+ * const lsp = workspace.createLspServer('typescript', '/workspace/project');
+ * await lsp.didOpen('/workspace/project/src/index.ts');
+ * const completions = await lsp.completions('/workspace/project/src/index.ts', {
+ *   line: 10,
+ *   character: 15
+ * });
+ * console.log(completions);
+ *
+ */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Workspace = void 0;
 const FileSystem_1 = require("./FileSystem");
 const Git_1 = require("./Git");
-//  import { LspLanguageId, LspServer } from './LspServer'
 const Process_1 = require("./Process");
 const LspServer_1 = require("./LspServer");
+const DaytonaError_1 = require("./errors/DaytonaError");
 /**
- * Represents a Daytona workspace instance with file system, git, and process management capabilities
- * @class Workspace
+ * Represents a Daytona Sandbox.
+ *
+ * A Sandbox provides file system operations, Git operations, process execution,
+ * and LSP functionality. It serves as the main interface for interacting with
+ * a Daytona workspace.
+ *
+ * @property {string} id - Unique identifier for the Sandbox
+ * @property {WorkspaceInstance} instance - The underlying Sandbox instance
+ * @property {WorkspaceApi} workspaceApi - API client for Sandbox operations
+ * @property {ToolboxApi} toolboxApi - API client for toolbox operations
+ * @property {WorkspaceCodeToolbox} codeToolbox - Language-specific toolbox implementation
+ * @property {FileSystem} fs - File system operations interface
+ * @property {Git} git - Git operations interface
+ * @property {Process} process - Process execution interface
  */
 class Workspace {
     /**
-     * Creates a new workspace instance
-     * @param {string} id - Unique identifier for the workspace
-     * @param {WorkspaceInstance} instance - The underlying workspace instance
-     * @param {WorkspaceApi} workspaceApi - API client for workspace operations
-     * @param {ToolboxApi} toolboxApi - API client for toolbox operations
+     * Creates a new Sandbox instance
      *
+     * @param {string} id - Unique identifier for the Sandbox
+     * @param {WorkspaceInstance} instance - The underlying Sandbox instance
+     * @param {WorkspaceApi} workspaceApi - API client for Sandbox operations
+     * @param {ToolboxApi} toolboxApi - API client for toolbox operations
      * @param {WorkspaceCodeToolbox} codeToolbox - Language-specific toolbox implementation
      */
     constructor(id, instance, workspaceApi, toolboxApi, codeToolbox) {
@@ -31,102 +83,200 @@ class Workspace {
         this.process = new Process_1.Process(this.codeToolbox, this.toolboxApi, instance);
     }
     /**
-     * Gets the root directory path of the workspace
-     * @returns {Promise<string>} The absolute path to the workspace root
+     * Gets the root directory path of the Sandbox.
+     *
+     * @returns {Promise<string | undefined>} The absolute path to the Sandbox root directory
+     *
+     * @example
+     * const rootDir = await workspace.getWorkspaceRootDir();
+     * console.log(`Workspace root: ${rootDir}`);
      */
     async getWorkspaceRootDir() {
         const response = await this.toolboxApi.getProjectDir(this.instance.id);
         return response.data.dir;
     }
     /**
-     * Creates a new Language Server Protocol (LSP) server instance
-     * @param {LspLanguageId} languageId - The language server type
-     * @param {string} pathToProject - Path to the project root
-     * @returns {LspServer} A new LSP server instance
+     * Creates a new Language Server Protocol (LSP) server instance.
+     *
+     * The LSP server provides language-specific features like code completion,
+     * diagnostics, and more.
+     *
+     * @param {LspLanguageId} languageId - The language server type (e.g., "typescript")
+     * @param {string} pathToProject - Absolute path to the project root directory
+     * @returns {LspServer} A new LSP server instance configured for the specified language
+     *
+     * @example
+     * const lsp = workspace.createLspServer('typescript', '/workspace/project');
      */
     createLspServer(languageId, pathToProject) {
         return new LspServer_1.LspServer(languageId, pathToProject, this.toolboxApi, this.instance);
     }
     /**
-     * Sets labels for the workspace
-     * @param {Record<string, string>} labels - The labels to set
+     * Sets labels for the Sandbox.
+     *
+     * Labels are key-value pairs that can be used to organize and identify Sandboxes.
+     *
+     * @param {Record<string, string>} labels - Dictionary of key-value pairs representing Sandbox labels
+     * @returns {Promise<void>}
+     *
+     * @example
+     * // Set workspace labels
+     * await workspace.setLabels({
+     *   project: 'my-project',
+     *   environment: 'development',
+     *   team: 'backend'
+     * });
      */
     async setLabels(labels) {
         await this.workspaceApi.replaceLabels(this.instance.id, { labels });
     }
     /**
-     * Starts the workspace
+     * Start the Sandbox.
+     *
+     * This method starts the Sandbox and waits for it to be ready.
+     *
+     * @param {number} [timeout] - Maximum time to wait in seconds. 0 means no timeout.
+     *                            Defaults to 60-second timeout.
      * @returns {Promise<void>}
+     * @throws {DaytonaError} - `DaytonaError` - If Sandbox fails to start or times out
+     *
+     * @example
+     * const workspace = await daytona.getCurrentWorkspace('my-workspace');
+     * await workspace.start(40);  // Wait up to 40 seconds
+     * console.log('Workspace started successfully');
      */
-    async start() {
-        await this.workspaceApi.startWorkspace(this.instance.id);
-        await this.waitUntilStarted();
+    async start(timeout = 60) {
+        if (timeout < 0) {
+            throw new DaytonaError_1.DaytonaError('Timeout must be a non-negative number');
+        }
+        const startTime = Date.now();
+        await this.workspaceApi.startWorkspace(this.instance.id, { timeout: timeout * 1000 });
+        const timeElapsed = Date.now() - startTime;
+        await this.waitUntilStarted(timeout ? timeout - (timeElapsed / 1000) : 0);
     }
     /**
-     * Stops the workspace
+     * Stops the Sandbox.
+     *
+     * This method stops the Sandbox and waits for it to be fully stopped.
+     *
+     * @param {number} [timeout] - Maximum time to wait in seconds. 0 means no timeout.
+     *                            Defaults to 60-second timeout.
      * @returns {Promise<void>}
+     *
+     * @example
+     * const workspace = await daytona.getCurrentWorkspace('my-workspace');
+     * await workspace.stop();
+     * console.log('Workspace stopped successfully');
      */
-    async stop() {
-        await this.workspaceApi.stopWorkspace(this.instance.id);
-        await this.waitUntilStopped();
+    async stop(timeout = 60) {
+        if (timeout < 0) {
+            throw new DaytonaError_1.DaytonaError('Timeout must be a non-negative number');
+        }
+        const startTime = Date.now();
+        await this.workspaceApi.stopWorkspace(this.instance.id, { timeout: timeout * 1000 });
+        const timeElapsed = Date.now() - startTime;
+        await this.waitUntilStopped(timeout ? timeout - (timeElapsed / 1000) : 0);
     }
     /**
-     * Deletes the workspace
+     * Deletes the Sandbox.
      * @returns {Promise<void>}
      */
     async delete() {
         await this.workspaceApi.deleteWorkspace(this.instance.id, true);
     }
-    async waitUntilStarted() {
-        const maxAttempts = 600;
-        let attempts = 0;
-        while (attempts < maxAttempts) {
+    /**
+     * Waits for the Sandbox to reach the 'started' state.
+     *
+     * This method polls the Sandbox status until it reaches the 'started' state
+     * or encounters an error.
+     *
+     * @param {number} [timeout] - Maximum time to wait in seconds. 0 means no timeout.
+     *                               Defaults to 60 seconds.
+     * @returns {Promise<void>}
+     * @throws {DaytonaError} - `DaytonaError` - If the workspace ends up in an error state or fails to start within the timeout period.
+     */
+    async waitUntilStarted(timeout = 60) {
+        if (timeout < 0) {
+            throw new DaytonaError_1.DaytonaError('Timeout must be a non-negative number');
+        }
+        const checkInterval = 100; // Wait 100 ms between checks
+        const startTime = Date.now();
+        while (timeout === 0 || (Date.now() - startTime) < (timeout * 1000)) {
             const response = await this.workspaceApi.getWorkspace(this.id);
             const state = response.data.state;
             if (state === 'started') {
                 return;
             }
             if (state === 'error') {
-                throw new Error(`Workspace failed to start with status: ${status}`);
+                throw new DaytonaError_1.DaytonaError(`Workspace failed to start with status: ${state}, error reason: ${response.data.errorReason}`);
             }
-            await new Promise(resolve => setTimeout(resolve, 100)); // Wait 100 ms between checks
-            attempts++;
+            await new Promise(resolve => setTimeout(resolve, checkInterval));
         }
-        throw new Error('Workspace failed to become ready within the timeout period');
+        throw new DaytonaError_1.DaytonaError(`Workspace failed to become ready within the timeout period`);
     }
-    async waitUntilStopped() {
-        const maxAttempts = 600;
-        let attempts = 0;
-        while (attempts < maxAttempts) {
+    /**
+     * Wait for Sandbox to reach 'stopped' state.
+     *
+     * This method polls the Sandbox status until it reaches the 'stopped' state
+     * or encounters an error.
+     *
+     * @param {number} [timeout] - Maximum time to wait in seconds. 0 means no timeout.
+     *                               Defaults to 60 seconds.
+     * @returns {Promise<void>}
+     * @throws {DaytonaError} - `DaytonaError` - If the workspace fails to stop within the timeout period.
+     */
+    async waitUntilStopped(timeout = 60) {
+        if (timeout < 0) {
+            throw new DaytonaError_1.DaytonaError('Timeout must be a non-negative number');
+        }
+        const checkInterval = 100; // Wait 100 ms between checks
+        const startTime = Date.now();
+        while (timeout === 0 || (Date.now() - startTime) < (timeout * 1000)) {
             const response = await this.workspaceApi.getWorkspace(this.id);
             const state = response.data.state;
             if (state === 'stopped') {
                 return;
             }
             if (state === 'error') {
-                throw new Error(`Workspace failed to stop with status: ${status}`);
+                throw new DaytonaError_1.DaytonaError(`Workspace failed to stop with status: ${state}, error reason: ${response.data.errorReason}`);
             }
-            await new Promise(resolve => setTimeout(resolve, 100)); // Wait 100 ms between checks
-            attempts++;
+            await new Promise(resolve => setTimeout(resolve, checkInterval));
         }
-        throw new Error('Workspace failed to become stopped within the timeout period');
+        throw new DaytonaError_1.DaytonaError('Workspace failed to become stopped within the timeout period');
     }
     /**
-     * Get structured information about the workspace
-     * @returns {Promise<WorkspaceInfo>} Structured workspace information
+     * Gets structured information about the Sandbox.
+     *
+     * @returns {Promise<WorkspaceInfo>} Detailed information about the Sandbox including its
+     *                                   configuration, resources, and current state
+     *
+     * @example
+     * const info = await workspace.info();
+     * console.log(`Workspace ${info.name}:`);
+     * console.log(`State: ${info.state}`);
+     * console.log(`Resources: ${info.resources.cpu} CPU, ${info.resources.memory} RAM`);
      */
     async info() {
-        var _a;
         const response = await this.workspaceApi.getWorkspace(this.id);
         const instance = response.data;
+        return Workspace.toWorkspaceInfo(instance);
+    }
+    /**
+     * Converts an API workspace instance to a WorkspaceInfo object.
+     *
+     * @param {ApiWorkspace} instance - The API workspace instance to convert
+     * @returns {WorkspaceInfo} The converted WorkspaceInfo object
+     */
+    static toWorkspaceInfo(instance) {
+        var _a, _b, _c, _d, _e;
         const providerMetadata = JSON.parse(((_a = instance.info) === null || _a === void 0 ? void 0 : _a.providerMetadata) || '{}');
+        var resourcesData = providerMetadata.resources || providerMetadata;
         // Extract resources with defaults
-        const resourcesData = providerMetadata.resources || {};
         const resources = {
             cpu: String(resourcesData.cpu || '1'),
             gpu: resourcesData.gpu ? String(resourcesData.gpu) : null,
-            memory: String(resourcesData.memory || '2Gi'),
-            disk: String(resourcesData.disk || '10Gi')
+            memory: `${(_b = resourcesData.memory) !== null && _b !== void 0 ? _b : 2}Gi`,
+            disk: `${(_c = resourcesData.disk) !== null && _c !== void 0 ? _c : 10}Gi`
         };
         return {
             id: instance.id,
@@ -143,8 +293,65 @@ class Workspace {
             snapshotState: providerMetadata.snapshotState || null,
             snapshotStateCreatedAt: providerMetadata.snapshotStateCreatedAt
                 ? new Date(providerMetadata.snapshotStateCreatedAt)
-                : null
+                : null,
+            nodeDomain: providerMetadata.nodeDomain || '',
+            region: providerMetadata.region || '',
+            class: providerMetadata.class || '',
+            updatedAt: providerMetadata.updatedAt || '',
+            lastSnapshot: providerMetadata.lastSnapshot || null,
+            autoStopInterval: providerMetadata.autoStopInterval || 0,
+            created: ((_d = instance.info) === null || _d === void 0 ? void 0 : _d.created) || '',
+            providerMetadata: (_e = instance.info) === null || _e === void 0 ? void 0 : _e.providerMetadata,
         };
     }
+    /**
+     * Set the auto-stop interval for the Sandbox.
+     *
+     * The Sandbox will automatically stop after being idle (no new events) for the specified interval.
+     * Events include any state changes or interactions with the Sandbox through the sdk.
+     * Interactions using Sandbox Previews are not included.
+     *
+     * @param {number} interval - Number of minutes of inactivity before auto-stopping.
+     *                           Set to 0 to disable auto-stop. Default is 15 minutes.
+     * @returns {Promise<void>}
+     * @throws {DaytonaError} - `DaytonaError` - If interval is not a non-negative integer
+     *
+     * @example
+     * // Auto-stop after 1 hour
+     * await workspace.setAutostopInterval(60);
+     * // Or disable auto-stop
+     * await workspace.setAutostopInterval(0);
+     */
+    async setAutostopInterval(interval) {
+        if (!Number.isInteger(interval) || interval < 0) {
+            throw new DaytonaError_1.DaytonaError('autoStopInterval must be a non-negative integer');
+        }
+        await this.workspaceApi.setAutostopInterval(this.id, interval);
+        this.instance.autoStopInterval = interval;
+    }
+    /**
+     * Gets the preview link for the workspace at a specific port. If the port is not open, it will open it and return the link.
+     * @param {number} port - The port to open the preview link on
+     * @returns {string} The preview link for the workspace at the specified port
+     * @throws {DaytonaError} If the node domain is not found in the provider metadata
+     */
+    getPreviewLink(port) {
+        var _a;
+        const providerMetadata = JSON.parse(((_a = this.instance.info) === null || _a === void 0 ? void 0 : _a.providerMetadata) || '{}');
+        const nodeDomain = providerMetadata.nodeDomain || '';
+        if (!nodeDomain) {
+            throw new DaytonaError_1.DaytonaError("Cannot get preview link. Node domain not found in provider metadata. Please contact support.");
+        }
+        return `https://${port}-${this.id}.${nodeDomain}`;
+    }
+    /**
+     * Archives the workspace, making it inactive and preserving its state. When sandboxes are archived, the entire filesystem
+     * state is moved to cost-effective object storage, making it possible to keep sandboxes available for an extended period.
+     * The tradeoff between archived and stopped states is that starting an archived sandbox takes more time, depending on its size.
+     * Workspace must be stopped before archiving.
+     */
+    async archive() {
+        await this.workspaceApi.archiveWorkspace(this.id);
+    }
 }
 exports.Workspace = Workspace;

package/dist/code-toolbox/WorkspacePythonCodeToolbox.d.ts

@@ -1,5 +1,6 @@
 import { WorkspaceCodeToolbox } from '../Workspace';
+import { CodeRunParams } from '../Process';
 export declare class WorkspacePythonCodeToolbox implements WorkspaceCodeToolbox {
     getDefaultImage(): string;
-    getRunCommand(code: string): string;
+    getRunCommand(code: string, params?: CodeRunParams): string;
 }

package/dist/code-toolbox/WorkspacePythonCodeToolbox.js

@@ -5,9 +5,11 @@ class WorkspacePythonCodeToolbox {
     getDefaultImage() {
         return 'daytonaio/sdk-python:v0.49.0-2';
     }
-    getRunCommand(code) {
+    getRunCommand(code, params) {
         const base64Code = Buffer.from(code).toString('base64');
-        return `python3 -c "exec(__import__('base64').b64decode('${base64Code}').decode())"`;
+        const envVars = (params === null || params === void 0 ? void 0 : params.env) ? Object.entries(params.env).map(([key, value]) => `${key}='${value}'`).join(' ') : '';
+        const argv = (params === null || params === void 0 ? void 0 : params.argv) ? params.argv.join(' ') : '';
+        return `sh -c '${envVars} python3 -c "exec(__import__(\\\"base64\\\").b64decode(\\\"${base64Code}\\\").decode())" ${argv}'`;
     }
 }
 exports.WorkspacePythonCodeToolbox = WorkspacePythonCodeToolbox;

package/dist/code-toolbox/WorkspaceTsCodeToolbox.d.ts

@@ -1,5 +1,6 @@
 import { WorkspaceCodeToolbox } from '../Workspace';
+import { CodeRunParams } from '../Process';
 export declare class WorkspaceTsCodeToolbox implements WorkspaceCodeToolbox {
     getDefaultImage(): string;
-    getRunCommand(code: string): string;
+    getRunCommand(code: string, params?: CodeRunParams): string;
 }

package/dist/code-toolbox/WorkspaceTsCodeToolbox.js

@@ -5,9 +5,11 @@ class WorkspaceTsCodeToolbox {
     getDefaultImage() {
         return 'daytonaio/sdk-typescript:v0.49.0-3';
     }
-    getRunCommand(code) {
+    getRunCommand(code, params) {
         const base64Code = Buffer.from(code).toString('base64');
-        return `python3 -c "exec(__import__('base64').b64decode('${base64Code}').decode())"`;
+        const envVars = (params === null || params === void 0 ? void 0 : params.env) ? Object.entries(params.env).map(([key, value]) => `${key}='${value}'`).join(' ') : '';
+        const argv = (params === null || params === void 0 ? void 0 : params.argv) ? params.argv.join(' ') : '';
+        return `sh -c 'echo ${base64Code} | base64 --decode | ${envVars} npx ts-node -O "{\\\"module\\\":\\\"CommonJS\\\"}" -e "$(cat)" x ${argv} 2>&1 | grep -vE "npm notice|npm warn exec"'`;
     }
 }
 exports.WorkspaceTsCodeToolbox = WorkspaceTsCodeToolbox;

package/dist/errors/DaytonaError.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @module Errors
+ */
+/**
+ * Base error for Daytona SDK.
+ */
+export declare class DaytonaError extends Error {
+}

package/dist/errors/DaytonaError.js

@@ -0,0 +1,12 @@
+"use strict";
+/**
+ * @module Errors
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DaytonaError = void 0;
+/**
+ * Base error for Daytona SDK.
+ */
+class DaytonaError extends Error {
+}
+exports.DaytonaError = DaytonaError;

package/dist/index.d.ts

@@ -1,8 +1,12 @@
 export { Daytona } from './Daytona';
 export type { DaytonaConfig, CreateWorkspaceParams } from './Daytona';
+export { CodeLanguage } from './Daytona';
 export { Workspace } from './Workspace';
 export type { WorkspaceCodeToolbox } from './Workspace';
 export { FileSystem } from './FileSystem';
 export { Git } from './Git';
 export { Process } from './Process';
+export { LspLanguageId } from './LspServer';
+export { DaytonaError } from './errors/DaytonaError';
 export type { FileInfo, Match, ReplaceResult, SearchFilesResponse, GitStatus, ListBranchResponse, ExecuteResponse, } from '@daytonaio/api-client';
+export { WorkspaceState, CreateWorkspaceTargetEnum as WorkspaceTargetRegion } from '@daytonaio/api-client';

package/dist/index.js

@@ -1,8 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Process = exports.Git = exports.FileSystem = exports.Workspace = exports.Daytona = void 0;
+exports.WorkspaceTargetRegion = exports.WorkspaceState = exports.DaytonaError = exports.LspLanguageId = exports.Process = exports.Git = exports.FileSystem = exports.Workspace = exports.CodeLanguage = exports.Daytona = void 0;
 var Daytona_1 = require("./Daytona");
 Object.defineProperty(exports, "Daytona", { enumerable: true, get: function () { return Daytona_1.Daytona; } });
+var Daytona_2 = require("./Daytona");
+Object.defineProperty(exports, "CodeLanguage", { enumerable: true, get: function () { return Daytona_2.CodeLanguage; } });
 var Workspace_1 = require("./Workspace");
 Object.defineProperty(exports, "Workspace", { enumerable: true, get: function () { return Workspace_1.Workspace; } });
 var FileSystem_1 = require("./FileSystem");
@@ -11,3 +13,12 @@ var Git_1 = require("./Git");
 Object.defineProperty(exports, "Git", { enumerable: true, get: function () { return Git_1.Git; } });
 var Process_1 = require("./Process");
 Object.defineProperty(exports, "Process", { enumerable: true, get: function () { return Process_1.Process; } });
+var LspServer_1 = require("./LspServer");
+Object.defineProperty(exports, "LspLanguageId", { enumerable: true, get: function () { return LspServer_1.LspLanguageId; } });
+// export { LspServer } from './LspServer'
+// export type { LspLanguageId, Position } from './LspServer'
+var DaytonaError_1 = require("./errors/DaytonaError");
+Object.defineProperty(exports, "DaytonaError", { enumerable: true, get: function () { return DaytonaError_1.DaytonaError; } });
+var api_client_1 = require("@daytonaio/api-client");
+Object.defineProperty(exports, "WorkspaceState", { enumerable: true, get: function () { return api_client_1.WorkspaceState; } });
+Object.defineProperty(exports, "WorkspaceTargetRegion", { enumerable: true, get: function () { return api_client_1.CreateWorkspaceTargetEnum; } });

package/dist/utils/Axios.d.ts

@@ -0,0 +1,6 @@
+import { AxiosInstance } from 'axios';
+export declare class Axios {
+    private static instance;
+    private constructor();
+    static getInstance(): AxiosInstance;
+}

package/dist/utils/Axios.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Axios = void 0;
+const axios_1 = __importDefault(require("axios"));
+class Axios {
+    constructor() { }
+    static getInstance() {
+        if (!Axios.instance) {
+            Axios.instance = axios_1.default.create();
+            Axios.instance.interceptors.response.use((response) => {
+                return response;
+            }, (error) => {
+                var _a, _b, _c;
+                const errorMessage = ((_b = (_a = error.response) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.message) ||
+                    ((_c = error.response) === null || _c === void 0 ? void 0 : _c.data) ||
+                    error.message ||
+                    String(error);
+                throw new Error(errorMessage);
+                // return Promise.reject(errorMessage);
+            });
+        }
+        return Axios.instance;
+    }
+}
+exports.Axios = Axios;

package/dist/utils/errors.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Helper method to parse API errors and extract meaningful messages.
+ * Checks if error is an AxiosError and has response data with a message field.
+ * If it does, it will return the message from the response.
+ * If it doesn't, it will return the original error message.
+ *
+ * @param error - The error to parse
+ * @returns A formatted error message string
+ */
+export declare function parseApiError(error: unknown): string;

package/dist/utils/errors.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseApiError = parseApiError;
+const axios_1 = require("axios");
+/**
+ * Helper method to parse API errors and extract meaningful messages.
+ * Checks if error is an AxiosError and has response data with a message field.
+ * If it does, it will return the message from the response.
+ * If it doesn't, it will return the original error message.
+ *
+ * @param error - The error to parse
+ * @returns A formatted error message string
+ */
+function parseApiError(error) {
+    var _a;
+    try {
+        // Handle Axios errors
+        if (error instanceof axios_1.AxiosError) {
+            // Check if we have response data
+            if ((_a = error.response) === null || _a === void 0 ? void 0 : _a.data) {
+                const errorData = error.response.data;
+                // If errorData is an object with a message field
+                if (typeof errorData === 'object' && errorData !== null) {
+                    if ('message' in errorData && typeof errorData.message === 'string') {
+                        return errorData.message;
+                    }
+                    // If no message field, we can stringify the error data
+                    return JSON.stringify(errorData);
+                }
+            }
+            return error.message;
+        }
+    }
+    catch (_b) { }
+    return String(error);
+}

package/dist/utils/timeout.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Custom error class for timeout-related exceptions
+ * @extends Error
+ */
+declare class TimeoutError extends Error {
+    constructor(message?: string);
+    /**
+     * Checks if an error is a TimeoutError
+     * @param error - The error to check
+     */
+    static isTimeoutError(error: unknown): error is TimeoutError;
+}
+/**
+ * Configuration options for timeout behavior
+ */
+interface TimeoutOptions {
+    /** Timeout duration in seconds */
+    timeout: number;
+    /** Whether the operation supports abortion */
+    abortable?: boolean;
+    /** Optional callback to execute on timeout */
+    onTimeout?: () => void;
+    /** Optional custom error message for TimeoutError */
+    errorMessage?: string;
+}
+/**
+ * Wraps a promise with a timeout mechanism
+ * @template T - The type of the promise result
+ * @param promise - The promise to wrap
+ * @param options - Timeout configuration options
+ * @returns A promise that will reject if the timeout is exceeded
+ * @throws {TimeoutError} When the operation times out
+ */
+declare function withTimeout<T>(promise: Promise<T>, options: TimeoutOptions): Promise<T>;
+export { withTimeout, TimeoutError };