langflow-mcp-server 1.2.0 → 2.1.0

package/dist/services/langflow-client.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LangflowClient = void 0;
 const axios_1 = __importDefault(require("axios"));
+const form_data_1 = __importDefault(require("form-data"));
 class LangflowClient {
     constructor(config) {
         this.config = config;
@@ -37,7 +38,7 @@ class LangflowClient {
     }
     async getFlow(flowId) {
         try {
-            const response = await this.client.get(`/flows/${flowId}`);
+            const response = await this.client.get(`/flows/${encodeURIComponent(flowId)}`);
             return response.data;
         }
         catch (error) {
@@ -46,7 +47,7 @@ class LangflowClient {
     }
     async updateFlow(flowId, updates) {
         try {
-            const response = await this.client.patch(`/flows/${flowId}`, updates);
+            const response = await this.client.patch(`/flows/${encodeURIComponent(flowId)}`, updates);
             return response.data;
         }
         catch (error) {
@@ -55,7 +56,7 @@ class LangflowClient {
     }
     async deleteFlow(flowId) {
         try {
-            await this.client.delete(`/flows/${flowId}`);
+            await this.client.delete(`/flows/${encodeURIComponent(flowId)}`);
         }
         catch (error) {
             throw this.handleError(error, `Failed to delete flow ${flowId}`);
@@ -80,6 +81,9 @@ class LangflowClient {
                 Object.entries(response.data).forEach(([category, items]) => {
                     if (items && typeof items === 'object') {
                         Object.entries(items).forEach(([name, info]) => {
+                            if (!info || typeof info !== 'object') {
+                                return;
+                            }
                             components.push({
                                 name,
                                 display_name: info.display_name || name,
@@ -98,7 +102,7 @@ class LangflowClient {
     }
     async runFlow(flowIdOrName, inputRequest, stream = false) {
         try {
-            const response = await this.client.post(`/run/${flowIdOrName}`, {
+            const response = await this.client.post(`/run/${encodeURIComponent(flowIdOrName)}`, {
                 ...inputRequest,
                 stream
             });
@@ -110,7 +114,7 @@ class LangflowClient {
     }
     async triggerWebhook(flowIdOrName, inputRequest) {
         try {
-            const response = await this.client.post(`/webhook/${flowIdOrName}`, inputRequest);
+            const response = await this.client.post(`/webhook/${encodeURIComponent(flowIdOrName)}`, inputRequest);
             return response.data;
         }
         catch (error) {
@@ -164,7 +168,7 @@ class LangflowClient {
     }
     async getFolder(folderId) {
         try {
-            const response = await this.client.get(`/folders/${folderId}`);
+            const response = await this.client.get(`/folders/${encodeURIComponent(folderId)}`);
             return response.data;
         }
         catch (error) {
@@ -173,7 +177,7 @@ class LangflowClient {
     }
     async updateFolder(folderId, updates) {
         try {
-            const response = await this.client.patch(`/folders/${folderId}`, updates);
+            const response = await this.client.patch(`/folders/${encodeURIComponent(folderId)}`, updates);
             return response.data;
         }
         catch (error) {
@@ -182,7 +186,7 @@ class LangflowClient {
     }
     async deleteFolder(folderId) {
         try {
-            await this.client.delete(`/folders/${folderId}`);
+            await this.client.delete(`/folders/${encodeURIComponent(folderId)}`);
         }
         catch (error) {
             throw this.handleError(error, `Failed to delete folder ${folderId}`);
@@ -208,7 +212,7 @@ class LangflowClient {
     }
     async getProject(projectId) {
         try {
-            const response = await this.client.get(`/projects/${projectId}`);
+            const response = await this.client.get(`/projects/${encodeURIComponent(projectId)}`);
             return response.data;
         }
         catch (error) {
@@ -217,7 +221,7 @@ class LangflowClient {
     }
     async updateProject(projectId, updates) {
         try {
-            const response = await this.client.patch(`/projects/${projectId}`, updates);
+            const response = await this.client.patch(`/projects/${encodeURIComponent(projectId)}`, updates);
             return response.data;
         }
         catch (error) {
@@ -226,7 +230,7 @@ class LangflowClient {
     }
     async deleteProject(projectId) {
         try {
-            await this.client.delete(`/projects/${projectId}`);
+            await this.client.delete(`/projects/${encodeURIComponent(projectId)}`);
         }
         catch (error) {
             throw this.handleError(error, `Failed to delete project ${projectId}`);
@@ -243,7 +247,7 @@ class LangflowClient {
     }
     async downloadProject(projectId) {
         try {
-            const response = await this.client.get(`/projects/download/${projectId}`);
+            const response = await this.client.get(`/projects/download/${encodeURIComponent(projectId)}`);
             return response.data;
         }
         catch (error) {
@@ -270,7 +274,7 @@ class LangflowClient {
     }
     async updateVariable(variableId, updates) {
         try {
-            const response = await this.client.patch(`/variables/${variableId}`, updates);
+            const response = await this.client.patch(`/variables/${encodeURIComponent(variableId)}`, updates);
             return response.data;
         }
         catch (error) {
@@ -279,7 +283,7 @@ class LangflowClient {
     }
     async deleteVariable(variableId) {
         try {
-            await this.client.delete(`/variables/${variableId}`);
+            await this.client.delete(`/variables/${encodeURIComponent(variableId)}`);
         }
         catch (error) {
             throw this.handleError(error, `Failed to delete variable ${variableId}`);
@@ -287,7 +291,7 @@ class LangflowClient {
     }
     async buildFlow(flowId, request, params) {
         try {
-            const response = await this.client.post(`/build/${flowId}/flow`, request, { params });
+            const response = await this.client.post(`/build/${encodeURIComponent(flowId)}/flow`, request, { params });
             return response.data;
         }
         catch (error) {
@@ -296,7 +300,7 @@ class LangflowClient {
     }
     async getBuildStatus(jobId, eventDelivery = 'polling') {
         try {
-            const response = await this.client.get(`/build/${jobId}/events`, { params: { event_delivery: eventDelivery } });
+            const response = await this.client.get(`/build/${encodeURIComponent(jobId)}/events`, { params: { event_delivery: eventDelivery } });
             return response.data;
         }
         catch (error) {
@@ -305,7 +309,7 @@ class LangflowClient {
     }
     async cancelBuild(jobId) {
         try {
-            const response = await this.client.post(`/build/${jobId}/cancel`);
+            const response = await this.client.post(`/build/${encodeURIComponent(jobId)}/cancel`);
             return response.data;
         }
         catch (error) {
@@ -349,6 +353,526 @@ class LangflowClient {
             throw this.handleError(error, 'Failed to bulk delete knowledge bases');
         }
     }
+    async uploadFile(params) {
+        try {
+            const formData = new form_data_1.default();
+            formData.append('file', params.file, params.file_name);
+            const response = await this.client.post(`/files/upload/${encodeURIComponent(params.flow_id)}`, formData, {
+                headers: {
+                    ...formData.getHeaders()
+                }
+            });
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to upload file to flow ${params.flow_id}`);
+        }
+    }
+    async downloadFile(params) {
+        try {
+            const response = await this.client.get(`/files/download/${encodeURIComponent(params.flow_id)}/${encodeURIComponent(params.file_name)}`, {
+                responseType: 'arraybuffer'
+            });
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to download file ${params.file_name} from flow ${params.flow_id}`);
+        }
+    }
+    async listFiles(params) {
+        try {
+            const response = await this.client.get(`/files/list/${encodeURIComponent(params.flow_id)}`);
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to list files for flow ${params.flow_id}`);
+        }
+    }
+    async deleteFile(params) {
+        try {
+            const response = await this.client.delete(`/files/delete/${encodeURIComponent(params.flow_id)}/${encodeURIComponent(params.file_name)}`);
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to delete file ${params.file_name} from flow ${params.flow_id}`);
+        }
+    }
+    async getFileImage(params) {
+        try {
+            const response = await this.client.get(`/files/images/${encodeURIComponent(params.flow_id)}/${encodeURIComponent(params.file_name)}`, {
+                responseType: 'arraybuffer'
+            });
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to get image ${params.file_name} from flow ${params.flow_id}`);
+        }
+    }
+    async listProfilePictures() {
+        try {
+            const response = await this.client.get('/files/profile_pictures/list');
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to list profile pictures');
+        }
+    }
+    async getProfilePicture(folderName, fileName) {
+        try {
+            const response = await this.client.get(`/files/profile_pictures/${folderName}/${fileName}`, {
+                responseType: 'arraybuffer'
+            });
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to get profile picture ${folderName}/${fileName}`);
+        }
+    }
+    async validateCode(code) {
+        try {
+            const response = await this.client.post('/validate/code', { code });
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to validate code');
+        }
+    }
+    async validatePrompt(prompt) {
+        try {
+            const response = await this.client.post('/validate/prompt', { prompt });
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to validate prompt');
+        }
+    }
+    async checkStore() {
+        try {
+            const response = await this.client.get('/store/check/');
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to check store availability');
+        }
+    }
+    async checkStoreApiKey(apiKey) {
+        try {
+            const response = await this.client.get('/store/check/api_key', {
+                headers: {
+                    'x-store-api-key': apiKey
+                }
+            });
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to check store API key');
+        }
+    }
+    async listStoreComponents(params) {
+        try {
+            const response = await this.client.get('/store/components/', { params });
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to list store components');
+        }
+    }
+    async getStoreComponent(componentId) {
+        try {
+            const response = await this.client.get(`/store/components/${encodeURIComponent(componentId)}`);
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to get store component ${componentId}`);
+        }
+    }
+    async listStoreTags() {
+        try {
+            const response = await this.client.get('/store/tags');
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to list store tags');
+        }
+    }
+    async getUserLikes() {
+        try {
+            const response = await this.client.get('/store/users/likes');
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to get user likes');
+        }
+    }
+    async runFlowAdvanced(flowId, request, stream = false) {
+        try {
+            const response = await this.client.post(`/run/advanced/${encodeURIComponent(flowId)}`, {
+                ...request,
+                stream
+            });
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to run flow ${flowId} (advanced)`);
+        }
+    }
+    async processFlow(flowId, request) {
+        try {
+            const response = await this.client.post(`/process/${encodeURIComponent(flowId)}`, request);
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to process flow ${flowId}`);
+        }
+    }
+    async predictFlow(flowId, request) {
+        try {
+            const response = await this.client.post(`/predict/${encodeURIComponent(flowId)}`, request);
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to predict flow ${flowId}`);
+        }
+    }
+    async getMonitorBuilds(params) {
+        try {
+            const response = await this.client.get('/monitor/builds', { params });
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to get monitor builds for flow ${params.flow_id}`);
+        }
+    }
+    async getMonitorMessages(params) {
+        try {
+            const response = await this.client.get('/monitor/messages', { params });
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to get monitor messages');
+        }
+    }
+    async getMonitorMessage(messageId) {
+        try {
+            const response = await this.client.get(`/monitor/messages/${encodeURIComponent(messageId)}`);
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to get monitor message ${messageId}`);
+        }
+    }
+    async getMonitorSessions(params) {
+        try {
+            const response = await this.client.get('/monitor/messages/sessions', { params });
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to get monitor sessions');
+        }
+    }
+    async getMonitorSessionMessages(sessionId) {
+        try {
+            const response = await this.client.get(`/monitor/messages/session/${encodeURIComponent(sessionId)}`);
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to get session messages for ${sessionId}`);
+        }
+    }
+    async migrateMonitorSession(params) {
+        try {
+            const response = await this.client.patch(`/monitor/messages/session/${encodeURIComponent(params.old_session_id)}`, null, { params: { new_session_id: params.new_session_id } });
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to migrate session ${params.old_session_id}`);
+        }
+    }
+    async getMonitorTransactions(params) {
+        try {
+            const response = await this.client.get('/monitor/transactions', { params });
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to get monitor transactions');
+        }
+    }
+    async deleteMonitorBuilds(flowId) {
+        try {
+            await this.client.delete('/monitor/builds', {
+                params: { flow_id: flowId }
+            });
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to delete monitor builds for flow ${flowId}`);
+        }
+    }
+    async deleteMonitorMessages(messageIds) {
+        try {
+            const response = await this.client.delete('/monitor/messages', { data: messageIds });
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to delete monitor messages');
+        }
+    }
+    async buildVertices(flowId, request) {
+        try {
+            const response = await this.client.post(`/build/${encodeURIComponent(flowId)}/vertices`, {}, { params: request });
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to build vertices for flow ${flowId}`);
+        }
+    }
+    async getVertex(params) {
+        try {
+            const response = await this.client.get(`/build/${encodeURIComponent(params.flow_id)}/vertices/${encodeURIComponent(params.vertex_id)}`);
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to get vertex ${params.vertex_id}`);
+        }
+    }
+    async streamVertexBuild(params) {
+        try {
+            const response = await this.client.get(`/build/${encodeURIComponent(params.flow_id)}/${encodeURIComponent(params.vertex_id)}/stream`);
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to stream vertex build ${params.vertex_id}`);
+        }
+    }
+    async getVersion() {
+        try {
+            const response = await this.client.get('/version');
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to get version');
+        }
+    }
+    async listUsers(params) {
+        try {
+            const response = await this.client.get('/users/', { params });
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to list users');
+        }
+    }
+    async getCurrentUser() {
+        try {
+            const response = await this.client.get('/users/whoami');
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to get current user');
+        }
+    }
+    async getUser(userId) {
+        try {
+            const response = await this.client.get(`/users/${encodeURIComponent(userId)}`);
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to get user ${userId}`);
+        }
+    }
+    async updateUser(userId, updates) {
+        try {
+            const response = await this.client.patch(`/users/${encodeURIComponent(userId)}`, updates);
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to update user ${userId}`);
+        }
+    }
+    async resetUserPassword(userId, newPassword) {
+        try {
+            const response = await this.client.patch(`/users/${userId}/reset-password`, {
+                password: newPassword
+            });
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to reset password for user ${userId}`);
+        }
+    }
+    async listApiKeys() {
+        try {
+            const response = await this.client.get('/api_key/');
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to list API keys');
+        }
+    }
+    async createApiKey(name) {
+        try {
+            const response = await this.client.post('/api_key/', { name });
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to create API key');
+        }
+    }
+    async deleteApiKey(apiKeyId) {
+        try {
+            await this.client.delete(`/api_key/${encodeURIComponent(apiKeyId)}`);
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to delete API key ${apiKeyId}`);
+        }
+    }
+    async listCustomComponents() {
+        try {
+            const response = await this.client.get('/custom_component');
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to list custom components');
+        }
+    }
+    async createCustomComponent(component) {
+        try {
+            const response = await this.client.post('/custom_component', component);
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to create custom component');
+        }
+    }
+    async login(username, password) {
+        try {
+            const formData = new URLSearchParams();
+            formData.append('username', username);
+            formData.append('password', password);
+            const response = await this.client.post('/login', formData, {
+                headers: {
+                    'Content-Type': 'application/x-www-form-urlencoded'
+                }
+            });
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to login');
+        }
+    }
+    async autoLogin() {
+        try {
+            const response = await this.client.get('/auto_login');
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to auto login');
+        }
+    }
+    async refreshToken() {
+        try {
+            const response = await this.client.post('/refresh');
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to refresh token');
+        }
+    }
+    async logout() {
+        try {
+            const response = await this.client.post('/logout');
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to logout');
+        }
+    }
+    async getPublicFlow(flowId) {
+        try {
+            const response = await this.client.get(`/flows/public_flow/${encodeURIComponent(flowId)}`);
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to get public flow ${flowId}`);
+        }
+    }
+    async batchCreateFlows(flows) {
+        try {
+            const response = await this.client.post('/flows/batch/', flows);
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to batch create flows');
+        }
+    }
+    async getTaskStatus(taskId) {
+        try {
+            const response = await this.client.get(`/task/${encodeURIComponent(taskId)}`);
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to get task status ${taskId}`);
+        }
+    }
+    async downloadFolder(folderId) {
+        try {
+            const response = await this.client.get(`/folders/download/${folderId}`, {
+                responseType: 'arraybuffer'
+            });
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to download folder ${folderId}`);
+        }
+    }
+    async uploadFolder(fileContent, fileName) {
+        try {
+            const formData = new form_data_1.default();
+            formData.append('file', fileContent, fileName);
+            const response = await this.client.post('/folders/upload/', formData, {
+                headers: {
+                    ...formData.getHeaders()
+                }
+            });
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to upload folder');
+        }
+    }
+    async listStarterProjects() {
+        try {
+            const response = await this.client.get('/starter-projects/');
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to list starter projects');
+        }
+    }
+    async uploadKnowledgeBase(kbName, fileContent, fileName) {
+        try {
+            const formData = new form_data_1.default();
+            formData.append('file', fileContent, fileName);
+            const response = await this.client.post('/knowledge_bases/', formData, {
+                params: { kb_name: kbName },
+                headers: {
+                    ...formData.getHeaders()
+                }
+            });
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to upload knowledge base ${kbName}`);
+        }
+    }
+    async listElevenLabsVoices() {
+        try {
+            const response = await this.client.get('/voice/elevenlabs/voice_ids');
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to list ElevenLabs voices');
+        }
+    }
     async healthCheck() {
         try {
             await this.client.get('/health');
@@ -358,12 +882,334 @@ class LangflowClient {
             return false;
         }
     }
+    async getLogs(stream = false) {
+        try {
+            const endpoint = stream ? '/logs-stream' : '/logs';
+            const response = await this.client.get(endpoint, {
+                responseType: stream ? 'stream' : 'json'
+            });
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to get logs');
+        }
+    }
+    async getMonitorMessageById(messageId) {
+        try {
+            const response = await this.client.get(`/monitor/messages/${encodeURIComponent(messageId)}`);
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to get monitor message');
+        }
+    }
+    async getMonitorTransactionById(transactionId) {
+        try {
+            const response = await this.client.get(`/monitor/transactions/${encodeURIComponent(transactionId)}`);
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to get monitor transaction');
+        }
+    }
+    async getMonitorVertexBuilds(params) {
+        try {
+            const response = await this.client.get('/monitor/vertices/builds', { params });
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to get monitor vertex builds');
+        }
+    }
+    async getMonitorVertexBuildById(vertexBuildId) {
+        try {
+            const response = await this.client.get(`/monitor/vertices/builds/${encodeURIComponent(vertexBuildId)}`);
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to get monitor vertex build');
+        }
+    }
+    async uploadTextData(params) {
+        try {
+            const response = await this.client.post(`/files/upload/${encodeURIComponent(params.flow_id)}/text`, {
+                text: params.text_data,
+                file_name: params.file_name
+            });
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to upload text data to flow ${params.flow_id}`);
+        }
+    }
+    async installStoreComponent(componentId) {
+        try {
+            const response = await this.client.post(`/store/components/${componentId}/install`);
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to install store component ${componentId}`);
+        }
+    }
+    async updateCustomComponent(componentId, updates) {
+        try {
+            const response = await this.client.patch(`/custom_component/${encodeURIComponent(componentId)}`, updates);
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to update custom component ${componentId}`);
+        }
+    }
+    async deleteCustomComponent(componentId) {
+        try {
+            await this.client.delete(`/custom_component/${encodeURIComponent(componentId)}`);
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to delete custom component ${componentId}`);
+        }
+    }
+    async deleteUser(userId) {
+        try {
+            await this.client.delete(`/users/${encodeURIComponent(userId)}`);
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to delete user ${userId}`);
+        }
+    }
+    async getConfig() {
+        try {
+            const response = await this.client.get('/config');
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to get configuration');
+        }
+    }
+    async updateConfig(config) {
+        try {
+            const response = await this.client.patch('/config', config);
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to update configuration');
+        }
+    }
+    async getStats() {
+        try {
+            const response = await this.client.get('/stats');
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to get statistics');
+        }
+    }
+    async exportFlow(flowId) {
+        try {
+            const response = await this.client.get(`/flows/${encodeURIComponent(flowId)}/export`);
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to export flow ${flowId}`);
+        }
+    }
+    async importFlow(flowData) {
+        try {
+            const response = await this.client.post('/flows/import', flowData);
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to import flow');
+        }
+    }
+    async cloneFlow(flowId, name) {
+        try {
+            const response = await this.client.post(`/flows/${encodeURIComponent(flowId)}/clone`, { name });
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to clone flow ${flowId}`);
+        }
+    }
+    async getFlowDependencies(flowId) {
+        try {
+            const response = await this.client.get(`/flows/${encodeURIComponent(flowId)}/dependencies`);
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to get flow dependencies ${flowId}`);
+        }
+    }
+    async getAiNodes() {
+        try {
+            const response = await this.client.get('/ai_nodes');
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to get AI nodes');
+        }
+    }
+    async buildVertex(params) {
+        try {
+            const response = await this.client.post(`/build/${encodeURIComponent(params.flow_id)}/vertices/${encodeURIComponent(params.vertex_id)}`, params.inputs || {});
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to build vertex ${params.vertex_id}`);
+        }
+    }
+    async cancelExecution(params) {
+        try {
+            const response = await this.client.post(`/executions/${encodeURIComponent(params.execution_id)}/cancel`);
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to cancel execution ${params.execution_id}`);
+        }
+    }
+    async getExecutionResult(params) {
+        try {
+            const response = await this.client.get(`/executions/${encodeURIComponent(params.execution_id)}/result`);
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to get execution result ${params.execution_id}`);
+        }
+    }
+    async getFileMetadata(params) {
+        try {
+            const response = await this.client.get(`/files/${encodeURIComponent(params.flow_id)}/${encodeURIComponent(params.file_name)}/metadata`);
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to get file metadata ${params.file_name}`);
+        }
+    }
+    async getHealth() {
+        try {
+            const response = await this.client.get('/health');
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to get health status');
+        }
+    }
+    async getUserById(userId) {
+        try {
+            const response = await this.client.get(`/users/${encodeURIComponent(userId)}`);
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to get user ${userId}`);
+        }
+    }
+    async listFilesDetailed(params) {
+        try {
+            const response = await this.client.get(`/files/${encodeURIComponent(params.flow_id)}/detailed`);
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to get detailed file list for flow ${params.flow_id}`);
+        }
+    }
+    async register(username, password, email) {
+        try {
+            const response = await this.client.post('/register', {
+                username,
+                password,
+                email
+            });
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to register user');
+        }
+    }
+    async runAdvancedExecution(params) {
+        try {
+            const { flow_id, ...request } = params;
+            const response = await this.client.post(`/executions/${encodeURIComponent(flow_id)}/advanced`, request);
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to execute advanced flow ${params.flow_id}`);
+        }
+    }
+    async searchStoreComponents(query, params) {
+        try {
+            const response = await this.client.get('/store/components/search', {
+                params: { q: query, ...params }
+            });
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to search store components');
+        }
+    }
+    async uninstallStoreComponent(componentId) {
+        try {
+            const response = await this.client.delete(`/store/components/${componentId}/uninstall`);
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to uninstall store component ${componentId}`);
+        }
+    }
+    async updateStoreComponent(componentId, updates) {
+        try {
+            const response = await this.client.patch(`/store/components/${encodeURIComponent(componentId)}`, updates);
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to update store component ${componentId}`);
+        }
+    }
+    async validateConnection(connectionData) {
+        try {
+            const response = await this.client.post('/validate/connection', connectionData);
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to validate connection');
+        }
+    }
+    async validateFlow(params) {
+        try {
+            const response = await this.client.post(`/flows/${encodeURIComponent(params.flow_id)}/validate`);
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to validate flow ${params.flow_id}`);
+        }
+    }
     handleError(error, message) {
         if (axios_1.default.isAxiosError(error)) {
             const axiosError = error;
             const status = axiosError.response?.status;
             const data = axiosError.response?.data;
-            return new Error(`${message}: ${status ? `HTTP ${status}` : 'Network error'} - ${data ? JSON.stringify(data) : axiosError.message}`);
+            const sanitize = (val, depth = 0, seen = new WeakSet()) => {
+                const MAX_DEPTH = 10;
+                const SENSITIVE_KEYS = new Set([
+                    'authorization', 'api_key', 'x-api-key', 'password', 'new_password', 'token',
+                    'access_token', 'refresh_token', 'secret', 'api-key',
+                    'bearer', 'private_key', 'session_id', 'cookie', 'set-cookie',
+                    'x-store-api-key'
+                ]);
+                if (!val || typeof val !== 'object')
+                    return val;
+                if (depth > MAX_DEPTH)
+                    return '[max depth exceeded]';
+                if (Buffer.isBuffer(val) || val instanceof ArrayBuffer || ArrayBuffer.isView(val)) {
+                    return '[binary data]';
+                }
+                if (seen.has(val))
+                    return '[circular reference]';
+                seen.add(val);
+                if (Array.isArray(val))
+                    return val.map(v => sanitize(v, depth + 1, seen));
+                return Object.fromEntries(Object.entries(val).map(([k, v]) => [k, SENSITIVE_KEYS.has(k.toLowerCase()) ? '***REDACTED***' : sanitize(v, depth + 1, seen)]));
+            };
+            const safeData = data ? sanitize(data) : undefined;
+            return new Error(`${message}: ${status ? `HTTP ${status}` : 'Network error'} - ${safeData ? JSON.stringify(safeData) : axiosError.message}`);
         }
         if (error instanceof Error) {
             return new Error(`${message}: ${error.message}`);