@devpad/api 1.0.1

package/dist/api-client.js

@@ -0,0 +1,407 @@
+import { ApiClient as HttpClient } from "./request";
+import { wrap } from "./result";
+/**
+ * API client with Result-wrapped operations for clean error handling
+ * All methods return Result<T, name> types with context-aware property names
+ */
+export class ApiClient {
+    constructor(options) {
+        /**
+         * Auth namespace with Result-wrapped operations
+         */
+        this.auth = {
+            /**
+             * Get current session information
+             */
+            session: () => wrap(() => this.clients.auth.get("/auth/session"), "session"),
+            /**
+             * Login (redirect to OAuth)
+             */
+            login: () => wrap(() => this.clients.auth.get("/auth/login"), "result"),
+            /**
+             * Logout
+             */
+            logout: () => wrap(() => this.clients.auth.get("/auth/logout"), "result"),
+            /**
+             * API key management
+             */
+            keys: {
+                /**
+                 * List all API keys
+                 */
+                list: () => wrap(() => this.clients.auth.get("/auth/keys"), "keys"),
+                /**
+                 * Generate a new API key
+                 */
+                create: (name) => wrap(() => this.clients.auth.post("/auth/keys", { body: name ? { name } : {} }), "key"),
+                /**
+                 * Revoke an API key
+                 */
+                revoke: (key_id) => wrap(() => this.clients.auth.delete(`/auth/keys/${key_id}`), "result"),
+                /**
+                 * Remove an API key (alias for revoke)
+                 */
+                remove: (key_id) => wrap(() => this.clients.auth.delete(`/auth/keys/${key_id}`), "result"),
+            },
+        };
+        /**
+         * Projects namespace with Result-wrapped operations
+         */
+        this.projects = {
+            /**
+             * List projects with optional filtering
+             */
+            list: (filters) => wrap(() => this.clients.projects.get(filters?.private === false ? "/projects/public" : "/projects"), "projects"),
+            /**
+             * Get project map
+             */
+            map: async (filters) => wrap(async () => {
+                const { projects, error } = await this.projects.list(filters);
+                if (error)
+                    throw new Error(error.message);
+                return projects.reduce((acc, project) => {
+                    acc[project.project_id] = project;
+                    return acc;
+                }, {});
+            }, "project_map"),
+            /**
+             * Get project by ID
+             */
+            find: (id) => wrap(() => this.clients.projects.get("/projects", { query: { id } }), "project"),
+            /**
+             * Get project by name
+             */
+            getByName: (name) => wrap(() => this.clients.projects.get("/projects", { query: { name } }), "project"),
+            /**
+             * Get project by ID (throws if not found)
+             */
+            getById: (id) => wrap(() => this.clients.projects.get("/projects", { query: { id } }), "project"),
+            /**
+             * Create a new project
+             */
+            create: (data) => wrap(() => this.clients.projects.patch("/projects", { body: data }), "project"),
+            /**
+             * Update an existing project
+             */
+            update: async (idOrData, changes) => wrap(async () => {
+                // Handle backward compatibility: update(data)
+                if (typeof idOrData === "object" && idOrData.id) {
+                    return this.clients.projects.patch("/projects", { body: idOrData });
+                }
+                // Handle new clean interface: update(id, changes)
+                const id = idOrData;
+                if (!changes) {
+                    throw new Error("Changes parameter required for update");
+                }
+                // Fetch the existing project to get current values
+                const { project, error } = await this.projects.find(id);
+                if (error)
+                    throw new Error(error.message);
+                if (!project)
+                    throw new Error(`Project with id ${id} not found`);
+                // Merge changes with existing project data
+                const updateData = {
+                    id: project.id,
+                    project_id: project.project_id,
+                    owner_id: project.owner_id,
+                    name: project.name,
+                    description: project.description,
+                    specification: project.specification,
+                    repo_url: project.repo_url,
+                    repo_id: project.repo_id,
+                    icon_url: project.icon_url,
+                    status: project.status,
+                    deleted: project.deleted,
+                    link_url: project.link_url,
+                    link_text: project.link_text,
+                    visibility: project.visibility,
+                    current_version: project.current_version,
+                    ...changes,
+                };
+                return this.clients.projects.patch("/projects", { body: updateData });
+            }, "project"),
+            /**
+             * Project configuration operations
+             */
+            config: {
+                /**
+                 * Get project configuration
+                 */
+                load: (project_id) => wrap(() => this.clients.projects.get("/projects/config", { query: { project_id } }), "config"),
+                /**
+                 * Save project configuration
+                 */
+                save: (request) => wrap(() => this.clients.projects.patch("/projects/save_config", { body: request }), "result"),
+            },
+            /**
+             * Scanning operations
+             */
+            scan: {
+                /**
+                 * Update scan status
+                 */
+                updateStatus: (project_id, data) => wrap(() => this.clients.projects.post(`/projects/${project_id}/scan/status`, { body: data }), "result"),
+            },
+            /**
+             * Get project history
+             */
+            history: (project_id) => wrap(() => this.clients.projects.get(`/projects/${project_id}/history`), "history"),
+            /**
+             * Legacy methods (keeping for compatibility)
+             */
+            upsert: (data) => wrap(() => this.clients.projects.patch("/projects", { body: data }), "project"),
+            /**
+             * Fetch project specification from GitHub
+             */
+            specification: (project_id) => wrap(() => this.clients.projects.get("/projects/fetch_spec", { query: { project_id } }), "specification"),
+            /**
+             * Delete project (soft delete)
+             */
+            deleteProject: (project) => wrap(() => this.clients.projects.patch("/projects", { body: { ...project, deleted: true } }), "result"),
+        };
+        /**
+         * Milestones namespace with Result-wrapped operations
+         */
+        this.milestones = {
+            /**
+             * List milestones for authenticated user
+             */
+            list: () => wrap(() => this.clients.milestones.get("/milestones"), "milestones"),
+            /**
+             * Get milestones by project ID
+             */
+            getByProject: (project_id) => wrap(() => this.clients.milestones.get(`/projects/${project_id}/milestones`), "milestones"),
+            /**
+             * Get milestone by ID
+             */
+            find: (id) => wrap(async () => {
+                try {
+                    return await this.clients.milestones.get(`/milestones/${id}`);
+                }
+                catch (error) {
+                    return null;
+                }
+            }, "milestone"),
+            /**
+             * Create new milestone
+             */
+            create: (data) => wrap(() => this.clients.milestones.post("/milestones", { body: data }), "milestone"),
+            /**
+             * Update milestone
+             */
+            update: async (id, data) => wrap(async () => {
+                // Fetch the existing milestone to get required fields
+                const { milestone, error } = await this.milestones.find(id);
+                if (error)
+                    throw new Error(error.message);
+                if (!milestone)
+                    throw new Error(`Milestone with id ${id} not found`);
+                // Merge changes with existing milestone data
+                const updateData = {
+                    id: milestone.id,
+                    project_id: milestone.project_id,
+                    name: data.name ?? milestone.name,
+                    description: data.description ?? milestone.description,
+                    target_time: data.target_time ?? milestone.target_time,
+                    target_version: data.target_version ?? milestone.target_version,
+                };
+                return this.clients.milestones.patch(`/milestones/${id}`, { body: updateData });
+            }, "milestone"),
+            /**
+             * Delete milestone (soft delete)
+             */
+            delete: (id) => wrap(() => this.clients.milestones.delete(`/milestones/${id}`), "result"),
+            /**
+             * Get goals for a milestone
+             */
+            goals: (id) => wrap(() => this.clients.milestones.get(`/milestones/${id}/goals`), "goals"),
+        };
+        /**
+         * Goals namespace with Result-wrapped operations
+         */
+        this.goals = {
+            /**
+             * List goals for authenticated user
+             */
+            list: () => wrap(() => this.clients.goals.get("/goals"), "goals"),
+            /**
+             * Get goal by ID
+             */
+            find: (id) => wrap(() => this.clients.goals.get(`/goals/${id}`), "goal"),
+            /**
+             * Create new goal
+             */
+            create: (data) => wrap(() => this.clients.goals.post("/goals", { body: data }), "goal"),
+            /**
+             * Update goal
+             */
+            update: async (id, data) => wrap(async () => {
+                // Fetch the existing goal to get required fields
+                const { goal, error } = await this.goals.find(id);
+                if (error)
+                    throw new Error(error.message);
+                if (!goal)
+                    throw new Error(`Goal with id ${id} not found`);
+                // Merge changes with existing goal data
+                const updateData = {
+                    id: goal.id,
+                    milestone_id: goal.milestone_id,
+                    name: data.name ?? goal.name,
+                    description: data.description ?? goal.description,
+                    target_time: data.target_time ?? goal.target_time,
+                };
+                return this.clients.goals.patch(`/goals/${id}`, { body: updateData });
+            }, "goal"),
+            /**
+             * Delete goal (soft delete)
+             */
+            delete: (id) => wrap(() => this.clients.goals.delete(`/goals/${id}`), "result"),
+        };
+        /**
+         * Tasks namespace with Result-wrapped operations
+         */
+        this.tasks = {
+            /**
+             * List tasks with optional filtering
+             */
+            list: (filters) => wrap(() => {
+                const query = {};
+                if (filters?.project_id)
+                    query.project = filters.project_id;
+                if (filters?.tag_id)
+                    query.tag = filters.tag_id;
+                return this.clients.tasks.get("/tasks", Object.keys(query).length > 0 ? { query } : {});
+            }, "tasks"),
+            /**
+             * Get task by ID
+             */
+            find: (id) => wrap(() => this.clients.tasks.get("/tasks", { query: { id } }), "task"),
+            /**
+             * Get tasks by project ID
+             */
+            getByProject: (project_id) => wrap(() => this.clients.tasks.get(`/tasks`, { query: { project: project_id } }), "tasks"),
+            /**
+             * Create a new task
+             */
+            create: (data) => wrap(() => this.clients.tasks.patch("/tasks", { body: data }), "task"),
+            /**
+             * Update an existing task
+             */
+            update: async (id, changes) => wrap(async () => {
+                // Fetch existing task to merge changes
+                const { task, error } = await this.tasks.find(id);
+                if (error)
+                    throw new Error(error.message);
+                if (!task)
+                    throw new Error(`Task with id ${id} not found`);
+                const updateData = {
+                    id,
+                    title: task.task.title,
+                    summary: task.task.summary,
+                    description: task.task.description,
+                    progress: task.task.progress,
+                    visibility: task.task.visibility,
+                    start_time: task.task.start_time,
+                    end_time: task.task.end_time,
+                    priority: task.task.priority,
+                    owner_id: task.task.owner_id,
+                    project_id: task.task.project_id,
+                    ...changes,
+                };
+                return this.clients.tasks.patch("/tasks", { body: updateData });
+            }, "task"),
+            /**
+             * Upsert task (create or update)
+             */
+            upsert: (data) => wrap(() => this.clients.tasks.patch("/tasks", { body: data }), "task"),
+            /**
+             * Save tags for tasks
+             */
+            saveTags: (data) => wrap(() => this.clients.tasks.post("/tasks/save_tags", { body: data }), "result"),
+            /**
+             * Delete task (soft delete)
+             */
+            deleteTask: (task) => wrap(() => this.clients.tasks.patch("/tasks", { body: { ...task.task, deleted: true } }), "result"),
+            /**
+             * Task history operations
+             */
+            history: {
+                /**
+                 * Get task history by task ID
+                 */
+                get: (task_id) => wrap(() => this.clients.tasks.get(`/tasks/history/${task_id}`), "history"),
+            },
+        };
+        /**
+         * Tags namespace with Result-wrapped operations
+         */
+        this.tags = {
+            /**
+             * List tags for authenticated user
+             */
+            list: () => wrap(() => this.clients.tags.get("/tags"), "tags"),
+        };
+        /**
+         * GitHub namespace with Result-wrapped operations
+         */
+        this.github = {
+            /**
+             * List repositories for authenticated user
+             */
+            repos: () => wrap(() => this.clients.github.get("/repos"), "repos"),
+            /**
+             * List branches for a GitHub repository
+             */
+            branches: (owner, repo) => wrap(() => this.clients.github.get(`/repos/${owner}/${repo}/branches`), "branches"),
+        };
+        /**
+         * User namespace with Result-wrapped operations
+         */
+        this.user = {
+            /**
+             * Get user activity history
+             */
+            history: () => wrap(() => this.clients.auth.get("/user/history"), "history"),
+            /**
+             * Update user preferences
+             */
+            preferences: (data) => wrap(() => this.clients.auth.patch("/user/preferences", { body: data }), "result"),
+        };
+        const v0_base_url = options.base_url || "http://localhost:4321/api/v0";
+        this._api_key = options.api_key;
+        this._auth_mode = options.auth_mode || (options.api_key.startsWith("jwt:") ? "session" : "key");
+        // Create category-specific HTTP clients
+        const clientOptions = {
+            base_url: v0_base_url,
+            api_key: options.api_key,
+            max_history_size: options.max_history_size,
+        };
+        this.clients = {
+            auth: new HttpClient({ ...clientOptions, category: "auth" }),
+            projects: new HttpClient({ ...clientOptions, category: "projects" }),
+            tasks: new HttpClient({ ...clientOptions, category: "tasks" }),
+            milestones: new HttpClient({ ...clientOptions, category: "milestones" }),
+            goals: new HttpClient({ ...clientOptions, category: "goals" }),
+            github: new HttpClient({ ...clientOptions, category: "github" }),
+            tags: new HttpClient({ ...clientOptions, category: "tags" }),
+        };
+    }
+    /**
+     * Get request history for debugging
+     */
+    history() {
+        return this.clients.projects.history();
+    }
+    /**
+     * Get the API key
+     */
+    getApiKey() {
+        return this._api_key;
+    }
+    /**
+     * Get the authentication mode
+     */
+    getAuthMode() {
+        return this._auth_mode;
+    }
+}

