@rimori/react-client 0.1.0

package/dist/rimori-client/src/controller/AIController.js

@@ -0,0 +1,255 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+export function generateText(backendUrl, messages, tools, token) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const response = yield fetch(`${backendUrl}/ai/llm`, {
+            method: 'POST',
+            body: JSON.stringify({ messages, tools }),
+            headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' },
+        });
+        return yield response.json();
+    });
+}
+export function streamChatGPT(backendUrl, messages, tools, onResponse, token) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const messageId = Math.random().toString(36).substring(3);
+        const currentMessages = [...messages];
+        console.log('Starting streamChatGPT with:', {
+            messageId,
+            messageCount: messages.length,
+            toolCount: tools.length,
+            backendUrl,
+        });
+        while (true) {
+            const messagesForApi = currentMessages.map((_a) => {
+                var { id } = _a, rest = __rest(_a, ["id"]);
+                return rest;
+            });
+            try {
+                const response = yield fetch(`${backendUrl}/ai/llm`, {
+                    method: 'POST',
+                    body: JSON.stringify({ messages: messagesForApi, tools, stream: true }),
+                    headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' },
+                });
+                if (!response.ok) {
+                    throw new Error(`HTTP error! status: ${response.status}`);
+                }
+                if (!response.body) {
+                    console.error('No response body.');
+                    return;
+                }
+                const reader = response.body.getReader();
+                const decoder = new TextDecoder('utf-8');
+                let content = '';
+                let done = false;
+                const toolInvocations = [];
+                let currentTextId = '';
+                let isToolCallMode = false;
+                let buffer = ''; // Buffer for incomplete chunks
+                while (!done) {
+                    const { value, done: readerDone } = yield reader.read();
+                    if (value) {
+                        const chunk = decoder.decode(value, { stream: true });
+                        buffer += chunk;
+                        // Split by lines, but handle incomplete lines
+                        const lines = buffer.split('\n');
+                        // Keep the last line in buffer if it's incomplete
+                        if (lines.length > 1) {
+                            buffer = lines.pop() || '';
+                        }
+                        for (const line of lines) {
+                            if (line.trim() === '')
+                                continue;
+                            // Handle the new streaming format
+                            if (line.startsWith('data: ')) {
+                                const dataStr = line.substring(6); // Remove 'data: ' prefix
+                                // Handle [DONE] marker
+                                if (dataStr === '[DONE]') {
+                                    done = true;
+                                    break;
+                                }
+                                try {
+                                    const data = JSON.parse(dataStr);
+                                    // Log the first message to understand the format
+                                    if (!content && !isToolCallMode) {
+                                        // console.log('First stream message received:', data);
+                                    }
+                                    switch (data.type) {
+                                        case 'start':
+                                            // Stream started, no action needed
+                                            // console.log('Stream started');
+                                            break;
+                                        case 'start-step':
+                                            // Step started, no action needed
+                                            // console.log('Step started');
+                                            break;
+                                        case 'reasoning-start':
+                                            // Reasoning started, no action needed
+                                            console.log('Reasoning started:', data.id);
+                                            break;
+                                        case 'reasoning-end':
+                                            // Reasoning ended, no action needed
+                                            console.log('Reasoning ended:', data.id);
+                                            break;
+                                        case 'text-start':
+                                            // Text generation started, store the ID
+                                            currentTextId = data.id;
+                                            console.log('Text generation started:', data.id);
+                                            break;
+                                        case 'text-delta':
+                                            // Text delta received, append to content
+                                            if (data.delta) {
+                                                content += data.delta;
+                                                onResponse(messageId, content, false);
+                                            }
+                                            break;
+                                        case 'text-end':
+                                            // Text generation ended
+                                            console.log('Text generation ended:', data.id);
+                                            break;
+                                        case 'finish-step':
+                                            // Step finished, no action needed
+                                            // console.log('Step finished');
+                                            break;
+                                        case 'finish':
+                                            // Stream finished
+                                            // console.log('Stream finished');
+                                            done = true;
+                                            break;
+                                        // Additional message types that might be present in the AI library
+                                        case 'tool-call':
+                                        case 'tool-input-available': //for now input calls should be handled the same way as tool calls
+                                            // Tool call initiated
+                                            console.log('Tool call initiated:', data);
+                                            isToolCallMode = true;
+                                            if (data.toolCallId && data.toolName && (data.args || data.input)) {
+                                                toolInvocations.push({
+                                                    toolCallId: data.toolCallId,
+                                                    toolName: data.toolName,
+                                                    args: data.args || data.input,
+                                                });
+                                            }
+                                            break;
+                                        case 'tool-input-delta': //for now input calls should be handled the same way as tool calls
+                                        case 'tool-call-delta':
+                                            // Tool call delta (for streaming tool calls)
+                                            console.log('Tool call delta:', data);
+                                            break;
+                                        case 'tool-call-end':
+                                            // Tool call completed
+                                            console.log('Tool call completed:', data);
+                                            break;
+                                        case 'tool-result':
+                                            // Tool execution result
+                                            console.log('Tool result:', data);
+                                            break;
+                                        case 'error':
+                                            // Error occurred
+                                            console.error('Stream error:', data);
+                                            break;
+                                        case 'usage':
+                                            // Usage information
+                                            console.log('Usage info:', data);
+                                            break;
+                                        case 'model':
+                                            // Model information
+                                            console.log('Model info:', data);
+                                            break;
+                                        case 'stop':
+                                            // Stop signal
+                                            console.log('Stop signal received');
+                                            done = true;
+                                            break;
+                                        default:
+                                            // Unknown type, log for debugging
+                                            console.log('Unknown stream type:', data.type, data);
+                                            break;
+                                    }
+                                }
+                                catch (error) {
+                                    console.error('Error parsing stream data:', error, dataStr);
+                                }
+                            }
+                        }
+                    }
+                    if (readerDone) {
+                        done = true;
+                    }
+                }
+                // Check if we have content or if this was a tool call response
+                if (content || toolInvocations.length > 0) {
+                    currentMessages.push({
+                        id: messageId,
+                        role: 'assistant',
+                        content: content,
+                        toolCalls: toolInvocations.length > 0 ? toolInvocations : undefined,
+                    });
+                }
+                // Handle tool call scenario if tools were provided
+                if (tools.length > 0 && toolInvocations.length > 0) {
+                    console.log('Tool calls detected, executing tools...');
+                    const toolResults = [];
+                    for (const toolInvocation of toolInvocations) {
+                        const tool = tools.find((t) => t.name === toolInvocation.toolName);
+                        if (tool && tool.execute) {
+                            try {
+                                const result = yield tool.execute(toolInvocation.args);
+                                toolResults.push({
+                                    id: Math.random().toString(36).substring(3),
+                                    role: 'user',
+                                    content: `Tool '${toolInvocation.toolName}' returned: ${JSON.stringify(result)}`,
+                                });
+                            }
+                            catch (error) {
+                                console.error(`Error executing tool ${toolInvocation.toolName}:`, error);
+                                toolResults.push({
+                                    id: Math.random().toString(36).substring(3),
+                                    role: 'user',
+                                    content: `Tool '${toolInvocation.toolName}' failed with error: ${error}`,
+                                });
+                            }
+                        }
+                    }
+                    if (toolResults.length > 0) {
+                        currentMessages.push(...toolResults);
+                        // Continue the loop to handle the next response
+                        continue;
+                    }
+                }
+                // Since the new format doesn't seem to support tool calls in the same way,
+                // we'll assume the stream is complete when we reach the end
+                // If tools are provided and no content was generated, this might indicate a tool call
+                if (tools.length > 0 && !content && !isToolCallMode) {
+                    // This might be a tool call scenario, but we need more information
+                    // For now, we'll just finish the stream
+                    console.log('No content generated, but tools provided - might be tool call scenario');
+                }
+                onResponse(messageId, content, true, toolInvocations);
+                return;
+            }
+            catch (error) {
+                console.error('Error in streamChatGPT:', error);
+                onResponse(messageId, `Error: ${error instanceof Error ? error.message : String(error)}`, true, []);
+                return;
+            }
+        }
+    });
+}

