langflow-mcp-server 3.1.1 → 4.12.2

package/dist/services/langflow-client.js

@@ -100,12 +100,12 @@ class LangflowClient {
             throw this.handleError(error, 'Failed to list components');
         }
     }
-    async runFlow(flowIdOrName, inputRequest, stream = false) {
+    async runFlow(flowIdOrName, inputRequest, stream = false, context) {
         try {
-            const response = await this.client.post(`/run/${encodeURIComponent(flowIdOrName)}`, {
-                ...inputRequest,
-                stream
-            });
+            if (stream) {
+                throw new Error('Streaming run responses are not supported by this MCP client');
+            }
+            const response = await this.client.post(`/run/${encodeURIComponent(flowIdOrName)}`, { input_request: inputRequest, context }, { params: { stream } });
             return response.data;
         }
         catch (error) {
@@ -228,6 +228,15 @@ class LangflowClient {
             throw this.handleError(error, `Failed to update project ${projectId}`);
         }
     }
+    async upsertProject(projectId, body) {
+        try {
+            const response = await this.client.put(`/projects/${encodeURIComponent(projectId)}`, body);
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to upsert project ${projectId}`);
+        }
+    }
     async deleteProject(projectId) {
         try {
             await this.client.delete(`/projects/${encodeURIComponent(projectId)}`);
@@ -316,6 +325,36 @@ class LangflowClient {
             throw this.handleError(error, `Failed to cancel build job ${jobId}`);
         }
     }
+    async buildPublicFlow(flowId, request, params) {
+        try {
+            const response = await this.client.post('/build_public_tmp/' + encodeURIComponent(flowId) + '/flow', request, { params });
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to build public flow ' + flowId);
+        }
+    }
+    async getPublicBuildEvents(jobId, eventDelivery = 'streaming') {
+        try {
+            const response = await this.client.get('/build_public_tmp/' + encodeURIComponent(jobId) + '/events', {
+                params: { event_delivery: eventDelivery },
+                responseType: eventDelivery === 'streaming' ? 'text' : 'json'
+            });
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to get public build events for job ' + jobId);
+        }
+    }
+    async cancelPublicBuild(jobId) {
+        try {
+            const response = await this.client.post('/build_public_tmp/' + encodeURIComponent(jobId) + '/cancel');
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to cancel public build job ' + jobId);
+        }
+    }
     async listKnowledgeBases() {
         try {
             const response = await this.client.get('/knowledge_bases');
@@ -470,7 +509,10 @@ class LangflowClient {
     }
     async listStoreComponents(params) {
         try {
-            const response = await this.client.get('/store/components/', { params });
+            const response = await this.client.get('/store/components/', {
+                params,
+                paramsSerializer: { indexes: null }
+            });
             return response.data;
         }
         catch (error) {
@@ -551,8 +593,12 @@ class LangflowClient {
     }
     async getMonitorMessage(messageId) {
         try {
-            const response = await this.client.get(`/monitor/messages/${encodeURIComponent(messageId)}`);
-            return response.data;
+            const response = await this.client.get('/monitor/messages');
+            const message = response.data.find(m => m.id === messageId);
+            if (!message) {
+                throw new Error(`Monitor message ${messageId} not found`);
+            }
+            return message;
         }
         catch (error) {
             throw this.handleError(error, `Failed to get monitor message ${messageId}`);
@@ -569,7 +615,9 @@ class LangflowClient {
     }
     async getMonitorSessionMessages(sessionId) {
         try {
-            const response = await this.client.get(`/monitor/messages/session/${encodeURIComponent(sessionId)}`);
+            const response = await this.client.get('/monitor/messages', {
+                params: { session_id: sessionId }
+            });
             return response.data;
         }
         catch (error) {
@@ -623,15 +671,6 @@ class LangflowClient {
             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`);
@@ -668,15 +707,6 @@ class LangflowClient {
             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);
@@ -723,15 +753,6 @@ class LangflowClient {
             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);
@@ -848,15 +869,7 @@ class LangflowClient {
     }
     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;
+            return await this.ingestKnowledgeBase(kbName, [{ buffer: fileContent, filename: fileName }]);
         }
         catch (error) {
             throw this.handleError(error, `Failed to upload knowledge base ${kbName}`);
@@ -873,17 +886,29 @@ class LangflowClient {
     }
     async healthCheck() {
         try {
-            await this.client.get('/health');
+            await this.client.get('/health', { baseURL: this.config.baseUrl });
             return true;
         }
         catch (error) {
             return false;
         }
     }
+    async getHealthz() {
+        try {
+            const response = await this.client.get('/healthz', {
+                baseURL: this.config.baseUrl
+            });
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to get readiness health status');
+        }
+    }
     async getLogs(stream = false) {
         try {
             const endpoint = stream ? '/logs-stream' : '/logs';
             const response = await this.client.get(endpoint, {
+                baseURL: this.config.baseUrl,
                 responseType: stream ? 'stream' : 'json'
             });
             return response.data;
@@ -892,320 +917,1445 @@ class LangflowClient {
             throw this.handleError(error, 'Failed to get logs');
         }
     }
-    async getMonitorMessageById(messageId) {
+    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 buildVertex(params) {
         try {
-            const response = await this.client.get(`/monitor/messages/${encodeURIComponent(messageId)}`);
+            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 get monitor message');
+            throw this.handleError(error, `Failed to build vertex ${params.vertex_id}`);
         }
     }
-    async getMonitorTransactionById(transactionId) {
+    async getHealth() {
         try {
-            const response = await this.client.get(`/monitor/transactions/${encodeURIComponent(transactionId)}`);
+            const response = await this.client.get('/health', { baseURL: this.config.baseUrl });
             return response.data;
         }
         catch (error) {
-            throw this.handleError(error, 'Failed to get monitor transaction');
+            throw this.handleError(error, 'Failed to get health status');
         }
     }
-    async getMonitorVertexBuilds(params) {
+    async updateStoreComponent(componentId, updates) {
         try {
-            const response = await this.client.get('/monitor/vertices/builds', { params });
+            const response = await this.client.patch(`/store/components/${encodeURIComponent(componentId)}`, updates);
             return response.data;
         }
         catch (error) {
-            throw this.handleError(error, 'Failed to get monitor vertex builds');
+            throw this.handleError(error, `Failed to update store component ${componentId}`);
         }
     }
-    async getMonitorVertexBuildById(vertexBuildId) {
+    async runFlowSession(flowIdOrName, request, stream = false) {
         try {
-            const response = await this.client.get(`/monitor/vertices/builds/${encodeURIComponent(vertexBuildId)}`);
+            if (stream) {
+                throw new Error('Streaming run session responses are not supported by this MCP client');
+            }
+            const { context, ...inputRequest } = request;
+            const response = await this.client.post(`/run/session/${encodeURIComponent(flowIdOrName)}`, { input_request: inputRequest, context }, { params: { stream } });
             return response.data;
         }
         catch (error) {
-            throw this.handleError(error, 'Failed to get monitor vertex build');
+            throw this.handleError(error, `Failed to run flow session ${flowIdOrName}`);
         }
     }
-    async uploadTextData(params) {
+    async getRegistration() {
         try {
-            const response = await this.client.post(`/files/upload/${encodeURIComponent(params.flow_id)}/text`, {
-                text: params.text_data,
-                file_name: params.file_name
+            const response = await this.client.get('/api/v2/registration/', {
+                baseURL: this.config.baseUrl
             });
             return response.data;
         }
         catch (error) {
-            throw this.handleError(error, `Failed to upload text data to flow ${params.flow_id}`);
+            throw this.handleError(error, 'Failed to get registration status');
         }
     }
-    async installStoreComponent(componentId) {
+    async registerUser(email) {
         try {
-            const response = await this.client.post(`/store/components/${componentId}/install`);
+            const response = await this.client.post('/api/v2/registration/', { email }, { baseURL: this.config.baseUrl });
             return response.data;
         }
         catch (error) {
-            throw this.handleError(error, `Failed to install store component ${componentId}`);
+            throw this.handleError(error, 'Failed to register user');
         }
     }
-    async updateCustomComponent(componentId, updates) {
+    async replaceFlow(flowId, body) {
         try {
-            const response = await this.client.patch(`/custom_component/${encodeURIComponent(componentId)}`, updates);
+            const response = await this.client.put(`/flows/${encodeURIComponent(flowId)}`, body);
             return response.data;
         }
         catch (error) {
-            throw this.handleError(error, `Failed to update custom component ${componentId}`);
+            throw this.handleError(error, `Failed to replace flow ${flowId}`);
         }
     }
-    async deleteCustomComponent(componentId) {
+    async expandFlows(body) {
         try {
-            await this.client.delete(`/custom_component/${encodeURIComponent(componentId)}`);
+            const response = await this.client.post('/flows/expand/', body);
+            return response.data;
         }
         catch (error) {
-            throw this.handleError(error, `Failed to delete custom component ${componentId}`);
+            throw this.handleError(error, 'Failed to expand flows');
         }
     }
-    async deleteUser(userId) {
+    async getFlowEvents(flowId, params) {
         try {
-            await this.client.delete(`/users/${encodeURIComponent(userId)}`);
+            const response = await this.client.get(`/flows/${encodeURIComponent(flowId)}/events`, { params });
+            return response.data;
         }
         catch (error) {
-            throw this.handleError(error, `Failed to delete user ${userId}`);
+            throw this.handleError(error, `Failed to get events for flow ${flowId}`);
         }
     }
-    async getConfig() {
+    async createFlowEvent(flowId, body) {
         try {
-            const response = await this.client.get('/config');
+            const response = await this.client.post(`/flows/${encodeURIComponent(flowId)}/events`, body);
             return response.data;
         }
         catch (error) {
-            throw this.handleError(error, 'Failed to get configuration');
+            throw this.handleError(error, `Failed to create event for flow ${flowId}`);
         }
     }
-    async updateConfig(config) {
+    async listFlowVersions(flowId, params) {
         try {
-            const response = await this.client.patch('/config', config);
+            const response = await this.client.get(`/flows/${encodeURIComponent(flowId)}/versions/`, { params });
             return response.data;
         }
         catch (error) {
-            throw this.handleError(error, 'Failed to update configuration');
+            throw this.handleError(error, `Failed to list versions for flow ${flowId}`);
         }
     }
-    async getStats() {
+    async createFlowVersion(flowId, body) {
         try {
-            const response = await this.client.get('/stats');
+            const response = await this.client.post(`/flows/${encodeURIComponent(flowId)}/versions/`, body ?? {});
             return response.data;
         }
         catch (error) {
-            throw this.handleError(error, 'Failed to get statistics');
+            throw this.handleError(error, `Failed to create version for flow ${flowId}`);
         }
     }
-    async exportFlow(flowId) {
+    async getFlowVersion(flowId, versionId) {
         try {
-            const response = await this.client.get(`/flows/${encodeURIComponent(flowId)}/export`);
+            const response = await this.client.get(`/flows/${encodeURIComponent(flowId)}/versions/${encodeURIComponent(versionId)}`);
             return response.data;
         }
         catch (error) {
-            throw this.handleError(error, `Failed to export flow ${flowId}`);
+            throw this.handleError(error, `Failed to get version ${versionId} for flow ${flowId}`);
+        }
+    }
+    async deleteFlowVersion(flowId, versionId) {
+        try {
+            await this.client.delete(`/flows/${encodeURIComponent(flowId)}/versions/${encodeURIComponent(versionId)}`);
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to delete version ${versionId} for flow ${flowId}`);
         }
     }
-    async importFlow(flowData) {
+    async activateFlowVersion(flowId, versionId, params) {
         try {
-            const response = await this.client.post('/flows/import', flowData);
+            const response = await this.client.post(`/flows/${encodeURIComponent(flowId)}/versions/${encodeURIComponent(versionId)}/activate`, undefined, { params });
             return response.data;
         }
         catch (error) {
-            throw this.handleError(error, 'Failed to import flow');
+            throw this.handleError(error, `Failed to activate version ${versionId} for flow ${flowId}`);
         }
     }
-    async cloneFlow(flowId, name) {
+    async detectVariables(body) {
         try {
-            const response = await this.client.post(`/flows/${encodeURIComponent(flowId)}/clone`, { name });
+            const response = await this.client.post('/variables/detections', body);
             return response.data;
         }
         catch (error) {
-            throw this.handleError(error, `Failed to clone flow ${flowId}`);
+            throw this.handleError(error, 'Failed to detect variables');
         }
     }
-    async getFlowDependencies(flowId) {
+    async saveStoreApiKey(apiKey) {
         try {
-            const response = await this.client.get(`/flows/${encodeURIComponent(flowId)}/dependencies`);
+            const response = await this.client.post('/api_key/store', { api_key: apiKey });
             return response.data;
         }
         catch (error) {
-            throw this.handleError(error, `Failed to get flow dependencies ${flowId}`);
+            throw this.handleError(error, 'Failed to save store API key');
         }
     }
-    async getAiNodes() {
+    async updateCustomComponentCode(body) {
         try {
-            const response = await this.client.get('/ai_nodes');
+            const response = await this.client.post('/custom_component/update', body);
             return response.data;
         }
         catch (error) {
-            throw this.handleError(error, 'Failed to get AI nodes');
+            throw this.handleError(error, 'Failed to update custom component code');
         }
     }
-    async buildVertex(params) {
+    async createStoreComponent(body) {
         try {
-            const response = await this.client.post(`/build/${encodeURIComponent(params.flow_id)}/vertices/${encodeURIComponent(params.vertex_id)}`, params.inputs || {});
+            const response = await this.client.post('/store/components/', body);
             return response.data;
         }
         catch (error) {
-            throw this.handleError(error, `Failed to build vertex ${params.vertex_id}`);
+            throw this.handleError(error, 'Failed to create store component');
         }
     }
-    async cancelExecution(params) {
+    async likeStoreComponent(componentId) {
         try {
-            const response = await this.client.post(`/executions/${encodeURIComponent(params.execution_id)}/cancel`);
+            const response = await this.client.post(`/store/users/likes/${encodeURIComponent(componentId)}`);
             return response.data;
         }
         catch (error) {
-            throw this.handleError(error, `Failed to cancel execution ${params.execution_id}`);
+            throw this.handleError(error, `Failed to like store component ${componentId}`);
         }
     }
-    async getExecutionResult(params) {
+    async createResponse(body) {
         try {
-            const response = await this.client.get(`/executions/${encodeURIComponent(params.execution_id)}/result`);
+            const response = await this.client.post('/responses', body);
             return response.data;
         }
         catch (error) {
-            throw this.handleError(error, `Failed to get execution result ${params.execution_id}`);
+            throw this.handleError(error, 'Failed to create response');
         }
     }
-    async getFileMetadata(params) {
+    async getSession() {
         try {
-            const response = await this.client.get(`/files/${encodeURIComponent(params.flow_id)}/${encodeURIComponent(params.file_name)}/metadata`);
+            const response = await this.client.get('/session');
             return response.data;
         }
         catch (error) {
-            throw this.handleError(error, `Failed to get file metadata ${params.file_name}`);
+            throw this.handleError(error, 'Failed to get session');
         }
     }
-    async getHealth() {
+    async createUser(body) {
         try {
-            const response = await this.client.get('/health');
+            const response = await this.client.post('/users/', body);
             return response.data;
         }
         catch (error) {
-            throw this.handleError(error, 'Failed to get health status');
+            throw this.handleError(error, 'Failed to create user');
         }
     }
-    async getUserById(userId) {
+    async getWebhookEvents(flowIdOrName, params) {
         try {
-            const response = await this.client.get(`/users/${encodeURIComponent(userId)}`);
+            const response = await this.client.get(`/webhook-events/${encodeURIComponent(flowIdOrName)}`, { params });
             return response.data;
         }
         catch (error) {
-            throw this.handleError(error, `Failed to get user ${userId}`);
+            throw this.handleError(error, `Failed to get webhook events for ${flowIdOrName}`);
         }
     }
-    async listFilesDetailed(params) {
+    async getHealthCheck() {
         try {
-            const response = await this.client.get(`/files/${encodeURIComponent(params.flow_id)}/detailed`);
+            const response = await this.client.get('/health_check', { baseURL: this.config.baseUrl });
             return response.data;
         }
         catch (error) {
-            throw this.handleError(error, `Failed to get detailed file list for flow ${params.flow_id}`);
+            throw this.handleError(error, 'Failed to get health check');
         }
     }
-    async register(username, password, email) {
+    async uploadFlowFileLegacy(flowId, file, fileName) {
         try {
-            const response = await this.client.post('/register', {
-                username,
-                password,
-                email
+            const formData = new form_data_1.default();
+            formData.append('file', file, fileName);
+            const response = await this.client.post(`/upload/${encodeURIComponent(flowId)}`, formData, {
+                headers: {
+                    ...formData.getHeaders()
+                }
             });
             return response.data;
         }
         catch (error) {
-            throw this.handleError(error, 'Failed to register user');
+            throw this.handleError(error, `Failed to upload legacy file to flow ${flowId}`);
         }
     }
-    async runAdvancedExecution(params) {
+    async listFilesV2() {
         try {
-            const { flow_id, ...request } = params;
-            const response = await this.client.post(`/executions/${encodeURIComponent(flow_id)}/advanced`, request);
+            const response = await this.client.get('/api/v2/files', { baseURL: this.config.baseUrl });
             return response.data;
         }
         catch (error) {
-            throw this.handleError(error, `Failed to execute advanced flow ${params.flow_id}`);
+            throw this.handleError(error, 'Failed to list files (v2)');
         }
     }
-    async searchStoreComponents(query, params) {
+    async uploadFileV2(file, fileName, params) {
         try {
-            const response = await this.client.get('/store/components/search', {
-                params: { q: query, ...params }
+            const formData = new form_data_1.default();
+            formData.append('file', file, fileName);
+            const response = await this.client.post('/api/v2/files', formData, {
+                baseURL: this.config.baseUrl,
+                params,
+                headers: {
+                    ...formData.getHeaders()
+                }
             });
             return response.data;
         }
         catch (error) {
-            throw this.handleError(error, 'Failed to search store components');
+            throw this.handleError(error, 'Failed to upload file (v2)');
         }
     }
-    async uninstallStoreComponent(componentId) {
+    async getFileV2(fileId, params) {
         try {
-            const response = await this.client.delete(`/store/components/${componentId}/uninstall`);
+            const response = await this.client.get(`/api/v2/files/${encodeURIComponent(fileId)}`, {
+                baseURL: this.config.baseUrl,
+                params
+            });
             return response.data;
         }
         catch (error) {
-            throw this.handleError(error, `Failed to uninstall store component ${componentId}`);
+            throw this.handleError(error, `Failed to get file ${fileId} (v2)`);
         }
     }
-    async updateStoreComponent(componentId, updates) {
+    async renameFileV2(fileId, name) {
         try {
-            const response = await this.client.patch(`/store/components/${encodeURIComponent(componentId)}`, updates);
+            const response = await this.client.put(`/api/v2/files/${encodeURIComponent(fileId)}`, undefined, {
+                baseURL: this.config.baseUrl,
+                params: { name }
+            });
             return response.data;
         }
         catch (error) {
-            throw this.handleError(error, `Failed to update store component ${componentId}`);
+            throw this.handleError(error, `Failed to rename file ${fileId} (v2)`);
         }
     }
-    async runFlowSession(flowIdOrName, request, stream = false) {
+    async deleteFileV2(fileId) {
         try {
-            const response = await this.client.post(`/run/session/${encodeURIComponent(flowIdOrName)}`, { ...request, stream });
+            const response = await this.client.delete(`/api/v2/files/${encodeURIComponent(fileId)}`, {
+                baseURL: this.config.baseUrl
+            });
             return response.data;
         }
         catch (error) {
-            throw this.handleError(error, `Failed to run flow session ${flowIdOrName}`);
+            throw this.handleError(error, `Failed to delete file ${fileId} (v2)`);
         }
     }
-    async getRegistration() {
+    async deleteAllFilesV2() {
         try {
-            const response = await this.client.get('/api/v2/registration/', {
+            const response = await this.client.delete('/api/v2/files', { baseURL: this.config.baseUrl });
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to delete all files (v2)');
+        }
+    }
+    async batchDownloadFilesV2(fileIds) {
+        try {
+            const response = await this.client.post('/api/v2/files/batch/', fileIds, {
                 baseURL: this.config.baseUrl
             });
             return response.data;
         }
         catch (error) {
-            throw this.handleError(error, 'Failed to get registration status');
+            throw this.handleError(error, 'Failed to batch download files (v2)');
         }
     }
-    async registerUser(email) {
+    async batchDeleteFilesV2(fileIds) {
         try {
-            const response = await this.client.post('/api/v2/registration/', { email }, { baseURL: this.config.baseUrl });
+            const response = await this.client.delete('/api/v2/files/batch/', {
+                baseURL: this.config.baseUrl,
+                data: fileIds
+            });
             return response.data;
         }
         catch (error) {
-            throw this.handleError(error, 'Failed to register user');
+            throw this.handleError(error, 'Failed to batch delete files (v2)');
+        }
+    }
+    async listKnowledgeBasesDetailed() {
+        try {
+            const response = await this.client.get('/knowledge_bases/');
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to list knowledge bases (detailed)');
+        }
+    }
+    async createKnowledgeBase(body) {
+        try {
+            const response = await this.client.post('/knowledge_bases', body);
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to create knowledge base');
+        }
+    }
+    async previewKnowledgeBaseChunks(files, body) {
+        try {
+            const formData = new form_data_1.default();
+            files.forEach((file, idx) => {
+                formData.append('files', file.buffer, file.filename || `file-${idx}`);
+            });
+            if (body) {
+                Object.entries(body).forEach(([key, value]) => {
+                    formData.append(key, typeof value === 'string' ? value : JSON.stringify(value));
+                });
+            }
+            const response = await this.client.post('/knowledge_bases/preview-chunks', formData, {
+                headers: {
+                    ...formData.getHeaders()
+                }
+            });
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to preview knowledge base chunks');
+        }
+    }
+    async listKnowledgeBaseChunks(kbName, params) {
+        try {
+            const response = await this.client.get(`/knowledge_bases/${encodeURIComponent(kbName)}/chunks`, { params });
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to list chunks for knowledge base ${kbName}`);
+        }
+    }
+    async ingestKnowledgeBase(kbName, files, body) {
+        try {
+            const formData = new form_data_1.default();
+            files.forEach((file, idx) => {
+                formData.append('files', file.buffer, file.filename || `file-${idx}`);
+            });
+            if (body) {
+                Object.entries(body).forEach(([key, value]) => {
+                    formData.append(key, typeof value === 'string' ? value : JSON.stringify(value));
+                });
+            }
+            const response = await this.client.post(`/knowledge_bases/${encodeURIComponent(kbName)}/ingest`, formData, {
+                headers: {
+                    ...formData.getHeaders()
+                }
+            });
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to ingest knowledge base ${kbName}`);
+        }
+    }
+    async cancelKnowledgeBaseIngest(kbName) {
+        try {
+            const response = await this.client.post(`/knowledge_bases/${encodeURIComponent(kbName)}/cancel`);
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to cancel ingest for knowledge base ${kbName}`);
+        }
+    }
+    async updateMonitorMessage(messageId, body) {
+        try {
+            const response = await this.client.put(`/monitor/messages/${encodeURIComponent(messageId)}`, body);
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to update monitor message ${messageId}`);
+        }
+    }
+    async deleteMonitorSessionMessages(sessionId) {
+        try {
+            const response = await this.client.delete(`/monitor/messages/session/${encodeURIComponent(sessionId)}`);
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to delete messages for session ${sessionId}`);
+        }
+    }
+    async deleteMonitorSessions(sessionIds) {
+        try {
+            const response = await this.client.delete('/monitor/messages/sessions', { data: sessionIds });
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to delete monitor sessions');
+        }
+    }
+    async getSharedMessages(params) {
+        try {
+            const response = await this.client.get('/monitor/messages/shared', { params });
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to get shared messages');
         }
     }
-    async validateConnection(connectionData) {
+    async getSharedSessions(sourceFlowId) {
         try {
-            const response = await this.client.post('/validate/connection', connectionData);
+            const response = await this.client.get('/monitor/messages/shared/sessions', {
+                params: { source_flow_id: sourceFlowId }
+            });
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to get shared sessions');
+        }
+    }
+    async updateSharedMessage(messageId, sourceFlowId, body) {
+        try {
+            const response = await this.client.put(`/monitor/messages/shared/${encodeURIComponent(messageId)}`, body, { params: { source_flow_id: sourceFlowId } });
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to update shared message ${messageId}`);
+        }
+    }
+    async migrateSharedSession(oldSessionId, params) {
+        try {
+            const response = await this.client.patch(`/monitor/messages/shared/session/${encodeURIComponent(oldSessionId)}`, null, { params });
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to migrate shared session ${oldSessionId}`);
+        }
+    }
+    async deleteSharedSession(sessionId, sourceFlowId) {
+        try {
+            const response = await this.client.delete(`/monitor/messages/shared/session/${encodeURIComponent(sessionId)}`, { params: { source_flow_id: sourceFlowId } });
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to delete shared session ${sessionId}`);
+        }
+    }
+    async listTraces(params) {
+        try {
+            const response = await this.client.get('/monitor/traces', { params });
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to list traces');
+        }
+    }
+    async deleteTraces(flowId) {
+        try {
+            const response = await this.client.delete('/monitor/traces', { params: { flow_id: flowId } });
             return response.data;
         }
         catch (error) {
-            throw this.handleError(error, 'Failed to validate connection');
+            throw this.handleError(error, `Failed to delete traces for flow ${flowId}`);
         }
     }
-    async validateFlow(params) {
+    async getTrace(traceId) {
         try {
-            const response = await this.client.post(`/flows/${encodeURIComponent(params.flow_id)}/validate`);
+            const response = await this.client.get(`/monitor/traces/${encodeURIComponent(traceId)}`);
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to get trace ${traceId}`);
+        }
+    }
+    async deleteTrace(traceId) {
+        try {
+            await this.client.delete(`/monitor/traces/${encodeURIComponent(traceId)}`);
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to delete trace ${traceId}`);
+        }
+    }
+    async listModels(params) {
+        try {
+            const response = await this.client.get('/models', { params });
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to list models');
+        }
+    }
+    async listModelProviders(params) {
+        try {
+            const response = await this.client.get('/models/providers', { params });
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to list model providers');
+        }
+    }
+    async listModelProviderDescriptors(params) {
+        try {
+            const response = await this.client.get('/models/provider-descriptors', { params });
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to list model provider descriptors');
+        }
+    }
+    async listEnabledProviders(params) {
+        try {
+            const response = await this.client.get('/models/enabled_providers', {
+                params,
+                paramsSerializer: { indexes: null }
+            });
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to list enabled providers');
+        }
+    }
+    async listEnabledModels(params) {
+        try {
+            const response = await this.client.get('/models/enabled_models', {
+                params,
+                paramsSerializer: { indexes: null }
+            });
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to list enabled models');
+        }
+    }
+    async setEnabledModels(body) {
+        try {
+            const response = await this.client.post('/models/enabled_models', body);
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to set enabled models');
+        }
+    }
+    async getDefaultModel(params) {
+        try {
+            const response = await this.client.get('/models/default_model', { params });
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to get default model');
+        }
+    }
+    async setDefaultModel(body) {
+        try {
+            const response = await this.client.post('/models/default_model', body);
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to set default model');
+        }
+    }
+    async deleteDefaultModel(params) {
+        try {
+            const response = await this.client.delete('/models/default_model', { params });
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to delete default model');
+        }
+    }
+    async getProviderVariableMapping(params) {
+        try {
+            const response = await this.client.get('/models/provider-variable-mapping', { params });
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to get provider variable mapping');
+        }
+    }
+    async validateModelProvider(body) {
+        try {
+            const response = await this.client.post('/models/validate-provider', body);
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to validate model provider');
+        }
+    }
+    async getModelProviderPolicy() {
+        try {
+            const response = await this.client.get('/model-provider-policy');
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to get model provider policy');
+        }
+    }
+    async replaceModelProviderPolicy(body) {
+        try {
+            const response = await this.client.put('/model-provider-policy', body);
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to replace model provider policy');
+        }
+    }
+    async getCatalogComponentPolicy() {
+        try {
+            const response = await this.client.get('/catalog-policy/components');
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to get catalog component policy');
+        }
+    }
+    async replaceCatalogComponentPolicy(body) {
+        try {
+            const response = await this.client.put('/catalog-policy/components', body);
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to replace catalog component policy');
+        }
+    }
+    async getCatalogTemplatePolicy() {
+        try {
+            const response = await this.client.get('/catalog-policy/templates');
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to get catalog template policy');
+        }
+    }
+    async replaceCatalogTemplatePolicy(body) {
+        try {
+            const response = await this.client.put('/catalog-policy/templates', body);
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to replace catalog template policy');
+        }
+    }
+    async getCatalogPolicyUsage() {
+        try {
+            const response = await this.client.get('/catalog-policy/usage');
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to get catalog policy usage');
+        }
+    }
+    async getCatalogPolicyUsageFlows(params) {
+        try {
+            const response = await this.client.get('/catalog-policy/usage/flows', { params });
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to get catalog policy usage flows');
+        }
+    }
+    async getPolicyBundle() {
+        try {
+            const response = await this.client.get('/policy-bundle');
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to get policy bundle');
+        }
+    }
+    async replacePolicyBundle(body) {
+        try {
+            const response = await this.client.put('/policy-bundle', body);
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to replace policy bundle');
+        }
+    }
+    async listPolicyBundleHistory(params) {
+        try {
+            const response = await this.client.get('/policy-bundle/history', { params });
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to list policy bundle history');
+        }
+    }
+    async rollbackPolicyBundle(revision, body) {
+        try {
+            const response = await this.client.post(`/policy-bundle/rollback/${encodeURIComponent(revision)}`, body);
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to roll back policy bundle revision ${revision}`);
+        }
+    }
+    async getLanguageModelOptions(params) {
+        try {
+            const response = await this.client.get('/model_options/language', { params });
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to get language model options');
+        }
+    }
+    async getEmbeddingModelOptions(params) {
+        try {
+            const response = await this.client.get('/model_options/embedding', { params });
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to get embedding model options');
+        }
+    }
+    async agenticAssist(body) {
+        try {
+            const response = await this.client.post('/agentic/assist', body);
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to run agentic assist');
+        }
+    }
+    async agenticAssistStream(body) {
+        try {
+            const response = await this.client.post('/agentic/assist/stream', body, {
+                responseType: 'text'
+            });
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to run streaming agentic assist');
+        }
+    }
+    async agenticAssistRun(body) {
+        try {
+            const response = await this.client.post('/agentic/assist/run', body, {
+                responseType: 'text'
+            });
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to run headless agentic assist');
+        }
+    }
+    async agenticCheckConfig() {
+        try {
+            const response = await this.client.get('/agentic/check-config');
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to check agentic config');
+        }
+    }
+    async agenticExecute(flowName, body) {
+        try {
+            const response = await this.client.post(`/agentic/execute/${encodeURIComponent(flowName)}`, body);
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to run agentic execute for flow ${flowName}`);
+        }
+    }
+    async getWorkflowResult(params) {
+        try {
+            const response = await this.client.get('/api/v2/workflows', {
+                baseURL: this.config.baseUrl,
+                params
+            });
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to get workflow result');
+        }
+    }
+    async runWorkflow(body) {
+        try {
+            const response = await this.client.post('/api/v2/workflows', body, {
+                baseURL: this.config.baseUrl
+            });
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to run workflow');
+        }
+    }
+    async stopWorkflow(jobId) {
+        try {
+            const response = await this.client.post('/api/v2/workflows/stop', { job_id: jobId }, { baseURL: this.config.baseUrl });
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to stop workflow ${jobId}`);
+        }
+    }
+    async listMcpServers(params) {
+        try {
+            const response = await this.client.get('/api/v2/mcp/servers', {
+                baseURL: this.config.baseUrl,
+                params
+            });
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to list MCP servers');
+        }
+    }
+    async getMcpServer(serverName) {
+        try {
+            const response = await this.client.get(`/api/v2/mcp/servers/${encodeURIComponent(serverName)}`, {
+                baseURL: this.config.baseUrl
+            });
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to get MCP server ${serverName}`);
+        }
+    }
+    async createMcpServer(serverName, body) {
+        try {
+            const response = await this.client.post(`/api/v2/mcp/servers/${encodeURIComponent(serverName)}`, body, { baseURL: this.config.baseUrl });
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to create MCP server ${serverName}`);
+        }
+    }
+    async updateMcpServer(serverName, body) {
+        try {
+            const response = await this.client.patch(`/api/v2/mcp/servers/${encodeURIComponent(serverName)}`, body, { baseURL: this.config.baseUrl });
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to update MCP server ${serverName}`);
+        }
+    }
+    async deleteMcpServer(serverName) {
+        try {
+            const response = await this.client.delete(`/api/v2/mcp/servers/${encodeURIComponent(serverName)}`, { baseURL: this.config.baseUrl });
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to delete MCP server ${serverName}`);
+        }
+    }
+    async getMcpProjectConfig(projectId, params) {
+        try {
+            const response = await this.client.get(`/mcp/project/${encodeURIComponent(projectId)}`, { params });
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to get MCP project config ${projectId}`);
+        }
+    }
+    async updateMcpProjectConfig(projectId, body) {
+        try {
+            const response = await this.client.patch(`/mcp/project/${encodeURIComponent(projectId)}`, body);
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to update MCP project config ${projectId}`);
+        }
+    }
+    async getMcpProjectInstalled(projectId) {
+        try {
+            const response = await this.client.get(`/mcp/project/${encodeURIComponent(projectId)}/installed`);
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to get MCP project installed ${projectId}`);
+        }
+    }
+    async installMcpProject(projectId, body) {
+        try {
+            const response = await this.client.post(`/mcp/project/${encodeURIComponent(projectId)}/install`, body);
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to install MCP project ${projectId}`);
+        }
+    }
+    async getMcpProjectComposerUrl(projectId) {
+        try {
+            const response = await this.client.get(`/mcp/project/${encodeURIComponent(projectId)}/composer-url`);
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to get MCP project composer URL ${projectId}`);
+        }
+    }
+    async listAuthzRoles(params) {
+        try {
+            const response = await this.client.get('/authz/roles', { params });
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to list authz roles');
+        }
+    }
+    async getAuthzRole(roleId) {
+        try {
+            const response = await this.client.get(`/authz/roles/${encodeURIComponent(roleId)}`);
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to get authz role ${roleId}`);
+        }
+    }
+    async createAuthzRole(body) {
+        try {
+            const response = await this.client.post('/authz/roles', body);
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to create authz role');
+        }
+    }
+    async updateAuthzRole(roleId, body) {
+        try {
+            const response = await this.client.patch(`/authz/roles/${encodeURIComponent(roleId)}`, body);
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to update authz role ${roleId}`);
+        }
+    }
+    async deleteAuthzRole(roleId) {
+        try {
+            await this.client.delete(`/authz/roles/${encodeURIComponent(roleId)}`);
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to delete authz role ${roleId}`);
+        }
+    }
+    async listAuthzRoleAssignments(params) {
+        try {
+            const response = await this.client.get('/authz/role-assignments', { params });
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to list authz role assignments');
+        }
+    }
+    async createAuthzRoleAssignment(body) {
+        try {
+            const response = await this.client.post('/authz/role-assignments', body);
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to create authz role assignment');
+        }
+    }
+    async deleteAuthzRoleAssignment(assignmentId) {
+        try {
+            await this.client.delete(`/authz/role-assignments/${encodeURIComponent(assignmentId)}`);
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to delete authz role assignment ${assignmentId}`);
+        }
+    }
+    async listAuthzTeams(params) {
+        try {
+            const response = await this.client.get('/authz/teams', { params });
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to list authz teams');
+        }
+    }
+    async getAuthzTeam(teamId) {
+        try {
+            const response = await this.client.get(`/authz/teams/${encodeURIComponent(teamId)}`);
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to get authz team ${teamId}`);
+        }
+    }
+    async createAuthzTeam(body) {
+        try {
+            const response = await this.client.post('/authz/teams', body);
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to create authz team');
+        }
+    }
+    async updateAuthzTeam(teamId, body) {
+        try {
+            const response = await this.client.patch(`/authz/teams/${encodeURIComponent(teamId)}`, body);
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to update authz team ${teamId}`);
+        }
+    }
+    async deleteAuthzTeam(teamId) {
+        try {
+            await this.client.delete(`/authz/teams/${encodeURIComponent(teamId)}`);
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to delete authz team ${teamId}`);
+        }
+    }
+    async listAuthzTeamMembers(teamId, params) {
+        try {
+            const response = await this.client.get(`/authz/teams/${encodeURIComponent(teamId)}/members`, { params });
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to list members for authz team ${teamId}`);
+        }
+    }
+    async addAuthzTeamMember(teamId, body) {
+        try {
+            const response = await this.client.post(`/authz/teams/${encodeURIComponent(teamId)}/members`, body);
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to add member to authz team ${teamId}`);
+        }
+    }
+    async removeAuthzTeamMember(teamId, userId) {
+        try {
+            await this.client.delete(`/authz/teams/${encodeURIComponent(teamId)}/members/${encodeURIComponent(userId)}`);
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to remove member ${userId} from authz team ${teamId}`);
+        }
+    }
+    async listAuthzShares(params) {
+        try {
+            const response = await this.client.get('/authz/shares', { params });
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to list authz shares');
+        }
+    }
+    async getAuthzShare(shareId) {
+        try {
+            const response = await this.client.get(`/authz/shares/${encodeURIComponent(shareId)}`);
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to get authz share ${shareId}`);
+        }
+    }
+    async createAuthzShare(body) {
+        try {
+            const response = await this.client.post('/authz/shares', body);
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to create authz share');
+        }
+    }
+    async updateAuthzShare(shareId, body) {
+        try {
+            const response = await this.client.patch(`/authz/shares/${encodeURIComponent(shareId)}`, body);
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to update authz share ${shareId}`);
+        }
+    }
+    async deleteAuthzShare(shareId) {
+        try {
+            await this.client.delete(`/authz/shares/${encodeURIComponent(shareId)}`);
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to delete authz share ${shareId}`);
+        }
+    }
+    async getAuthzAudit(params) {
+        try {
+            const response = await this.client.get('/authz/audit', {
+                params,
+                paramsSerializer: { indexes: null }
+            });
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to get authz audit log');
+        }
+    }
+    async getMyPermissions(body) {
+        try {
+            const response = await this.client.post('/authz/me/permissions', body);
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to get effective permissions');
+        }
+    }
+    async createMemoryBase(body) {
+        try {
+            const response = await this.client.post('/memories', body);
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to create memory base');
+        }
+    }
+    async listMemoryBases(params) {
+        try {
+            const response = await this.client.get('/memories', { params });
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to list memory bases');
+        }
+    }
+    async getMemoryBase(memoryBaseId) {
+        try {
+            const response = await this.client.get(`/memories/${encodeURIComponent(memoryBaseId)}`);
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to get memory base ${memoryBaseId}`);
+        }
+    }
+    async listMemoryBaseSessions(memoryBaseId, params) {
+        try {
+            const response = await this.client.get(`/memories/${encodeURIComponent(memoryBaseId)}/sessions`, { params });
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to list sessions for memory base ${memoryBaseId}`);
+        }
+    }
+    async listMemoryBaseMessages(memoryBaseId, params) {
+        try {
+            const response = await this.client.get(`/memories/${encodeURIComponent(memoryBaseId)}/messages`, { params });
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to list messages for memory base ${memoryBaseId}`);
+        }
+    }
+    async updateMemoryBase(memoryBaseId, body) {
+        try {
+            const response = await this.client.patch(`/memories/${encodeURIComponent(memoryBaseId)}`, body);
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to update memory base ${memoryBaseId}`);
+        }
+    }
+    async deleteMemoryBase(memoryBaseId) {
+        try {
+            await this.client.delete(`/memories/${encodeURIComponent(memoryBaseId)}`);
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to delete memory base ${memoryBaseId}`);
+        }
+    }
+    async flushMemoryBase(memoryBaseId, body) {
+        try {
+            const response = await this.client.post(`/memories/${encodeURIComponent(memoryBaseId)}/flush`, body);
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to flush memory base ${memoryBaseId}`);
+        }
+    }
+    async checkMemoryBaseMismatch(memoryBaseId) {
+        try {
+            const response = await this.client.get(`/memories/${encodeURIComponent(memoryBaseId)}/mismatch`);
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to check mismatch for memory base ${memoryBaseId}`);
+        }
+    }
+    async regenerateMemoryBase(memoryBaseId) {
+        try {
+            const response = await this.client.post(`/memories/${encodeURIComponent(memoryBaseId)}/regenerate`);
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to regenerate memory base ${memoryBaseId}`);
+        }
+    }
+    async testKnowledgeBaseConnection(body) {
+        try {
+            const response = await this.client.post('/knowledge_bases/test-connection', body);
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to test knowledge base connection');
+        }
+    }
+    async listKnowledgeBaseConnectors() {
+        try {
+            const response = await this.client.get('/knowledge_bases/connectors');
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to list knowledge base connectors');
+        }
+    }
+    async ingestKnowledgeBaseFolder(kbName, body) {
+        try {
+            const response = await this.client.post(`/knowledge_bases/${encodeURIComponent(kbName)}/ingest/folder`, body);
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to ingest folder into knowledge base ${kbName}`);
+        }
+    }
+    async ingestKnowledgeBaseConnector(kbName, body) {
+        try {
+            const response = await this.client.post(`/knowledge_bases/${encodeURIComponent(kbName)}/ingest/connector`, body);
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to ingest connector into knowledge base ${kbName}`);
+        }
+    }
+    async getKnowledgeBaseMetadataKeys(kbName) {
+        try {
+            const response = await this.client.get(`/knowledge_bases/${encodeURIComponent(kbName)}/metadata/keys`);
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to get metadata keys for knowledge base ${kbName}`);
+        }
+    }
+    async listKnowledgeBaseRuns(kbName, params) {
+        try {
+            const response = await this.client.get(`/knowledge_bases/${encodeURIComponent(kbName)}/runs`, { params });
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to list ingestion runs for knowledge base ${kbName}`);
+        }
+    }
+    async getKnowledgeBaseRun(kbName, runId) {
+        try {
+            const response = await this.client.get(`/knowledge_bases/${encodeURIComponent(kbName)}/runs/${encodeURIComponent(runId)}`);
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to get ingestion run ${runId} for knowledge base ${kbName}`);
+        }
+    }
+    async reloadExtensionBundle(extensionId, bundleName) {
+        try {
+            const response = await this.client.post(`/extensions/${encodeURIComponent(extensionId)}/bundles/${encodeURIComponent(bundleName)}/reload`);
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to reload extension bundle ${bundleName}`);
+        }
+    }
+    async getExtensionEvents(params) {
+        try {
+            const response = await this.client.get('/extensions/events', { params });
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to get extension events');
+        }
+    }
+    async getAgenticFile(params) {
+        try {
+            const response = await this.client.get('/agentic/files', {
+                params,
+                responseType: params.download ? 'arraybuffer' : 'text'
+            });
+            if (params.download) {
+                return {
+                    path: params.path,
+                    encoding: 'base64',
+                    content: Buffer.from(response.data).toString('base64')
+                };
+            }
+            return { path: params.path, content: response.data };
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to get agentic file ${params.path}`);
+        }
+    }
+    async resetAgenticSession(params) {
+        try {
+            const response = await this.client.post('/agentic/sessions/reset', undefined, { params });
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to reset agentic session');
+        }
+    }
+    async getFlowNoteTranslations(flowId) {
+        try {
+            const response = await this.client.get(`/flows/${encodeURIComponent(flowId)}/note_translations`);
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to get note translations for flow ${flowId}`);
+        }
+    }
+    async getJobQueueMetrics() {
+        try {
+            const response = await this.client.get('/monitor/job_queue');
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to get job queue metrics');
+        }
+    }
+    async listA2aAgents() {
+        try {
+            const response = await this.client.get('/a2a/agents');
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to list A2A agents');
+        }
+    }
+    async getA2aAgentCard(flowId) {
+        try {
+            const response = await this.client.get(`/a2a/${encodeURIComponent(flowId)}/.well-known/agent-card.json`);
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to get A2A agent card for flow ${flowId}`);
+        }
+    }
+    async invokeA2aJsonrpc(flowId, body) {
+        try {
+            const response = await this.client.post(`/a2a/${encodeURIComponent(flowId)}/jsonrpc`, body);
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to invoke A2A JSON-RPC for flow ${flowId}`);
+        }
+    }
+    async listPendingWorkflows(params) {
+        try {
+            const response = await this.client.get('/api/v2/workflows/pending', {
+                baseURL: this.config.baseUrl,
+                params
+            });
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to list pending workflows');
+        }
+    }
+    async getWorkflowEvents(jobId) {
+        try {
+            const response = await this.client.get(`/api/v2/workflows/${encodeURIComponent(jobId)}/events`, { baseURL: this.config.baseUrl, responseType: 'text' });
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to get events for workflow ${jobId}`);
+        }
+    }
+    async resumeWorkflow(jobId, body) {
+        try {
+            const response = await this.client.post(`/api/v2/workflows/${encodeURIComponent(jobId)}/resume`, body, { baseURL: this.config.baseUrl });
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to resume workflow ${jobId}`);
+        }
+    }
+    async runPublicWorkflow(body) {
+        try {
+            const response = await this.client.post('/api/v2/workflows/public', body, {
+                baseURL: this.config.baseUrl,
+                responseType: 'text'
+            });
             return response.data;
         }
         catch (error) {
-            throw this.handleError(error, `Failed to validate flow ${params.flow_id}`);
+            throw this.handleError(error, 'Failed to run public workflow');
         }
     }
     handleError(error, message) {