package/dist/error-handlers.d.ts

@@ -0,0 +1,55 @@
+import { ApiError, AuthenticationError, NetworkError } from "./errors";
+/**
+ * Centralized error handling utilities to reduce duplication
+ * across API client methods and improve consistency
+ */
+/**
+ * Standard HTTP status codes
+ */
+export declare const HTTP_STATUS: {
+    readonly OK: 200;
+    readonly CREATED: 201;
+    readonly NO_CONTENT: 204;
+    readonly BAD_REQUEST: 400;
+    readonly UNAUTHORIZED: 401;
+    readonly FORBIDDEN: 403;
+    readonly NOT_FOUND: 404;
+    readonly INTERNAL_SERVER_ERROR: 500;
+};
+/**
+ * Handle response based on status code with consistent error types
+ */
+export declare function handleHttpResponse(response: Response): void;
+/**
+ * Parse and throw appropriate error from response text
+ */
+export declare function handleResponseError(response: Response): Promise<never>;
+/**
+ * Handle network errors consistently
+ */
+export declare function handleNetworkError(error: unknown): never;
+/**
+ * Type guard to check if error is an API error
+ */
+export declare function isApiError(error: unknown): error is ApiError;
+/**
+ * Type guard to check if error is an authentication error
+ */
+export declare function isAuthenticationError(error: unknown): error is AuthenticationError;
+/**
+ * Type guard to check if error is a network error
+ */
+export declare function isNetworkError(error: unknown): error is NetworkError;
+/**
+ * Parse Zod validation errors into user-friendly messages
+ */
+export declare function parseZodErrors(errorMessage: string): string;
+/**
+ * Get user-friendly error message from any error
+ */
+export declare function getUserFriendlyErrorMessage(error: unknown): string;
+/**
+ * Retry wrapper for API calls with exponential backoff
+ */
+export declare function withRetry<T>(operation: () => Promise<T>, maxRetries?: number, baseDelay?: number): Promise<T>;
+//# sourceMappingURL=error-handlers.d.ts.map