package/dist/rimori-client/src/controller/AccomplishmentController.d.ts

@@ -0,0 +1,38 @@
+import { EventBusMessage } from '../fromRimori/EventBus';
+export type AccomplishmentMessage = EventBusMessage<MicroAccomplishmentPayload>;
+export declare const skillCategories: readonly ["reading", "listening", "speaking", "writing", "learning", "community"];
+interface BaseAccomplishmentPayload {
+    type: 'micro' | 'macro';
+    skillCategory: (typeof skillCategories)[number];
+    accomplishmentKeyword: string;
+    description: string;
+    meta?: {
+        key: string;
+        value: string | number | boolean;
+        description: string;
+    }[];
+}
+export interface MicroAccomplishmentPayload extends BaseAccomplishmentPayload {
+    type: 'micro';
+}
+export interface MacroAccomplishmentPayload extends BaseAccomplishmentPayload {
+    type: 'macro';
+    errorRatio: number;
+    durationMinutes: number;
+}
+export type AccomplishmentPayload = MicroAccomplishmentPayload | MacroAccomplishmentPayload;
+export declare class AccomplishmentController {
+    private pluginId;
+    constructor(pluginId: string);
+    emitAccomplishment(payload: Omit<AccomplishmentPayload, 'type'>): void;
+    private validateAccomplishment;
+    private sanitizeAccomplishment;
+    private getDecoupledTopic;
+    /**
+     * Subscribe to accomplishment events
+     * @param accomplishmentTopic - The topic of the accomplishment event. The pattern can be any pattern of plugin.skillCategory.accomplishmentKeyword or an * as wildcard for any plugin, skill category or accomplishment keyword
+     * @param callback - The callback function to be called when the accomplishment event is triggered
+     */
+    subscribe(accomplishmentTopics: string | string[] | undefined, callback: (payload: EventBusMessage<AccomplishmentPayload>) => void): void;
+}
+export {};

