langflow-mcp-server 1.2.0 → 2.0.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;
@@ -349,6 +350,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/${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/${params.flow_id}/${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/${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/${params.flow_id}/${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/${params.flow_id}/${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/${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/${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/${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/${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/${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/${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/${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/${flowId}/vertices`, 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/${params.flow_id}/vertices/${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/${params.flow_id}/${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/${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/${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/${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/${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/${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 +879,333 @@ 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/${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/${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/${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/${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/${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/${componentId}`);
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to delete custom component ${componentId}`);
+        }
+    }
+    async deleteUser(userId) {
+        try {
+            await this.client.delete(`/users/${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/${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/${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/${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/${params.flow_id}/vertices/${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/${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/${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/${params.flow_id}/${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/${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/${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/${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/${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/${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)
+                    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}`);