@flowdot.ai/daemon 1.0.0

package/dist/goals/GoalApiClient.js

@@ -0,0 +1,743 @@
+import { ApiRequestFailedError, ApiAuthenticationFailedError, ApiRateLimitedError, ApiTimeoutError, GoalNotFoundError, TaskNotFoundError, MilestoneNotFoundError, ValidationError, } from './errors.js';
+import { deserializeGoal, deserializeMilestone, deserializeTask, deserializeGoalMemory, deserializeMetaGoal, deserializeGoalActionLog, } from './types.js';
+const DEFAULT_TIMEOUT_MS = 30000;
+const DEFAULT_RETRIES = 2;
+const RETRY_DELAY_MS = 1000;
+const TRANSIENT_STATUS_CODES = [502, 503, 504];
+const noopLogger = {
+    debug: () => { },
+    info: () => { },
+    warn: () => { },
+    error: () => { },
+};
+export class GoalApiClient {
+    baseUrl;
+    tokenProvider;
+    timeout;
+    retries;
+    logger;
+    constructor(options) {
+        this.baseUrl = options.baseUrl.replace(/\/$/, '');
+        this.tokenProvider = options.tokenProvider;
+        this.timeout = options.timeout ?? DEFAULT_TIMEOUT_MS;
+        this.retries = options.retries ?? DEFAULT_RETRIES;
+        this.logger = options.logger ?? noopLogger;
+    }
+    async listGoals(options) {
+        const response = await this.request({
+            method: 'GET',
+            path: '/api/hub/goals',
+            query: {
+                status: options?.status,
+                page: options?.page,
+                per_page: options?.perPage,
+            },
+        });
+        if (!response.success || !response.data) {
+            throw new ApiRequestFailedError('GET', '/api/hub/goals', 0, response.message || 'Failed to list goals');
+        }
+        return response.data.map(deserializeGoal);
+    }
+    async getGoal(hash) {
+        const response = await this.request({
+            method: 'GET',
+            path: `/api/hub/goals/${hash}`,
+        });
+        if (!response.success) {
+            if (response.message?.includes('not found')) {
+                throw new GoalNotFoundError(hash);
+            }
+            throw new ApiRequestFailedError('GET', `/api/hub/goals/${hash}`, 0, response.message || 'Failed to get goal');
+        }
+        if (!response.data) {
+            throw new GoalNotFoundError(hash);
+        }
+        return deserializeGoal(response.data);
+    }
+    async createGoal(input) {
+        const response = await this.request({
+            method: 'POST',
+            path: '/api/hub/goals',
+            body: this.transformGoalInput(input),
+        });
+        if (!response.success) {
+            if (response.errors) {
+                throw new ValidationError('Goal validation failed', response.errors);
+            }
+            throw new ApiRequestFailedError('POST', '/api/hub/goals', 0, response.message || 'Failed to create goal');
+        }
+        if (!response.data) {
+            throw new ApiRequestFailedError('POST', '/api/hub/goals', 0, 'No data returned');
+        }
+        return deserializeGoal(response.data);
+    }
+    async updateGoal(hash, input) {
+        const response = await this.request({
+            method: 'PUT',
+            path: `/api/hub/goals/${hash}`,
+            body: this.transformGoalInput(input),
+        });
+        if (!response.success) {
+            if (response.message?.includes('not found')) {
+                throw new GoalNotFoundError(hash);
+            }
+            if (response.errors) {
+                throw new ValidationError('Goal validation failed', response.errors);
+            }
+            throw new ApiRequestFailedError('PUT', `/api/hub/goals/${hash}`, 0, response.message || 'Failed to update goal');
+        }
+        if (!response.data) {
+            throw new GoalNotFoundError(hash);
+        }
+        return deserializeGoal(response.data);
+    }
+    async deleteGoal(hash) {
+        const response = await this.request({
+            method: 'DELETE',
+            path: `/api/hub/goals/${hash}`,
+        });
+        if (!response.success) {
+            if (response.message?.includes('not found')) {
+                throw new GoalNotFoundError(hash);
+            }
+            throw new ApiRequestFailedError('DELETE', `/api/hub/goals/${hash}`, 0, response.message || 'Failed to delete goal');
+        }
+    }
+    async pauseGoal(hash) {
+        const response = await this.request({
+            method: 'POST',
+            path: `/api/hub/goals/${hash}/pause`,
+        });
+        if (!response.success || !response.data) {
+            throw new ApiRequestFailedError('POST', `/api/hub/goals/${hash}/pause`, 0, response.message || 'Failed to pause goal');
+        }
+        return deserializeGoal(response.data);
+    }
+    async resumeGoal(hash) {
+        const response = await this.request({
+            method: 'POST',
+            path: `/api/hub/goals/${hash}/resume`,
+        });
+        if (!response.success || !response.data) {
+            throw new ApiRequestFailedError('POST', `/api/hub/goals/${hash}/resume`, 0, response.message || 'Failed to resume goal');
+        }
+        return deserializeGoal(response.data);
+    }
+    async completeGoal(hash) {
+        const response = await this.request({
+            method: 'POST',
+            path: `/api/hub/goals/${hash}/complete`,
+        });
+        if (!response.success || !response.data) {
+            throw new ApiRequestFailedError('POST', `/api/hub/goals/${hash}/complete`, 0, response.message || 'Failed to complete goal');
+        }
+        return deserializeGoal(response.data);
+    }
+    async abandonGoal(hash) {
+        const response = await this.request({
+            method: 'POST',
+            path: `/api/hub/goals/${hash}/abandon`,
+        });
+        if (!response.success || !response.data) {
+            throw new ApiRequestFailedError('POST', `/api/hub/goals/${hash}/abandon`, 0, response.message || 'Failed to abandon goal');
+        }
+        return deserializeGoal(response.data);
+    }
+    async getGoalProgress(hash) {
+        const response = await this.request({
+            method: 'GET',
+            path: `/api/hub/goals/${hash}/progress`,
+        });
+        if (!response.success || !response.data) {
+            throw new ApiRequestFailedError('GET', `/api/hub/goals/${hash}/progress`, 0, response.message || 'Failed to get goal progress');
+        }
+        return response.data;
+    }
+    async listMilestones(goalHash) {
+        const response = await this.request({
+            method: 'GET',
+            path: `/api/hub/goals/${goalHash}/milestones`,
+        });
+        if (!response.success || !response.data) {
+            throw new ApiRequestFailedError('GET', `/api/hub/goals/${goalHash}/milestones`, 0, response.message || 'Failed to list milestones');
+        }
+        return response.data.map(deserializeMilestone);
+    }
+    async createMilestone(goalHash, input) {
+        const response = await this.request({
+            method: 'POST',
+            path: `/api/hub/goals/${goalHash}/milestones`,
+            body: {
+                title: input.title,
+                description: input.description,
+                target_date: input.targetDate,
+                is_manual: input.isManual ?? true,
+            },
+        });
+        if (!response.success) {
+            if (response.errors) {
+                throw new ValidationError('Milestone validation failed', response.errors);
+            }
+            throw new ApiRequestFailedError('POST', `/api/hub/goals/${goalHash}/milestones`, 0, response.message || 'Failed to create milestone');
+        }
+        if (!response.data) {
+            throw new ApiRequestFailedError('POST', `/api/hub/goals/${goalHash}/milestones`, 0, 'No data returned');
+        }
+        return deserializeMilestone(response.data);
+    }
+    async getMilestone(goalHash, milestoneId) {
+        const response = await this.request({
+            method: 'GET',
+            path: `/api/hub/goals/${goalHash}/milestones/${milestoneId}`,
+        });
+        if (!response.success) {
+            if (response.message?.includes('not found')) {
+                throw new MilestoneNotFoundError(goalHash, milestoneId);
+            }
+            throw new ApiRequestFailedError('GET', `/api/hub/goals/${goalHash}/milestones/${milestoneId}`, 0, response.message || 'Failed to get milestone');
+        }
+        if (!response.data) {
+            throw new MilestoneNotFoundError(goalHash, milestoneId);
+        }
+        return deserializeMilestone(response.data);
+    }
+    async updateMilestone(goalHash, milestoneId, input) {
+        const response = await this.request({
+            method: 'PUT',
+            path: `/api/hub/goals/${goalHash}/milestones/${milestoneId}`,
+            body: {
+                title: input.title,
+                description: input.description,
+                target_date: input.targetDate,
+            },
+        });
+        if (!response.success || !response.data) {
+            throw new ApiRequestFailedError('PUT', `/api/hub/goals/${goalHash}/milestones/${milestoneId}`, 0, response.message || 'Failed to update milestone');
+        }
+        return deserializeMilestone(response.data);
+    }
+    async deleteMilestone(goalHash, milestoneId) {
+        const response = await this.request({
+            method: 'DELETE',
+            path: `/api/hub/goals/${goalHash}/milestones/${milestoneId}`,
+        });
+        if (!response.success) {
+            throw new ApiRequestFailedError('DELETE', `/api/hub/goals/${goalHash}/milestones/${milestoneId}`, 0, response.message || 'Failed to delete milestone');
+        }
+    }
+    async completeMilestone(goalHash, milestoneId) {
+        const response = await this.request({
+            method: 'POST',
+            path: `/api/hub/goals/${goalHash}/milestones/${milestoneId}/complete`,
+        });
+        if (!response.success || !response.data) {
+            throw new ApiRequestFailedError('POST', `/api/hub/goals/${goalHash}/milestones/${milestoneId}/complete`, 0, response.message || 'Failed to complete milestone');
+        }
+        return deserializeMilestone(response.data);
+    }
+    async listTasks(goalHash, options) {
+        const response = await this.request({
+            method: 'GET',
+            path: `/api/hub/goals/${goalHash}/tasks`,
+            query: {
+                status: options?.status,
+                page: options?.page,
+                per_page: options?.perPage,
+            },
+        });
+        if (!response.success || !response.data) {
+            throw new ApiRequestFailedError('GET', `/api/hub/goals/${goalHash}/tasks`, 0, response.message || 'Failed to list tasks');
+        }
+        return response.data.map(deserializeTask);
+    }
+    async getPendingTasks() {
+        const response = await this.request({
+            method: 'GET',
+            path: '/api/hub/tasks/pending',
+        });
+        if (!response.success || !response.data) {
+            throw new ApiRequestFailedError('GET', '/api/hub/tasks/pending', 0, response.message || 'Failed to get pending tasks');
+        }
+        return response.data.map(deserializeTask);
+    }
+    async getTasksAwaitingApproval() {
+        const response = await this.request({
+            method: 'GET',
+            path: '/api/hub/tasks/awaiting-approval',
+        });
+        if (!response.success || !response.data) {
+            throw new ApiRequestFailedError('GET', '/api/hub/tasks/awaiting-approval', 0, response.message || 'Failed to get tasks awaiting approval');
+        }
+        return response.data.map(deserializeTask);
+    }
+    async createTask(goalHash, input) {
+        const response = await this.request({
+            method: 'POST',
+            path: `/api/hub/goals/${goalHash}/tasks`,
+            body: {
+                title: input.title,
+                description: input.description,
+                task_type: input.taskType ?? 'research',
+                permission_category: input.permissionCategory,
+                scheduled_for: input.scheduledFor,
+                milestone_id: input.milestoneId,
+            },
+        });
+        if (!response.success) {
+            if (response.errors) {
+                throw new ValidationError('Task validation failed', response.errors);
+            }
+            throw new ApiRequestFailedError('POST', `/api/hub/goals/${goalHash}/tasks`, 0, response.message || 'Failed to create task');
+        }
+        if (!response.data) {
+            throw new ApiRequestFailedError('POST', `/api/hub/goals/${goalHash}/tasks`, 0, 'No data returned');
+        }
+        return deserializeTask(response.data);
+    }
+    async getTask(goalHash, taskId) {
+        const response = await this.request({
+            method: 'GET',
+            path: `/api/hub/goals/${goalHash}/tasks/${taskId}`,
+        });
+        if (!response.success) {
+            if (response.message?.includes('not found')) {
+                throw new TaskNotFoundError(goalHash, taskId);
+            }
+            throw new ApiRequestFailedError('GET', `/api/hub/goals/${goalHash}/tasks/${taskId}`, 0, response.message || 'Failed to get task');
+        }
+        if (!response.data) {
+            throw new TaskNotFoundError(goalHash, taskId);
+        }
+        return deserializeTask(response.data);
+    }
+    async updateTask(goalHash, taskId, input) {
+        const response = await this.request({
+            method: 'PUT',
+            path: `/api/hub/goals/${goalHash}/tasks/${taskId}`,
+            body: {
+                title: input.title,
+                description: input.description,
+                task_type: input.taskType,
+                permission_category: input.permissionCategory,
+                scheduled_for: input.scheduledFor,
+                milestone_id: input.milestoneId,
+            },
+        });
+        if (!response.success || !response.data) {
+            throw new ApiRequestFailedError('PUT', `/api/hub/goals/${goalHash}/tasks/${taskId}`, 0, response.message || 'Failed to update task');
+        }
+        return deserializeTask(response.data);
+    }
+    async deleteTask(goalHash, taskId) {
+        const response = await this.request({
+            method: 'DELETE',
+            path: `/api/hub/goals/${goalHash}/tasks/${taskId}`,
+        });
+        if (!response.success) {
+            throw new ApiRequestFailedError('DELETE', `/api/hub/goals/${goalHash}/tasks/${taskId}`, 0, response.message || 'Failed to delete task');
+        }
+    }
+    async approveTask(goalHash, taskId) {
+        const response = await this.request({
+            method: 'POST',
+            path: `/api/hub/goals/${goalHash}/tasks/${taskId}/approve`,
+        });
+        if (!response.success || !response.data) {
+            throw new ApiRequestFailedError('POST', `/api/hub/goals/${goalHash}/tasks/${taskId}/approve`, 0, response.message || 'Failed to approve task');
+        }
+        return deserializeTask(response.data);
+    }
+    async denyTask(goalHash, taskId) {
+        const response = await this.request({
+            method: 'POST',
+            path: `/api/hub/goals/${goalHash}/tasks/${taskId}/deny`,
+        });
+        if (!response.success || !response.data) {
+            throw new ApiRequestFailedError('POST', `/api/hub/goals/${goalHash}/tasks/${taskId}/deny`, 0, response.message || 'Failed to deny task');
+        }
+        return deserializeTask(response.data);
+    }
+    async startTask(goalHash, taskId) {
+        const response = await this.request({
+            method: 'POST',
+            path: `/api/hub/goals/${goalHash}/tasks/${taskId}/start`,
+        });
+        if (!response.success || !response.data) {
+            throw new ApiRequestFailedError('POST', `/api/hub/goals/${goalHash}/tasks/${taskId}/start`, 0, response.message || 'Failed to start task');
+        }
+        return deserializeTask(response.data);
+    }
+    async completeTask(goalHash, taskId, result) {
+        const response = await this.request({
+            method: 'POST',
+            path: `/api/hub/goals/${goalHash}/tasks/${taskId}/complete`,
+            body: result ? { result } : undefined,
+        });
+        if (!response.success || !response.data) {
+            throw new ApiRequestFailedError('POST', `/api/hub/goals/${goalHash}/tasks/${taskId}/complete`, 0, response.message || 'Failed to complete task');
+        }
+        return deserializeTask(response.data);
+    }
+    async failTask(goalHash, taskId, input) {
+        const response = await this.request({
+            method: 'POST',
+            path: `/api/hub/goals/${goalHash}/tasks/${taskId}/fail`,
+            body: {
+                error: input.error,
+                result: input.result,
+            },
+        });
+        if (!response.success || !response.data) {
+            throw new ApiRequestFailedError('POST', `/api/hub/goals/${goalHash}/tasks/${taskId}/fail`, 0, response.message || 'Failed to fail task');
+        }
+        return deserializeTask(response.data);
+    }
+    async skipTask(goalHash, taskId) {
+        const response = await this.request({
+            method: 'POST',
+            path: `/api/hub/goals/${goalHash}/tasks/${taskId}/skip`,
+        });
+        if (!response.success || !response.data) {
+            throw new ApiRequestFailedError('POST', `/api/hub/goals/${goalHash}/tasks/${taskId}/skip`, 0, response.message || 'Failed to skip task');
+        }
+        return deserializeTask(response.data);
+    }
+    async addTaskFeedback(goalHash, taskId, input) {
+        const response = await this.request({
+            method: 'POST',
+            path: `/api/hub/goals/${goalHash}/tasks/${taskId}/feedback`,
+            body: {
+                quality: input.quality,
+                comment: input.comment,
+            },
+        });
+        if (!response.success || !response.data) {
+            throw new ApiRequestFailedError('POST', `/api/hub/goals/${goalHash}/tasks/${taskId}/feedback`, 0, response.message || 'Failed to add task feedback');
+        }
+        return deserializeTask(response.data);
+    }
+    async listMemories(goalHash) {
+        const response = await this.request({
+            method: 'GET',
+            path: `/api/hub/goals/${goalHash}/memories`,
+        });
+        if (!response.success || !response.data) {
+            throw new ApiRequestFailedError('GET', `/api/hub/goals/${goalHash}/memories`, 0, response.message || 'Failed to list memories');
+        }
+        return response.data.map(deserializeGoalMemory);
+    }
+    async getEnabledMemories(goalHash) {
+        const response = await this.request({
+            method: 'GET',
+            path: `/api/hub/goals/${goalHash}/memories/enabled`,
+        });
+        if (!response.success || !response.data) {
+            throw new ApiRequestFailedError('GET', `/api/hub/goals/${goalHash}/memories/enabled`, 0, response.message || 'Failed to get enabled memories');
+        }
+        return response.data.map(deserializeGoalMemory);
+    }
+    async createMemory(goalHash, input) {
+        const response = await this.request({
+            method: 'POST',
+            path: `/api/hub/goals/${goalHash}/memories`,
+            body: {
+                content: input.content,
+                memory_type: input.memoryType ?? 'learning',
+                source: input.source ?? 'auto',
+            },
+        });
+        if (!response.success) {
+            if (response.errors) {
+                throw new ValidationError('Memory validation failed', response.errors);
+            }
+            throw new ApiRequestFailedError('POST', `/api/hub/goals/${goalHash}/memories`, 0, response.message || 'Failed to create memory');
+        }
+        if (!response.data) {
+            throw new ApiRequestFailedError('POST', `/api/hub/goals/${goalHash}/memories`, 0, 'No data returned');
+        }
+        return deserializeGoalMemory(response.data);
+    }
+    async updateMemory(goalHash, memoryId, input) {
+        const response = await this.request({
+            method: 'PUT',
+            path: `/api/hub/goals/${goalHash}/memories/${memoryId}`,
+            body: {
+                content: input.content,
+                memory_type: input.memoryType,
+                is_enabled: input.isEnabled,
+            },
+        });
+        if (!response.success || !response.data) {
+            throw new ApiRequestFailedError('PUT', `/api/hub/goals/${goalHash}/memories/${memoryId}`, 0, response.message || 'Failed to update memory');
+        }
+        return deserializeGoalMemory(response.data);
+    }
+    async toggleMemory(goalHash, memoryId) {
+        const response = await this.request({
+            method: 'POST',
+            path: `/api/hub/goals/${goalHash}/memories/${memoryId}/toggle`,
+        });
+        if (!response.success || !response.data) {
+            throw new ApiRequestFailedError('POST', `/api/hub/goals/${goalHash}/memories/${memoryId}/toggle`, 0, response.message || 'Failed to toggle memory');
+        }
+        return deserializeGoalMemory(response.data);
+    }
+    async deleteMemory(goalHash, memoryId) {
+        const response = await this.request({
+            method: 'DELETE',
+            path: `/api/hub/goals/${goalHash}/memories/${memoryId}`,
+        });
+        if (!response.success) {
+            throw new ApiRequestFailedError('DELETE', `/api/hub/goals/${goalHash}/memories/${memoryId}`, 0, response.message || 'Failed to delete memory');
+        }
+    }
+    async listMetaGoals(active) {
+        const response = await this.request({
+            method: 'GET',
+            path: '/api/hub/meta-goals',
+            query: active !== undefined ? { active } : undefined,
+        });
+        if (!response.success || !response.data) {
+            throw new ApiRequestFailedError('GET', '/api/hub/meta-goals', 0, response.message || 'Failed to list meta-goals');
+        }
+        return response.data.map(deserializeMetaGoal);
+    }
+    async getMetaGoalsForGoal(goalHash) {
+        const response = await this.request({
+            method: 'GET',
+            path: `/api/hub/meta-goals/for-goal/${goalHash}`,
+        });
+        if (!response.success || !response.data) {
+            throw new ApiRequestFailedError('GET', `/api/hub/meta-goals/for-goal/${goalHash}`, 0, response.message || 'Failed to get meta-goals for goal');
+        }
+        return response.data.map(deserializeMetaGoal);
+    }
+    async createMetaGoal(input) {
+        const response = await this.request({
+            method: 'POST',
+            path: '/api/hub/meta-goals',
+            body: {
+                description: input.description,
+                priority: input.priority ?? 0,
+                scope: input.scope ?? 'all',
+            },
+        });
+        if (!response.success) {
+            if (response.errors) {
+                throw new ValidationError('Meta-goal validation failed', response.errors);
+            }
+            throw new ApiRequestFailedError('POST', '/api/hub/meta-goals', 0, response.message || 'Failed to create meta-goal');
+        }
+        if (!response.data) {
+            throw new ApiRequestFailedError('POST', '/api/hub/meta-goals', 0, 'No data returned');
+        }
+        return deserializeMetaGoal(response.data);
+    }
+    async getMetaGoal(id) {
+        const response = await this.request({
+            method: 'GET',
+            path: `/api/hub/meta-goals/${id}`,
+        });
+        if (!response.success || !response.data) {
+            throw new ApiRequestFailedError('GET', `/api/hub/meta-goals/${id}`, 0, response.message || 'Failed to get meta-goal');
+        }
+        return deserializeMetaGoal(response.data);
+    }
+    async updateMetaGoal(id, input) {
+        const response = await this.request({
+            method: 'PUT',
+            path: `/api/hub/meta-goals/${id}`,
+            body: {
+                description: input.description,
+                priority: input.priority,
+                scope: input.scope,
+                is_active: input.isActive,
+            },
+        });
+        if (!response.success || !response.data) {
+            throw new ApiRequestFailedError('PUT', `/api/hub/meta-goals/${id}`, 0, response.message || 'Failed to update meta-goal');
+        }
+        return deserializeMetaGoal(response.data);
+    }
+    async toggleMetaGoal(id) {
+        const response = await this.request({
+            method: 'POST',
+            path: `/api/hub/meta-goals/${id}/toggle`,
+        });
+        if (!response.success || !response.data) {
+            throw new ApiRequestFailedError('POST', `/api/hub/meta-goals/${id}/toggle`, 0, response.message || 'Failed to toggle meta-goal');
+        }
+        return deserializeMetaGoal(response.data);
+    }
+    async deleteMetaGoal(id) {
+        const response = await this.request({
+            method: 'DELETE',
+            path: `/api/hub/meta-goals/${id}`,
+        });
+        if (!response.success) {
+            throw new ApiRequestFailedError('DELETE', `/api/hub/meta-goals/${id}`, 0, response.message || 'Failed to delete meta-goal');
+        }
+    }
+    async getActionLogs(goalHash, limit) {
+        const response = await this.request({
+            method: 'GET',
+            path: `/api/hub/goals/${goalHash}/logs`,
+            query: limit ? { limit } : undefined,
+        });
+        if (!response.success || !response.data) {
+            throw new ApiRequestFailedError('GET', `/api/hub/goals/${goalHash}/logs`, 0, response.message || 'Failed to get action logs');
+        }
+        return response.data.map(deserializeGoalActionLog);
+    }
+    transformGoalInput(input) {
+        const result = {};
+        if ('name' in input && input.name !== undefined)
+            result.name = input.name;
+        if ('description' in input && input.description !== undefined)
+            result.description = input.description;
+        if ('priority' in input && input.priority !== undefined)
+            result.priority = input.priority;
+        if ('approvalMode' in input && input.approvalMode !== undefined)
+            result.approval_mode = input.approvalMode;
+        if ('deadline' in input && input.deadline !== undefined)
+            result.deadline = input.deadline;
+        if ('restrictions' in input && input.restrictions !== undefined)
+            result.restrictions = input.restrictions;
+        if ('schedule' in input && input.schedule !== undefined)
+            result.schedule = input.schedule;
+        if ('notificationPreferences' in input && input.notificationPreferences !== undefined) {
+            result.notification_preferences = input.notificationPreferences;
+        }
+        if ('reviewSchedule' in input && input.reviewSchedule !== undefined)
+            result.review_schedule = input.reviewSchedule;
+        if ('parentHash' in input && input.parentHash !== undefined)
+            result.parent_hash = input.parentHash;
+        if ('dependsOn' in input && input.dependsOn !== undefined)
+            result.dependsOn = input.dependsOn;
+        return result;
+    }
+    async request(options) {
+        const { method, path, body, query } = options;
+        let url = `${this.baseUrl}${path}`;
+        if (query) {
+            const params = new URLSearchParams();
+            for (const [key, value] of Object.entries(query)) {
+                if (value !== undefined) {
+                    params.append(key, String(value));
+                }
+            }
+            const queryString = params.toString();
+            if (queryString) {
+                url += `?${queryString}`;
+            }
+        }
+        const token = await this.tokenProvider();
+        let lastError = null;
+        for (let attempt = 0; attempt <= this.retries; attempt++) {
+            try {
+                const result = await this.executeRequest(method, url, token, body);
+                return result;
+            }
+            catch (error) {
+                lastError = error instanceof Error ? error : new Error(String(error));
+                if (error instanceof ApiAuthenticationFailedError ||
+                    error instanceof ApiRateLimitedError ||
+                    error instanceof ValidationError) {
+                    throw error;
+                }
+                const statusCode = error instanceof ApiRequestFailedError
+                    ? (typeof error.context?.statusCode === 'number' ? error.context.statusCode : 0)
+                    : 0;
+                const isTransient = error instanceof ApiTimeoutError ||
+                    (error instanceof ApiRequestFailedError && TRANSIENT_STATUS_CODES.includes(statusCode));
+                if (!isTransient || attempt >= this.retries) {
+                    throw error;
+                }
+                this.logger.debug('GOAL_API', `Request failed, retrying (${attempt + 1}/${this.retries})`, {
+                    method,
+                    path,
+                    error: lastError.message,
+                });
+                await this.delay(RETRY_DELAY_MS * (attempt + 1));
+            }
+        }
+        throw lastError ?? new ApiRequestFailedError(method, path, 0, 'Unknown error');
+    }
+    async executeRequest(method, url, token, body) {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+        try {
+            const headers = {
+                'Content-Type': 'application/json',
+                'Accept': 'application/json',
+            };
+            if (token) {
+                headers['Authorization'] = `Bearer ${token}`;
+            }
+            const response = await fetch(url, {
+                method,
+                headers,
+                body: body ? JSON.stringify(body) : undefined,
+                signal: controller.signal,
+            });
+            if (!response.ok) {
+                await this.handleHttpError(response, method, url);
+            }
+            const contentType = response.headers.get('content-type');
+            if (contentType?.includes('application/json')) {
+                return (await response.json());
+            }
+            return { success: true };
+        }
+        catch (error) {
+            if (error instanceof ApiRequestFailedError ||
+                error instanceof ApiAuthenticationFailedError ||
+                error instanceof ApiRateLimitedError) {
+                throw error;
+            }
+            if (error instanceof Error) {
+                if (error.name === 'AbortError') {
+                    throw new ApiTimeoutError(url, this.timeout);
+                }
+                throw new ApiRequestFailedError(method, url, 0, error.message);
+            }
+            throw new ApiRequestFailedError(method, url, 0, String(error));
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
+    }
+    async handleHttpError(response, method, url) {
+        const status = response.status;
+        let errorBody = null;
+        try {
+            const contentType = response.headers.get('content-type');
+            if (contentType?.includes('application/json')) {
+                errorBody = await response.json();
+            }
+        }
+        catch {
+        }
+        const message = errorBody?.message ||
+            errorBody?.error ||
+            response.statusText;
+        if (status === 401) {
+            throw new ApiAuthenticationFailedError(message);
+        }
+        if (status === 429) {
+            const retryAfterHeader = response.headers.get('retry-after');
+            const retryAfter = retryAfterHeader ? parseInt(retryAfterHeader, 10) : null;
+            throw new ApiRateLimitedError(Number.isNaN(retryAfter) ? null : retryAfter);
+        }
+        if (status === 422 && errorBody?.errors) {
+            throw new ValidationError('Validation failed', errorBody.errors);
+        }
+        throw new ApiRequestFailedError(method, url, status, message);
+    }
+    delay(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+}
+export function createGoalApiClient(options) {
+    return new GoalApiClient(options);
+}