package/dist/rimori-client/src/controller/AccomplishmentController.js

@@ -0,0 +1,112 @@
+import { EventBus } from '../fromRimori/EventBus';
+export const skillCategories = ['reading', 'listening', 'speaking', 'writing', 'learning', 'community'];
+export class AccomplishmentController {
+    constructor(pluginId) {
+        this.pluginId = pluginId;
+    }
+    emitAccomplishment(payload) {
+        const accomplishmentPayload = Object.assign(Object.assign({}, payload), { type: 'durationMinutes' in payload ? 'macro' : 'micro' });
+        this.validateAccomplishment(accomplishmentPayload);
+        const sanitizedPayload = this.sanitizeAccomplishment(accomplishmentPayload);
+        const topic = 'global.accomplishment.trigger' + (accomplishmentPayload.type === 'macro' ? 'Macro' : 'Micro');
+        EventBus.emit(this.pluginId, topic, sanitizedPayload);
+    }
+    validateAccomplishment(payload) {
+        if (!skillCategories.includes(payload.skillCategory)) {
+            throw new Error(`Invalid skill category: ${payload.skillCategory}`);
+        }
+        //regex validate accomplishmentKeyword
+        if (!/^[a-z_-]+$/.test(payload.accomplishmentKeyword)) {
+            throw new Error(`The accomplishment keyword: ${payload.accomplishmentKeyword} is invalid. Only lowercase letters, minuses and underscores are allowed`);
+        }
+        //description is required
+        if (payload.description.length < 10) {
+            throw new Error('Description is too short');
+        }
+        //check that the type is valid
+        if (!['micro', 'macro'].includes(payload.type)) {
+            throw new Error('Invalid accomplishment type ' + payload.type);
+        }
+        //durationMinutes is required
+        if (payload.type === 'macro' && payload.durationMinutes < 4) {
+            throw new Error('The duration must be at least 4 minutes');
+        }
+        //errorRatio is required
+        if (payload.type === 'macro' && (payload.errorRatio < 0 || payload.errorRatio > 1)) {
+            throw new Error('The error ratio must be between 0 and 1');
+        }
+        //regex check meta data key
+        if (payload.meta) {
+            payload.meta.forEach((meta) => {
+                if (!/^[a-z_]+$/.test(meta.key)) {
+                    throw new Error('Invalid meta data key ' + meta.key + ', only lowercase letters and underscores are allowed');
+                }
+            });
+        }
+    }
+    sanitizeAccomplishment(payload) {
+        var _a;
+        payload.description = payload.description.replace(/[^\x20-\x7E]/g, '');
+        (_a = payload.meta) === null || _a === void 0 ? void 0 : _a.forEach((meta) => {
+            meta.description = meta.description.replace(/[^\x20-\x7E]/g, '');
+        });
+        return payload;
+    }
+    getDecoupledTopic(topic) {
+        const [plugin, skillCategory, accomplishmentKeyword] = topic.split('.');
+        return {
+            plugin: plugin || '*',
+            skillCategory: skillCategory || '*',
+            accomplishmentKeyword: accomplishmentKeyword || '*',
+        };
+    }
+    /**
+     * Subscribe to accomplishment events
+     * @param accomplishmentTopic - The topic of the accomplishment event. The pattern can be any pattern of plugin.skillCategory.accomplishmentKeyword or an * as wildcard for any plugin, skill category or accomplishment keyword
+     * @param callback - The callback function to be called when the accomplishment event is triggered
+     */
+    subscribe(accomplishmentTopics = '*', callback) {
+        if (typeof accomplishmentTopics === 'string') {
+            accomplishmentTopics = [accomplishmentTopics];
+        }
+        accomplishmentTopics.forEach((accomplishmentTopic) => {
+            const topicLength = accomplishmentTopic.split('.').length;
+            if (topicLength === 1) {
+                accomplishmentTopic += '.*.*';
+            }
+            else if (topicLength === 2) {
+                accomplishmentTopic += '.*';
+            }
+            else if (topicLength !== 3) {
+                throw new Error('Invalid accomplishment topic pattern. The pattern must be plugin.skillCategory.accomplishmentKeyword or an * as wildcard for any plugin, skill category or accomplishment keyword');
+            }
+            EventBus.on(['global.accomplishment.triggerMicro', 'global.accomplishment.triggerMacro'], (event) => {
+                const { plugin, skillCategory, accomplishmentKeyword } = this.getDecoupledTopic(accomplishmentTopic);
+                if (plugin !== '*' && event.sender !== plugin)
+                    return;
+                if (skillCategory !== '*' && event.data.skillCategory !== skillCategory)
+                    return;
+                if (accomplishmentKeyword !== '*' && event.data.accomplishmentKeyword !== accomplishmentKeyword)
+                    return;
+                callback(event);
+            }, [this.pluginId]);
+        });
+    }
+}
+// const accomplishmentHandler = AccomplishmentHandler.getInstance("my-plugin");
+// accomplishmentHandler.subscribe("*", (payload) => {
+//   console.log(payload);
+// });
+// accomplishmentHandler.emitAccomplishment({
+//   skillCategory: "reading",
+//   accomplishmentKeyword: "chapter",
+//   description: "Read chapter 1 of the book",
+//   durationMinutes: 10,
+//   meta: [
+//     {
+//       key: "book",
+//       value: "The Great Gatsby",
+//       description: "The book I read",
+//     },
+//   ],
+// });