package/dist/error-handlers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-handlers.d.ts","sourceRoot":"","sources":["../src/error-handlers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,mBAAmB,EAAE,YAAY,EAAmB,MAAM,UAAU,CAAC;AAExF;;;GAGG;AAEH;;GAEG;AACH,eAAO,MAAM,WAAW;;;;;;;;;CASd,CAAC;AAEX;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,QAAQ,GAAG,IAAI,CAc3D;AAED;;GAEG;AACH,wBAAsB,mBAAmB,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAAC,KAAK,CAAC,CAmB5E;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,CAGxD;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,QAAQ,CAE5D;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,mBAAmB,CAElF;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,YAAY,CAEpE;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAgF3D;AAED;;GAEG;AACH,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CA0BlE;AAED;;GAEG;AACH,wBAAsB,SAAS,CAAC,CAAC,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EAAE,UAAU,GAAE,MAAU,EAAE,SAAS,GAAE,MAAa,GAAG,OAAO,CAAC,CAAC,CAAC,CA0B5H"}

package/dist/error-handlers.js

@@ -0,0 +1,217 @@
+import { ApiError, AuthenticationError, NetworkError, ValidationError } from "./errors";
+/**
+ * Centralized error handling utilities to reduce duplication
+ * across API client methods and improve consistency
+ */
+/**
+ * Standard HTTP status codes
+ */
+export const HTTP_STATUS = {
+    OK: 200,
+    CREATED: 201,
+    NO_CONTENT: 204,
+    BAD_REQUEST: 400,
+    UNAUTHORIZED: 401,
+    FORBIDDEN: 403,
+    NOT_FOUND: 404,
+    INTERNAL_SERVER_ERROR: 500,
+};
+/**
+ * Handle response based on status code with consistent error types
+ */
+export function handleHttpResponse(response) {
+    switch (response.status) {
+        case HTTP_STATUS.UNAUTHORIZED:
+            throw new AuthenticationError("Invalid or expired API key");
+        case HTTP_STATUS.NOT_FOUND:
+            throw new ApiError("Resource not found", { statusCode: HTTP_STATUS.NOT_FOUND });
+        case HTTP_STATUS.BAD_REQUEST:
+            // Will be handled by specific error text parsing
+            break;
+        default:
+            if (!response.ok) {
+                throw new ApiError(`Request failed: ${response.statusText}`, { statusCode: response.status });
+            }
+    }
+}
+/**
+ * Parse and throw appropriate error from response text
+ */
+export async function handleResponseError(response) {
+    const errorText = await response.text();
+    const errorMessage = errorText || "Request failed";
+    // Try to parse structured error responses
+    let parsedError = null;
+    try {
+        parsedError = JSON.parse(errorText);
+    }
+    catch {
+        // Not JSON, use raw text
+    }
+    if (response.status === HTTP_STATUS.BAD_REQUEST && parsedError?.error?.name === "ZodError") {
+        // Enhanced: Create a more detailed ValidationError with the original Zod error info
+        const zodErrorDetails = parsedError.error?.issues ? JSON.stringify(parsedError.error) : errorMessage;
+        throw new ValidationError(zodErrorDetails);
+    }
+    throw new ApiError(errorMessage, { statusCode: response.status });
+}
+/**
+ * Handle network errors consistently
+ */
+export function handleNetworkError(error) {
+    const message = error instanceof Error ? error.message : "Unknown network error";
+    throw new NetworkError(message);
+}
+/**
+ * Type guard to check if error is an API error
+ */
+export function isApiError(error) {
+    return error instanceof ApiError;
+}
+/**
+ * Type guard to check if error is an authentication error
+ */
+export function isAuthenticationError(error) {
+    return error instanceof AuthenticationError;
+}
+/**
+ * Type guard to check if error is a network error
+ */
+export function isNetworkError(error) {
+    return error instanceof NetworkError;
+}
+/**
+ * Parse Zod validation errors into user-friendly messages
+ */
+export function parseZodErrors(errorMessage) {
+    try {
+        // Try to parse as JSON first to get structured error info
+        let parsedError = null;
+        try {
+            parsedError = JSON.parse(errorMessage);
+        }
+        catch {
+            // If not JSON, try to extract Zod error details from the error message
+            const zodErrorMatch = errorMessage.match(/ZodError: (.+)/);
+            if (zodErrorMatch && zodErrorMatch[1]) {
+                try {
+                    parsedError = JSON.parse(zodErrorMatch[1]);
+                }
+                catch {
+                    // If still not JSON, try to extract from the message
+                    const issuesMatch = errorMessage.match(/issues:\s*(\[.*\])/s);
+                    if (issuesMatch && issuesMatch[1]) {
+                        try {
+                            parsedError = { issues: JSON.parse(issuesMatch[1]) };
+                        }
+                        catch {
+                            // Fall back to basic parsing
+                        }
+                    }
+                }
+            }
+        }
+        if (parsedError?.issues && Array.isArray(parsedError.issues)) {
+            const friendlyMessages = parsedError.issues.map((issue) => {
+                const path = issue.path && issue.path.length > 0 ? issue.path.join(".") : "field";
+                const message = issue.message || "is invalid";
+                // Handle common validation types with friendly messages
+                switch (issue.code) {
+                    case "invalid_type":
+                        return `${path} must be a ${issue.expected} (received ${issue.received})`;
+                    case "too_small":
+                        if (issue.type === "string") {
+                            return `${path} must be at least ${issue.minimum} characters long`;
+                        }
+                        if (issue.type === "number") {
+                            return `${path} must be at least ${issue.minimum}`;
+                        }
+                        return `${path} is too small`;
+                    case "too_big":
+                        if (issue.type === "string") {
+                            return `${path} must be no more than ${issue.maximum} characters long`;
+                        }
+                        if (issue.type === "number") {
+                            return `${path} must be no more than ${issue.maximum}`;
+                        }
+                        return `${path} is too large`;
+                    case "invalid_string":
+                        if (issue.validation === "email") {
+                            return `${path} must be a valid email address`;
+                        }
+                        if (issue.validation === "url") {
+                            return `${path} must be a valid URL`;
+                        }
+                        if (issue.validation === "uuid") {
+                            return `${path} must be a valid UUID`;
+                        }
+                        return `${path} format is invalid`;
+                    case "custom":
+                        return `${path}: ${message}`;
+                    default:
+                        return `${path}: ${message}`;
+                }
+            });
+            if (friendlyMessages.length === 1) {
+                return friendlyMessages[0];
+            }
+            return `Validation failed:\n• ${friendlyMessages.join("\n• ")}`;
+        }
+    }
+    catch (e) {
+        // Fall back to original message if parsing fails
+        console.debug("Failed to parse Zod error:", e);
+    }
+    return errorMessage;
+}
+/**
+ * Get user-friendly error message from any error
+ */
+export function getUserFriendlyErrorMessage(error) {
+    if (isAuthenticationError(error)) {
+        return "Please check your API key and try again";
+    }
+    if (isNetworkError(error)) {
+        return "Network connection issue. Please try again";
+    }
+    if (isApiError(error)) {
+        if (error.statusCode === HTTP_STATUS.NOT_FOUND) {
+            return "The requested resource was not found";
+        }
+        if (error.statusCode === HTTP_STATUS.BAD_REQUEST) {
+            return "Invalid request. Please check your data";
+        }
+        // Enhanced: Parse Zod validation errors for ValidationError types
+        if (error.code === "VALIDATION_ERROR" && error.message) {
+            return parseZodErrors(error.message);
+        }
+        return error.message || "An error occurred";
+    }
+    return "An unexpected error occurred";
+}
+/**
+ * Retry wrapper for API calls with exponential backoff
+ */
+export async function withRetry(operation, maxRetries = 3, baseDelay = 1000) {
+    let lastError;
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+        try {
+            return await operation();
+        }
+        catch (error) {
+            lastError = error;
+            // Don't retry authentication or validation errors
+            if (isAuthenticationError(error) || error instanceof ValidationError) {
+                throw error;
+            }
+            // Don't retry on final attempt
+            if (attempt === maxRetries) {
+                break;
+            }
+            // Exponential backoff
+            const delay = baseDelay * Math.pow(2, attempt - 1);
+            await new Promise(resolve => setTimeout(resolve, delay));
+        }
+    }
+    throw lastError;
+}