package/dist/rimori-client/src/controller/AudioController.d.ts

@@ -0,0 +1,37 @@
+/**
+ * AudioController is a class that provides methods to record audio. It is a wrapper around the Capacitor Voice Recorder plugin. For more information, see https://github.com/tchvu3/capacitor-voice-recorder.
+ *
+ * @example
+ * const audioController = new AudioController();
+ * await audioController.startRecording();
+ */
+export declare class AudioController {
+    private pluginId;
+    constructor(pluginId: string);
+    /**
+     * Start the recording.
+     *
+     * @example
+     * const audioController = new AudioController();
+     * await audioController.startRecording();
+     * @returns void
+     */
+    startRecording(): Promise<void>;
+    /**
+     * Stop the recording and return the audio data.
+     * @returns The audio data.
+     *
+     * @example
+     * const audioRef = new Audio(`data:${mimeType};base64,${base64Sound}`)
+     * audioRef.oncanplaythrough = () => audioRef.play()
+     * audioRef.load()
+     */
+    stopRecording(): Promise<{
+        recording: Blob;
+        msDuration: number;
+        mimeType: string;
+    }>;
+    pauseRecording(): Promise<boolean>;
+    resumeRecording(): Promise<boolean>;
+    getCurrentStatus(): Promise<'RECORDING' | 'PAUSED' | 'NONE'>;
+}

package/dist/rimori-client/src/controller/AudioController.js

@@ -0,0 +1,68 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { EventBus } from '../fromRimori/EventBus';
+/**
+ * AudioController is a class that provides methods to record audio. It is a wrapper around the Capacitor Voice Recorder plugin. For more information, see https://github.com/tchvu3/capacitor-voice-recorder.
+ *
+ * @example
+ * const audioController = new AudioController();
+ * await audioController.startRecording();
+ */
+export class AudioController {
+    constructor(pluginId) {
+        this.pluginId = pluginId;
+    }
+    /**
+     * Start the recording.
+     *
+     * @example
+     * const audioController = new AudioController();
+     * await audioController.startRecording();
+     * @returns void
+     */
+    startRecording() {
+        return __awaiter(this, void 0, void 0, function* () {
+            EventBus.emit(this.pluginId, 'global.microphone.triggerStartRecording');
+        });
+    }
+    /**
+     * Stop the recording and return the audio data.
+     * @returns The audio data.
+     *
+     * @example
+     * const audioRef = new Audio(`data:${mimeType};base64,${base64Sound}`)
+     * audioRef.oncanplaythrough = () => audioRef.play()
+     * audioRef.load()
+     */
+    stopRecording() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield EventBus.request(this.pluginId, 'global.microphone.triggerStopRecording');
+            return result.data;
+        });
+    }
+    pauseRecording() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield EventBus.request(this.pluginId, 'global.microphone.triggerPauseRecording');
+            return result.data;
+        });
+    }
+    resumeRecording() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield EventBus.request(this.pluginId, 'global.microphone.triggerResumeRecording');
+            return result.data;
+        });
+    }
+    getCurrentStatus() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield EventBus.request(this.pluginId, 'global.microphone.triggerGetCurrentStatus');
+            return result.data;
+        });
+    }
+}

package/dist/rimori-client/src/controller/ExerciseController.d.ts

@@ -0,0 +1,54 @@
+import { SupabaseClient } from '@supabase/supabase-js';
+export type TriggerAction = {
+    action_key: string;
+} & Record<string, string | number | boolean>;
+export interface CreateExerciseParams {
+    plugin_id: string;
+    start_date: string;
+    end_date: string;
+    trigger_action: TriggerAction;
+    name: string;
+    description: string;
+    estimated_duration: number;
+}
+export interface Exercise {
+    id: string;
+    plugin_id: string;
+    start_date: string;
+    end_date: string;
+    trigger_action: TriggerAction;
+    name: string;
+    description: string;
+    estimated_duration: number;
+    created_at?: string;
+    updated_at?: string;
+}
+export declare class ExerciseController {
+    private supabase;
+    constructor(supabase: SupabaseClient);
+    /**
+     * Fetches weekly exercises from the weekly_exercises view.
+     * Shows exercises for the current week that haven't expired.
+     * @returns Array of exercise objects.
+     */
+    viewWeeklyExercises(): Promise<Exercise[]>;
+    /**
+     * Creates a new exercise via the backend API.
+     * @param token The token to use for authentication.
+     * @param backendUrl The URL of the backend API.
+     * @param params Exercise creation parameters.
+     * @returns Created exercise object.
+     */
+    addExercise(token: string, backendUrl: string, params: CreateExerciseParams): Promise<Exercise>;
+    /**
+     * Deletes an exercise via the backend API.
+     * @param token The token to use for authentication.
+     * @param backendUrl The URL of the backend API.
+     * @param exerciseId The exercise ID to delete.
+     * @returns Success status.
+     */
+    deleteExercise(token: string, backendUrl: string, id: string): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+}

package/dist/rimori-client/src/controller/ExerciseController.js

@@ -0,0 +1,74 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+export class ExerciseController {
+    constructor(supabase) {
+        this.supabase = supabase;
+    }
+    /**
+     * Fetches weekly exercises from the weekly_exercises view.
+     * Shows exercises for the current week that haven't expired.
+     * @returns Array of exercise objects.
+     */
+    viewWeeklyExercises() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data, error } = yield this.supabase.from('weekly_exercises').select('*');
+            if (error) {
+                throw new Error(`Failed to fetch weekly exercises: ${error.message}`);
+            }
+            return data || [];
+        });
+    }
+    /**
+     * Creates a new exercise via the backend API.
+     * @param token The token to use for authentication.
+     * @param backendUrl The URL of the backend API.
+     * @param params Exercise creation parameters.
+     * @returns Created exercise object.
+     */
+    addExercise(token, backendUrl, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield fetch(`${backendUrl}/exercises`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: `Bearer ${token}`,
+                },
+                body: JSON.stringify(params),
+            });
+            if (!response.ok) {
+                const errorText = yield response.text();
+                throw new Error(`Failed to create exercise: ${errorText}`);
+            }
+            return yield response.json();
+        });
+    }
+    /**
+     * Deletes an exercise via the backend API.
+     * @param token The token to use for authentication.
+     * @param backendUrl The URL of the backend API.
+     * @param exerciseId The exercise ID to delete.
+     * @returns Success status.
+     */
+    deleteExercise(token, backendUrl, id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield fetch(`${backendUrl}/exercises/${id}`, {
+                method: 'DELETE',
+                headers: {
+                    Authorization: `Bearer ${token}`,
+                },
+            });
+            if (!response.ok) {
+                const errorText = yield response.text();
+                throw new Error(`Failed to delete exercise: ${errorText}`);
+            }
+            return yield response.json();
+        });
+    }
+}