@dainprotocol/service-sdk 2.0.78 → 2.0.80

package/dist/client/client.js

@@ -1,5 +1,4 @@
 "use strict";
-// File: src/client/client.ts
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DainServiceConnection = void 0;
 const tslib_1 = require("tslib");
@@ -19,69 +18,75 @@ class DainServiceConnection {
         this.baseUrl = baseUrl;
         this.clientAuth = clientAuth;
         this.plugins = options.plugins || [];
-        // Disable streaming by default to avoid QUIC protocol errors with tunneled connections
         this.enableStreaming = options.enableStreaming ?? false;
     }
-    /**
-     * Returns the base URL of the connected service
-     * @returns The service's base URL as a string
-     */
     getURI() {
         return this.baseUrl;
     }
-    async makeRequest(method, path, body = {}) {
-        // Process input with plugins
-        let processedBody = { ...body };
-        if (method === "POST" && this.plugins.length > 0) {
-            // Add plugins data container if needed
-            processedBody.plugins = processedBody.plugins || {};
-            // Let each plugin process the input
-            for (const plugin of this.plugins) {
-                if (plugin.processInputClient) {
-                    const pluginData = await plugin.processInputClient(processedBody);
-                    if (pluginData) {
-                        processedBody.plugins[plugin.id] = pluginData;
-                    }
+    async processPluginInput(body) {
+        if (this.plugins.length === 0)
+            return body;
+        const pluginsData = {};
+        for (const plugin of this.plugins) {
+            if (plugin.processInputClient) {
+                const pluginData = await plugin.processInputClient(body);
+                if (pluginData) {
+                    pluginsData[plugin.id] = pluginData;
                 }
             }
         }
-        const fullPath = `${this.baseUrl}${path}`;
+        return { ...body, plugins: pluginsData };
+    }
+    async processPluginOutput(data) {
+        if (this.plugins.length === 0)
+            return data;
+        let processed = data;
+        for (const plugin of this.plugins) {
+            if (plugin.processOutputClient) {
+                processed = await plugin.processOutputClient(processed);
+            }
+        }
+        return processed;
+    }
+    extractDataFromPluginResponse(data, schema) {
+        if (!data || typeof data !== 'object' || !('plugins' in data)) {
+            return schema.parse(data);
+        }
+        const { plugins: _, ...rest } = data;
+        if (Object.keys(rest).length === 0) {
+            return schema.parse([]);
+        }
+        return schema.parse(Array.isArray(rest) ? rest : Object.values(rest));
+    }
+    extractSingleFromPluginResponse(data, schema) {
+        if (!data || typeof data !== 'object' || !('plugins' in data)) {
+            return schema.parse(data);
+        }
+        const { plugins: _, ...rest } = data;
+        return schema.parse(rest);
+    }
+    async makeRequest(method, path, body = {}) {
+        const processedBody = method === "POST"
+            ? await this.processPluginInput(body)
+            : body;
         try {
             const response = await (0, axios_1.default)({
                 method,
-                url: fullPath,
+                url: `${this.baseUrl}${path}`,
                 data: method === "POST" ? processedBody : undefined,
                 headers: {
                     "Content-Type": "application/json",
-                    //  "User-Agent": "DAIN-SERVICE-CLIENT/1.0.7",
                     ...this.clientAuth.getHeaders(),
                 },
             });
-            // Process response with plugins
-            let processedResponse = response.data;
-            if (this.plugins.length > 0) {
-                for (const plugin of this.plugins) {
-                    if (plugin.processOutputClient) {
-                        processedResponse = await plugin.processOutputClient(processedResponse);
-                    }
-                }
-            }
-            return processedResponse;
+            return this.processPluginOutput(response.data);
         }
         catch (error) {
             if ((0, axios_1.isAxiosError)(error) && error.response) {
-                // Extract the actual error message from the server response
-                let serverError;
-                // Handle both plain text and JSON error responses
-                if (typeof error.response.data === 'string') {
-                    serverError = error.response.data;
-                }
-                else if (error.response.data?.message) {
-                    serverError = error.response.data.message;
-                }
-                else {
-                    serverError = error.message;
-                }
+                const responseData = error.response.data;
+                const serverError = typeof responseData === 'string'
+                    ? responseData
+                    : responseData?.message ?? error.message;
                 const customError = new Error(serverError);
                 customError.status = error.response.status;
                 throw customError;
@@ -95,56 +100,19 @@ class DainServiceConnection {
     }
     async getExampleQueries() {
         try {
-            // Use POST method to send plugins data in the request body
-            let requestBody = {};
-            if (this.plugins.length > 0) {
-                const pluginsData = {};
-                // Let each plugin process the input
-                for (const plugin of this.plugins) {
-                    if (plugin.processInputClient) {
-                        const pluginData = await plugin.processInputClient({});
-                        if (pluginData) {
-                            pluginsData[plugin.id] = pluginData;
-                        }
-                    }
-                }
-                // Add plugins data to request body
-                requestBody = { plugins: pluginsData };
-            }
-            // Try POST first for better plugin support
+            const requestBody = await this.processPluginInput({});
             try {
                 const data = await this.makeRequest("POST", "/exampleQueries", requestBody);
-                // Handle the case where the response is an object with plugins property
-                if (data && typeof data === 'object' && !Array.isArray(data) && 'plugins' in data) {
-                    // Process the plugin data if it exists
-                    if (this.plugins.length > 0 && data.plugins) {
-                        for (const plugin of this.plugins) {
-                            if (plugin.processOutputClient) {
-                                await plugin.processOutputClient(data);
-                            }
-                        }
-                    }
-                    // The actual queries array is the original response (without the plugins property)
-                    // Clone the data and delete the plugins property to get the original array
-                    const queriesData = { ...data };
-                    delete queriesData.plugins;
-                    // If there are no properties left other than plugins, then the response was empty
-                    if (Object.keys(queriesData).length === 0) {
-                        return [];
-                    }
-                    // Try to parse what's left as an array of queries
-                    return types_1.ExampleQueriesSchema.parse(Array.isArray(queriesData) ? queriesData : Object.values(queriesData));
-                }
-                return types_1.ExampleQueriesSchema.parse(data);
+                return this.extractDataFromPluginResponse(data, types_1.ExampleQueriesSchema);
             }
-            catch (postError) {
-                // Fall back to GET if POST fails
+            catch {
                 const data = await this.makeRequest("GET", "/exampleQueries");
                 return types_1.ExampleQueriesSchema.parse(data);
             }
         }
         catch (error) {
-            if (error.response?.status === 404) {
+            const err = error;
+            if (err?.response?.status === 404) {
                 return [];
             }
             throw error;
@@ -173,336 +141,59 @@ class DainServiceConnection {
     async getContexts() {
         return this.listContexts();
     }
-    /**
-     * List contexts using POST to send plugins data in request body
-     * This is the primary method to get context data, especially when using plugins
-     */
     async listContexts() {
-        // Process plugin data
-        let requestBody = {};
-        if (this.plugins.length > 0) {
-            const pluginsData = {};
-            // Let each plugin process the input
-            for (const plugin of this.plugins) {
-                if (plugin.processInputClient) {
-                    const pluginData = await plugin.processInputClient({});
-                    if (pluginData) {
-                        pluginsData[plugin.id] = pluginData;
-                    }
-                }
-            }
-            // Add plugins data to request body
-            requestBody = { plugins: pluginsData };
-        }
+        const requestBody = await this.processPluginInput({});
         const data = await this.makeRequest("POST", `/contexts/list`, requestBody);
         return zod_1.z.array(types_1.ServiceContextSchema).parse(data);
     }
-    /**
-     * Get all context data using POST to send plugins data in request body
-     * This is the primary method to get all context data, especially when using plugins
-     */
     async postAllContexts() {
-        // Process plugin data
-        let requestBody = {};
-        if (this.plugins.length > 0) {
-            const pluginsData = {};
-            // Let each plugin process the input
-            for (const plugin of this.plugins) {
-                if (plugin.processInputClient) {
-                    const pluginData = await plugin.processInputClient({});
-                    if (pluginData) {
-                        pluginsData[plugin.id] = pluginData;
-                    }
-                }
-            }
-            // Add plugins data to request body
-            requestBody = { plugins: pluginsData };
-        }
+        const requestBody = await this.processPluginInput({});
         const data = await this.makeRequest("POST", `/contexts`, requestBody);
-        // Handle the case where the response is an object with plugins property
-        if (data && typeof data === 'object' && !Array.isArray(data) && 'plugins' in data) {
-            // Process the plugin data if it exists
-            if (this.plugins.length > 0 && data.plugins) {
-                for (const plugin of this.plugins) {
-                    if (plugin.processOutputClient) {
-                        await plugin.processOutputClient(data);
-                    }
-                }
-            }
-            // The actual contexts array is the original response (without the plugins property)
-            // Clone the data and delete the plugins property to get the original array
-            const contextData = { ...data };
-            delete contextData.plugins;
-            // If there are no properties left other than plugins, then the response was empty
-            if (Object.keys(contextData).length === 0) {
-                return [];
-            }
-            // Try to parse what's left as an array of contexts
-            return zod_1.z.array(types_1.ServiceContextWithDataSchema).parse(Array.isArray(contextData) ? contextData : Object.values(contextData));
-        }
-        // Otherwise, try to parse the whole response as an array of contexts
-        return zod_1.z.array(types_1.ServiceContextWithDataSchema).parse(data);
+        return this.extractDataFromPluginResponse(data, zod_1.z.array(types_1.ServiceContextWithDataSchema));
     }
-    /**
-     * Get context data using POST to send plugins data in request body
-     * This is the primary method to get context data, especially when using plugins
-     */
     async getContext(contextId) {
-        // Process plugin data
-        let requestBody = {};
-        if (this.plugins.length > 0) {
-            const pluginsData = {};
-            // Let each plugin process the input
-            for (const plugin of this.plugins) {
-                if (plugin.processInputClient) {
-                    const pluginData = await plugin.processInputClient({});
-                    if (pluginData) {
-                        pluginsData[plugin.id] = pluginData;
-                    }
-                }
-            }
-            // Add plugins data to request body
-            requestBody = { plugins: pluginsData };
-        }
+        const requestBody = await this.processPluginInput({});
         const data = await this.makeRequest("POST", `/contexts/${contextId}`, requestBody);
-        // Handle the case where the response is an object with plugins property
-        if (data && typeof data === 'object' && !Array.isArray(data) && 'plugins' in data) {
-            // Process the plugin data if it exists
-            if (this.plugins.length > 0 && data.plugins) {
-                for (const plugin of this.plugins) {
-                    if (plugin.processOutputClient) {
-                        await plugin.processOutputClient(data);
-                    }
-                }
-            }
-            // The actual context object is the original response (without the plugins property)
-            // Clone the data and delete the plugins property to get the original object
-            const contextData = { ...data };
-            delete contextData.plugins;
-            // Try to parse what's left as a context object
-            return types_1.ServiceContextWithDataSchema.parse(contextData);
-        }
-        // Otherwise, try to parse the whole response as a context
-        return types_1.ServiceContextWithDataSchema.parse(data);
+        return this.extractSingleFromPluginResponse(data, types_1.ServiceContextWithDataSchema);
     }
     async getAllContexts() {
-        // Use the POST implementation
         return this.postAllContexts();
     }
-    /**
-     * Get widget IDs for the current user using POST to send plugins data in request body
-     * This is the primary method to get widget IDs, especially when using plugins
-     */
     async getWidgets() {
-        // Process plugin data
-        let requestBody = {};
-        if (this.plugins.length > 0) {
-            const pluginsData = {};
-            // Let each plugin process the input
-            for (const plugin of this.plugins) {
-                if (plugin.processInputClient) {
-                    const pluginData = await plugin.processInputClient({});
-                    if (pluginData) {
-                        pluginsData[plugin.id] = pluginData;
-                    }
-                }
-            }
-            // Add plugins data to request body
-            requestBody = { plugins: pluginsData };
-        }
+        const requestBody = await this.processPluginInput({});
         const data = await this.makeRequest("POST", `/widgets`, requestBody);
-        // Handle the case where the response is an object with plugins property
-        if (data && typeof data === 'object' && !Array.isArray(data) && 'plugins' in data) {
-            // Process the plugin data if it exists
-            if (this.plugins.length > 0 && data.plugins) {
-                for (const plugin of this.plugins) {
-                    if (plugin.processOutputClient) {
-                        await plugin.processOutputClient(data);
-                    }
-                }
-            }
-            // The actual widget IDs array is the original response (without the plugins property)
-            // Clone the data and delete the plugins property to get the original array
-            const widgetData = { ...data };
-            delete widgetData.plugins;
-            // If there are no properties left other than plugins, then the response was empty
-            if (Object.keys(widgetData).length === 0) {
-                return [];
-            }
-            // Try to parse what's left as an array of widget IDs
-            return zod_1.z.array(zod_1.z.string()).parse(Array.isArray(widgetData) ? widgetData : Object.values(widgetData));
-        }
-        return zod_1.z.array(zod_1.z.string()).parse(data);
+        return this.extractDataFromPluginResponse(data, zod_1.z.array(zod_1.z.string()));
     }
-    /**
-     * Get widget data using POST to send plugins data in request body
-     * This is the primary method to get widget data, especially when using plugins
-     */
     async getWidget(widgetId) {
-        // Process plugin data
-        let requestBody = {};
-        if (this.plugins.length > 0) {
-            const pluginsData = {};
-            // Let each plugin process the input
-            for (const plugin of this.plugins) {
-                if (plugin.processInputClient) {
-                    const pluginData = await plugin.processInputClient({});
-                    if (pluginData) {
-                        pluginsData[plugin.id] = pluginData;
-                    }
-                }
-            }
-            // Add plugins data to request body
-            requestBody = { plugins: pluginsData };
-        }
+        const requestBody = await this.processPluginInput({});
         const data = await this.makeRequest("POST", `/widgets/${widgetId}`, requestBody);
-        // Handle the case where the response is an object with plugins property
-        if (data && typeof data === 'object' && 'plugins' in data) {
-            // Process the plugin data if it exists
-            if (this.plugins.length > 0 && data.plugins) {
-                for (const plugin of this.plugins) {
-                    if (plugin.processOutputClient) {
-                        await plugin.processOutputClient(data);
-                    }
-                }
-            }
-            // The actual widget object is the original response (without the plugins property)
-            // Clone the data and delete the plugins property to get the original object
-            const widgetData = { ...data };
-            delete widgetData.plugins;
-            // Try to parse what's left as a widget object
-            return types_1.ServiceWidgetWithDataSchema.parse(widgetData);
-        }
-        // Otherwise, try to parse the whole response as a widget
-        return types_1.ServiceWidgetWithDataSchema.parse(data);
+        return this.extractSingleFromPluginResponse(data, types_1.ServiceWidgetWithDataSchema);
     }
-    /**
-     * Get all widgets with data using POST to send plugins data in request body
-     * This is the primary method to get all widgets with data, especially when using plugins
-     */
     async getAllWidgets() {
-        // Use the POST implementation
         return this.postAllWidgets();
     }
-    /**
-     * Get all widgets with their data using POST to send plugins data in request body
-     * This is the primary method to get widget data, especially when using plugins
-     */
     async postAllWidgets() {
-        // Process plugin data
-        let requestBody = {};
-        if (this.plugins.length > 0) {
-            const pluginsData = {};
-            // Let each plugin process the input
-            for (const plugin of this.plugins) {
-                if (plugin.processInputClient) {
-                    const pluginData = await plugin.processInputClient({});
-                    if (pluginData) {
-                        pluginsData[plugin.id] = pluginData;
-                    }
-                }
-            }
-            // Add plugins data to request body
-            requestBody = { plugins: pluginsData };
-        }
+        const requestBody = await this.processPluginInput({});
         const data = await this.makeRequest("POST", `/widgets/all`, requestBody);
-        // Handle the case where the response is an object with plugins property
-        if (data && typeof data === 'object' && !Array.isArray(data) && 'plugins' in data) {
-            // Process the plugin data if it exists
-            if (this.plugins.length > 0 && data.plugins) {
-                for (const plugin of this.plugins) {
-                    if (plugin.processOutputClient) {
-                        await plugin.processOutputClient(data);
-                    }
-                }
-            }
-            // The actual widgets array is the original response (without the plugins property)
-            // Clone the data and delete the plugins property to get the original array
-            const widgetsData = { ...data };
-            delete widgetsData.plugins;
-            // If there are no properties left other than plugins, then the response was empty
-            if (Object.keys(widgetsData).length === 0) {
-                return [];
-            }
-            // Try to parse what's left as an array of widgets
-            return zod_1.z.array(types_1.ServiceWidgetWithDataSchema).parse(Array.isArray(widgetsData) ? widgetsData : Object.values(widgetsData));
-        }
-        // Otherwise, try to parse the whole response as an array of widgets
-        return zod_1.z.array(types_1.ServiceWidgetWithDataSchema).parse(data);
+        return this.extractDataFromPluginResponse(data, zod_1.z.array(types_1.ServiceWidgetWithDataSchema));
     }
-    /**
-     * Get the home UI widget ID for the current user
-     * Returns null if no home UI is configured
-     */
     async getHomeUI() {
-        // Process plugin data
-        let requestBody = {};
-        if (this.plugins.length > 0) {
-            const pluginsData = {};
-            // Let each plugin process the input
-            for (const plugin of this.plugins) {
-                if (plugin.processInputClient) {
-                    const pluginData = await plugin.processInputClient({});
-                    if (pluginData) {
-                        pluginsData[plugin.id] = pluginData;
-                    }
-                }
-            }
-            requestBody = { plugins: pluginsData };
-        }
+        const requestBody = await this.processPluginInput({});
         const response = await this.makeRequest("POST", "/homeUI", requestBody);
-        // Return null if no home UI is configured or widgetId is null
-        if (!response.widgetId) {
-            return null;
-        }
-        return response.widgetId;
+        return response?.widgetId ?? null;
     }
-    /**
-     * Get all tools as JSON schema using POST to send plugins data in request body
-     * This is the primary method to get all tools as JSON schema, especially when using plugins
-     */
     async getAllToolsAsJsonSchema() {
-        // Process plugin data
-        let requestBody = {};
-        if (this.plugins.length > 0) {
-            const pluginsData = {};
-            // Let each plugin process the input
-            for (const plugin of this.plugins) {
-                if (plugin.processInputClient) {
-                    const pluginData = await plugin.processInputClient({});
-                    if (pluginData) {
-                        pluginsData[plugin.id] = pluginData;
-                    }
-                }
-            }
-            // Add plugins data to request body
-            requestBody = { plugins: pluginsData };
-        }
+        const requestBody = await this.processPluginInput({});
         const data = await this.makeRequest("POST", "/getAllToolsAsJsonSchema", requestBody);
-        // Handle the case where the response is an object with plugins property
-        if (data && typeof data === 'object' && 'plugins' in data && typeof data.plugins === 'object') {
-            // Process the plugin data if it exists
-            if (this.plugins.length > 0) {
-                for (const plugin of this.plugins) {
-                    if (plugin.processOutputClient) {
-                        await plugin.processOutputClient(data);
-                    }
-                }
-            }
-            // The actual tools schema is the original response (without the plugins property)
-            // Clone the data and delete the plugins property to get the original object
-            const toolsData = { ...data };
-            delete toolsData.plugins;
-            // If the object has both tools and reccomendedPrompts properties, assume it's a valid response
-            if ('tools' in toolsData && 'reccomendedPrompts' in toolsData &&
-                Array.isArray(toolsData.tools) && Array.isArray(toolsData.reccomendedPrompts)) {
+        if (data && typeof data === 'object' && 'plugins' in data) {
+            const { plugins: _, tools, reccomendedPrompts, ...rest } = data;
+            if (Array.isArray(tools) && Array.isArray(reccomendedPrompts)) {
                 return {
-                    tools: toolsData.tools,
-                    reccomendedPrompts: toolsData.reccomendedPrompts
+                    tools: tools,
+                    reccomendedPrompts: reccomendedPrompts
                 };
             }
         }
-        // Otherwise, try to parse the whole response
         const returned = types_1.GetAllToolsAsJsonSchemaResponseSchema.parse(data);
         return {
             tools: returned.tools,
@@ -534,63 +225,24 @@ class DainServiceConnection {
         });
     }
     async callTool(toolId, params, options) {
-        // Process input with plugins
-        let processedParams = { ...params };
-        if (this.plugins.length > 0) {
-            // Add plugins data container
-            processedParams.plugins = processedParams.plugins || {};
-            // Let each plugin process the input
-            for (const plugin of this.plugins) {
-                if (plugin.processInputClient) {
-                    const pluginData = await plugin.processInputClient(processedParams);
-                    if (pluginData) {
-                        processedParams.plugins[plugin.id] = pluginData;
-                    }
-                }
-            }
-        }
-        // Use streaming when explicitly enabled (callbacks are optional)
+        const processedParams = await this.processPluginInput(params);
         if (this.enableStreaming) {
             const streamedResult = await this._callToolWithStreaming(toolId, processedParams, `/tools/${toolId}`, options);
             return this.sanitizeToolResponse(streamedResult, options);
         }
-        // Use regular JSON request (default behavior)
         const response = await this.makeRequest("POST", `/tools/${toolId}`, processedParams);
         return this.sanitizeToolResponse(response, options);
     }
     async callToolAndGetNewContext(toolId, params, options) {
-        // Process input with plugins
-        let processedParams = { ...params };
-        if (this.plugins.length > 0) {
-            // Add plugins data container
-            processedParams.plugins = processedParams.plugins || {};
-            // Let each plugin process the input
-            for (const plugin of this.plugins) {
-                if (plugin.processInputClient) {
-                    const pluginData = await plugin.processInputClient(processedParams);
-                    if (pluginData) {
-                        processedParams.plugins[plugin.id] = pluginData;
-                    }
-                }
-            }
-        }
-        // Use streaming when explicitly enabled (callbacks are optional)
+        const processedParams = await this.processPluginInput(params);
+        const endpoint = `/tools/${toolId}/executeAndGetNewContext`;
         if (this.enableStreaming) {
-            const streamedResult = await this._callToolWithStreaming(toolId, processedParams, `/tools/${toolId}/executeAndGetNewContext`, options);
-            return this.sanitizeToolResponse(streamedResult, options, {
-                stripToolResultSuccess: true,
-            });
+            const streamedResult = await this._callToolWithStreaming(toolId, processedParams, endpoint, options);
+            return this.sanitizeToolResponse(streamedResult, options, { stripToolResultSuccess: true });
         }
-        // Use regular JSON request (default behavior)
-        const response = await this.makeRequest("POST", `/tools/${toolId}/executeAndGetNewContext`, processedParams);
-        return this.sanitizeToolResponse(response, options, {
-            stripToolResultSuccess: true,
-        });
+        const response = await this.makeRequest("POST", endpoint, processedParams);
+        return this.sanitizeToolResponse(response, options, { stripToolResultSuccess: true });
     }
-    /**
-     * Shared implementation for streaming tool calls
-     * @private
-     */
     async _callToolWithStreaming(toolId, params, endpoint, options = {}) {
         const abortController = new AbortController();
         const response = await fetch(`${this.baseUrl}${endpoint}`, {
@@ -604,21 +256,10 @@ class DainServiceConnection {
             signal: abortController.signal,
         });
         const contentType = response.headers.get('content-type') || '';
-        // If server doesn't support streaming, it will respond with regular JSON
         if (contentType.includes('application/json')) {
             const data = await response.json();
-            // Process response with plugins
-            let processedResponse = data;
-            if (this.plugins.length > 0) {
-                for (const plugin of this.plugins) {
-                    if (plugin.processOutputClient) {
-                        processedResponse = await plugin.processOutputClient(processedResponse);
-                    }
-                }
-            }
-            return processedResponse;
+            return this.processPluginOutput(data);
         }
-        // Check for error responses
         if (!response.ok) {
             if (contentType.includes('application/json')) {
                 const errorData = await response.json();
@@ -627,19 +268,16 @@ class DainServiceConnection {
             throw new Error(`HTTP error: ${response.status} ${response.statusText}`);
         }
         const reader = response.body?.getReader();
-        const decoder = new TextDecoder();
-        let buffer = '';
         if (!reader)
             throw new Error('No response body');
-        // Flag to track if we received a result
+        const decoder = new TextDecoder();
+        let buffer = '';
         let receivedResult = false;
         let receivedAnyChunk = false;
         let receivedAnyEvent = false;
-        // SSE parsing state - MUST persist across processSSEEvents calls
-        // because event: and data: lines may arrive in different TCP packets
         let currentEvent = null;
         let currentDataLines = [];
-        const stripFieldValue = (value) => (value.startsWith(' ') ? value.slice(1) : value);
+        const stripFieldValue = (value) => value.startsWith(' ') ? value.slice(1) : value;
         const normalizeProgressUpdate = (data) => {
             if (typeof data === 'string')
                 return { text: data };
@@ -651,6 +289,31 @@ class DainServiceConnection {
             }
             return { text: String(data ?? '') };
         };
+        const processEventData = async (eventType, data) => {
+            const processedData = eventType === 'result'
+                ? await this.processPluginOutput(data)
+                : data;
+            switch (eventType) {
+                case 'uipage-update':
+                    options.onUIUpdate?.(processedData);
+                    break;
+                case 'process-created': {
+                    const processId = typeof processedData === 'string'
+                        ? processedData
+                        : processedData?.processId;
+                    if (processId)
+                        options.onProcess?.(processId);
+                    break;
+                }
+                case 'progress':
+                    options.onProgress?.(normalizeProgressUpdate(processedData));
+                    break;
+                case 'result':
+                    receivedResult = true;
+                    return processedData;
+            }
+            return null;
+        };
         const handleEvent = async (eventType, rawData) => {
             receivedAnyEvent = true;
             let wrappedData = rawData;
@@ -668,67 +331,23 @@ class DainServiceConnection {
                     : wrappedData?.message || rawData || 'Unknown SSE error';
                 throw new Error(`SSE error: ${message}`);
             }
-            const isSignedPayload = wrappedData && typeof wrappedData === 'object' && '_signature' in wrappedData;
+            const isSignedPayload = wrappedData &&
+                typeof wrappedData === 'object' &&
+                '_signature' in wrappedData;
             if (isSignedPayload) {
-                const { signature, timestamp, address } = wrappedData._signature || {};
+                const signedData = wrappedData;
+                const { signature, timestamp, address } = signedData._signature || {};
                 const shouldVerify = eventType === 'result' || eventType === 'process-created';
-                if (shouldVerify) {
-                    const dataString = JSON.stringify(wrappedData.data);
+                if (shouldVerify && signature && timestamp && address) {
+                    const dataString = JSON.stringify(signedData.data);
                     const isSignatureValid = this.clientAuth.verifyEventSignature(dataString, signature, timestamp, address);
                     if (!isSignatureValid) {
                         console.warn(`SSE event signature verification failed for ${eventType}`);
                     }
                 }
-                let data = wrappedData.data;
-                if (eventType === 'result' && this.plugins.length > 0) {
-                    for (const plugin of this.plugins) {
-                        if (plugin.processOutputClient) {
-                            data = await plugin.processOutputClient(data);
-                        }
-                    }
-                }
-                if (eventType === 'uipage-update' && options.onUIUpdate) {
-                    options.onUIUpdate(data);
-                }
-                else if (eventType === 'process-created' && options.onProcess) {
-                    const processId = typeof data === 'string' ? data : data?.processId;
-                    if (processId)
-                        options.onProcess(processId);
-                }
-                else if (eventType === 'progress' && options.onProgress) {
-                    options.onProgress(normalizeProgressUpdate(data));
-                }
-                else if (eventType === 'result') {
-                    receivedResult = true;
-                    return data;
-                }
-            }
-            else {
-                let data = wrappedData;
-                if (eventType === 'result' && this.plugins.length > 0) {
-                    for (const plugin of this.plugins) {
-                        if (plugin.processOutputClient) {
-                            data = await plugin.processOutputClient(data);
-                        }
-                    }
-                }
-                if (eventType === 'uipage-update' && options.onUIUpdate) {
-                    options.onUIUpdate(data);
-                }
-                else if (eventType === 'process-created' && options.onProcess) {
-                    const processId = typeof data === 'string' ? data : data?.processId;
-                    if (processId)
-                        options.onProcess(processId);
-                }
-                else if (eventType === 'progress' && options.onProgress) {
-                    options.onProgress(normalizeProgressUpdate(data));
-                }
-                else if (eventType === 'result') {
-                    receivedResult = true;
-                    return data;
-                }
+                return processEventData(eventType, signedData.data);
             }
-            return null;
+            return processEventData(eventType, wrappedData);
         };
         const flushEvent = async () => {
             if (!currentEvent && currentDataLines.length === 0)
@@ -760,9 +379,7 @@ class DainServiceConnection {
             return null;
         };
         const readWithTimeout = async () => {
-            const timeoutId = setTimeout(() => {
-                abortController.abort();
-            }, this.streamIdleTimeoutMs);
+            const timeoutId = setTimeout(() => abortController.abort(), this.streamIdleTimeoutMs);
             try {
                 return await reader.read();
             }
@@ -815,6 +432,8 @@ class DainServiceConnection {
             }
             throw new Error('Stream ended without result');
         }
+        // Should be unreachable - receivedResult is true means we returned from processEventData
+        throw new Error('Unexpected state: received result but did not return');
     }
     createVercelAIToolWithoutExecute(toolInfo) {
         return (0, ai_1.tool)({
@@ -825,20 +444,26 @@ class DainServiceConnection {
     async getProcessStatus(processId) {
         try {
             const data = await this.makeRequest("GET", `/processes/${processId}/status`);
-            // Convert createdAt strings to Date objects
             if (data.updates) {
-                data.updates = data.updates.map((update) => ({
-                    ...update,
-                    createdAt: new Date(update.createdAt),
-                }));
+                return {
+                    ...data,
+                    updates: data.updates.map(update => ({
+                        ...update,
+                        createdAt: new Date(update.createdAt),
+                    })),
+                };
             }
-            return data;
+            return {
+                ...data,
+                updates: [],
+            };
         }
         catch (error) {
-            if (error.response?.status === 404) {
+            const err = error;
+            if (err?.response?.status === 404) {
                 return null;
             }
-            if (error.response?.status === 403) {
+            if (err?.response?.status === 403) {
                 throw new Error("Unauthorized access to process");
             }
             throw error;
@@ -848,10 +473,6 @@ class DainServiceConnection {
         const data = await this.makeRequest("GET", "/oauth2/providers");
         return zod_1.z.array(types_1.OAuth2ProviderInfoSchema).parse(data);
     }
-    /**
-     * Get all authentication providers (OAuth2 + Direct)
-     * Returns unified provider information with type discrimination
-     */
     async getAuthenticationProviders() {
         const data = await this.makeRequest("GET", "/oauth2/authentication-providers");
         return zod_1.z.array(types_1.ProviderInfoSchema).parse(data);
@@ -860,26 +481,16 @@ class DainServiceConnection {
         const data = await this.makeRequest("GET", `/oauth2/connect/${provider}`);
         return zod_1.z.object({ authUrl: zod_1.z.string() }).parse(data).authUrl;
     }
-    /**
-     * Get direct auth setup status for a provider (RFC 8628 Device Authorization Grant)
-     * Used to poll for completion when user completes auth on external device (e.g., Telegram)
-     *
-     * @param provider - Provider name (e.g., 'telegram')
-     * @returns Setup status with completion info or pending state
-     */
     async getDirectAuthStatus(provider) {
         const data = await this.makeRequest("GET", `/oauth2/direct-setup-status/${provider}`);
         return types_1.DirectAuthStatusSchema.parse(data);
     }
-    // Get all human actions for a process
     async getProcessHumanActions(processId) {
         return this.makeRequest("GET", `/processes/${processId}/human-actions`);
     }
-    // Get specific human action
     async getHumanAction(processId, stepId) {
         return this.makeRequest("GET", `/processes/${processId}/human-actions/${stepId}`);
     }
-    // Respond to human action
     async respondToHumanAction(processId, stepId, actionId, responseText, data) {
         return this.makeRequest("POST", `/processes/${processId}/human-actions/${stepId}/respond`, {
             actionId,
@@ -888,275 +499,63 @@ class DainServiceConnection {
         });
     }
     async getToolConfirmation(toolId, input) {
-        const response = await this.makeRequest("POST", `/tools/${toolId}/confirmation`, input);
-        return response;
+        return this.makeRequest("POST", `/tools/${toolId}/confirmation`, input);
     }
-    /**
-     * List datasources using POST to send plugins data in request body
-     * This is the primary method to get datasource data, especially when using plugins
-     */
     async listDatasources() {
-        // Process plugin data
-        let requestBody = {};
-        if (this.plugins.length > 0) {
-            const pluginsData = {};
-            // Let each plugin process the input
-            for (const plugin of this.plugins) {
-                if (plugin.processInputClient) {
-                    const pluginData = await plugin.processInputClient({});
-                    if (pluginData) {
-                        pluginsData[plugin.id] = pluginData;
-                    }
-                }
-            }
-            // Add plugins data to request body
-            requestBody = { plugins: pluginsData };
-        }
+        const requestBody = await this.processPluginInput({});
         const data = await this.makeRequest("POST", `/datasources/list`, requestBody);
-        // Handle the case where the response is an object with plugins property
-        if (data && typeof data === 'object' && !Array.isArray(data) && 'plugins' in data) {
-            // Process the plugin data if it exists
-            if (this.plugins.length > 0 && data.plugins) {
-                for (const plugin of this.plugins) {
-                    if (plugin.processOutputClient) {
-                        await plugin.processOutputClient(data);
-                    }
-                }
-            }
-            // The actual datasources array is the original response (without the plugins property)
-            // Clone the data and delete the plugins property to get the original array
-            const datasourcesData = { ...data };
-            delete datasourcesData.plugins;
-            // If there are no properties left other than plugins, then the response was empty
-            if (Object.keys(datasourcesData).length === 0) {
-                return [];
-            }
-            // Try to parse what's left as an array of datasources
-            return zod_1.z.array(types_1.ServiceDatasourceSchema).parse(Array.isArray(datasourcesData) ? datasourcesData : Object.values(datasourcesData));
-        }
-        return zod_1.z.array(types_1.ServiceDatasourceSchema).parse(data);
+        return this.extractDataFromPluginResponse(data, zod_1.z.array(types_1.ServiceDatasourceSchema));
     }
-    /**
-     * Get data from a datasource using POST to send params and plugin data
-     * This is the primary method for accessing datasources
-     */
     async getDatasource(datasourceId, params) {
-        // Process plugin data
-        let requestBody = { ...params };
-        if (this.plugins.length > 0) {
-            const pluginsData = {};
-            // Let each plugin process the input
-            for (const plugin of this.plugins) {
-                if (plugin.processInputClient) {
-                    const pluginData = await plugin.processInputClient(requestBody);
-                    if (pluginData) {
-                        pluginsData[plugin.id] = pluginData;
-                    }
-                }
-            }
-            // Add plugins data to request body
-            requestBody.plugins = pluginsData;
-        }
+        const requestBody = await this.processPluginInput(params);
         const data = await this.makeRequest("POST", `/datasources/${datasourceId}`, requestBody);
-        // Handle the case where the response is an object with plugins property
-        if (data && typeof data === 'object' && 'plugins' in data) {
-            // Process the plugin data if it exists
-            if (this.plugins.length > 0 && data.plugins) {
-                for (const plugin of this.plugins) {
-                    if (plugin.processOutputClient) {
-                        await plugin.processOutputClient(data);
-                    }
-                }
-            }
-            // The actual datasource object is the original response (without the plugins property)
-            // Clone the data and delete the plugins property to get the original object
-            const datasourceData = { ...data };
-            delete datasourceData.plugins;
-            // Try to parse what's left as a datasource object
-            return types_1.ServiceDatasourceWithDataSchema.parse(datasourceData);
-        }
-        // Otherwise, try to parse the whole response as a datasource with data
-        return types_1.ServiceDatasourceWithDataSchema.parse(data);
+        return this.extractSingleFromPluginResponse(data, types_1.ServiceDatasourceWithDataSchema);
     }
-    /**
-     * Get all datasources with POST to send plugins data in request body
-     * This is the primary method to get all datasources, especially when using plugins
-     */
     async postAllDatasources() {
-        // Process plugin data
-        let requestBody = {};
-        if (this.plugins.length > 0) {
-            const pluginsData = {};
-            // Let each plugin process the input
-            for (const plugin of this.plugins) {
-                if (plugin.processInputClient) {
-                    const pluginData = await plugin.processInputClient({});
-                    if (pluginData) {
-                        pluginsData[plugin.id] = pluginData;
-                    }
-                }
-            }
-            // Add plugins data to request body
-            requestBody = { plugins: pluginsData };
-        }
+        const requestBody = await this.processPluginInput({});
         const data = await this.makeRequest("POST", `/datasources/all`, requestBody);
-        // Handle the case where the response is an object with plugins property
-        if (data && typeof data === 'object' && !Array.isArray(data) && 'plugins' in data) {
-            // Process the plugin data if it exists
-            if (this.plugins.length > 0 && data.plugins) {
-                for (const plugin of this.plugins) {
-                    if (plugin.processOutputClient) {
-                        await plugin.processOutputClient(data);
-                    }
-                }
-            }
-            // The actual datasources array is the original response (without the plugins property)
-            // Clone the data and delete the plugins property to get the original array
-            const datasourcesData = { ...data };
-            delete datasourcesData.plugins;
-            // If there are no properties left other than plugins, then the response was empty
-            if (Object.keys(datasourcesData).length === 0) {
-                return [];
-            }
-            // Try to parse what's left as an array of datasources
-            return zod_1.z.array(types_1.ServiceDatasourceSchema).parse(Array.isArray(datasourcesData) ? datasourcesData : Object.values(datasourcesData));
-        }
-        return zod_1.z.array(types_1.ServiceDatasourceSchema).parse(data);
+        return this.extractDataFromPluginResponse(data, zod_1.z.array(types_1.ServiceDatasourceSchema));
     }
-    /**
-     * Get all tools that implement a specific interface
-     */
     async getToolsByInterface(interfaceType) {
         const allTools = await this.getTools();
-        return allTools.filter(tool => tool.interface === interfaceType);
+        return allTools.filter(t => t.interface === interfaceType);
     }
-    /**
-     * Get available interfaces from tools
-     */
     async getAvailableInterfaces() {
         const allTools = await this.getTools();
         const interfaces = new Set();
-        allTools.forEach(tool => {
-            if (tool.interface && Object.values(interfaces_1.ToolInterfaceType).includes(tool.interface)) {
-                interfaces.add(tool.interface);
+        for (const t of allTools) {
+            if (t.interface && Object.values(interfaces_1.ToolInterfaceType).includes(t.interface)) {
+                interfaces.add(t.interface);
             }
-        });
+        }
         return Array.from(interfaces);
     }
-    /**
-     * Get all agents defined by the service
-     */
     async getAgents() {
         const data = await this.makeRequest("GET", "/agents");
         return zod_1.z.array(types_1.ServiceAgentSchema).parse(data);
     }
-    /**
-     * List agents using POST to send plugins data in request body
-     * This is the primary method to get agents, especially when using plugins
-     */
     async listAgents() {
-        // Process plugin data
-        let requestBody = {};
-        if (this.plugins.length > 0) {
-            const pluginsData = {};
-            // Let each plugin process the input
-            for (const plugin of this.plugins) {
-                if (plugin.processInputClient) {
-                    const pluginData = await plugin.processInputClient({});
-                    if (pluginData) {
-                        pluginsData[plugin.id] = pluginData;
-                    }
-                }
-            }
-            // Add plugins data to request body
-            requestBody = { plugins: pluginsData };
-        }
+        const requestBody = await this.processPluginInput({});
         const data = await this.makeRequest("POST", "/agents/list", requestBody);
-        // Handle the case where the response is an object with plugins property
-        if (data && typeof data === 'object' && !Array.isArray(data) && 'plugins' in data) {
-            // Process the plugin data if it exists
-            if (this.plugins.length > 0 && data.plugins) {
-                for (const plugin of this.plugins) {
-                    if (plugin.processOutputClient) {
-                        await plugin.processOutputClient(data);
-                    }
-                }
-            }
-            // The actual agents array is the original response (without the plugins property)
-            // Clone the data and delete the plugins property to get the original array
-            const agentsData = { ...data };
-            delete agentsData.plugins;
-            // If there are no properties left other than plugins, then the response was empty
-            if (Object.keys(agentsData).length === 0) {
-                return [];
-            }
-            // Try to parse what's left as an array of agents
-            return zod_1.z.array(types_1.ServiceAgentSchema).parse(Array.isArray(agentsData) ? agentsData : Object.values(agentsData));
-        }
-        return zod_1.z.array(types_1.ServiceAgentSchema).parse(data);
+        return this.extractDataFromPluginResponse(data, zod_1.z.array(types_1.ServiceAgentSchema));
     }
-    /**
-     * Get a specific agent by ID
-     */
     async getAgent(agentId) {
         const data = await this.makeRequest("GET", `/agents/${agentId}`);
         return types_1.ServiceAgentSchema.parse(data);
     }
-    /**
-     * Get specific agent using POST to send plugins data in request body
-     * This is the primary method to get agent data, especially when using plugins
-     */
     async postAgent(agentId) {
-        // Process plugin data
-        let requestBody = {};
-        if (this.plugins.length > 0) {
-            const pluginsData = {};
-            // Let each plugin process the input
-            for (const plugin of this.plugins) {
-                if (plugin.processInputClient) {
-                    const pluginData = await plugin.processInputClient({});
-                    if (pluginData) {
-                        pluginsData[plugin.id] = pluginData;
-                    }
-                }
-            }
-            // Add plugins data to request body
-            requestBody = { plugins: pluginsData };
-        }
+        const requestBody = await this.processPluginInput({});
         const data = await this.makeRequest("POST", `/agents/${agentId}`, requestBody);
-        // Handle the case where the response is an object with plugins property
-        if (data && typeof data === 'object' && 'plugins' in data) {
-            // Process the plugin data if it exists
-            if (this.plugins.length > 0 && data.plugins) {
-                for (const plugin of this.plugins) {
-                    if (plugin.processOutputClient) {
-                        await plugin.processOutputClient(data);
-                    }
-                }
-            }
-            // The actual agent object is the original response (without the plugins property)
-            // Clone the data and delete the plugins property to get the original object
-            const agentData = { ...data };
-            delete agentData.plugins;
-            // Try to parse what's left as an agent object
-            return types_1.ServiceAgentSchema.parse(agentData);
-        }
-        // Otherwise, try to parse the whole response as an agent
-        return types_1.ServiceAgentSchema.parse(data);
+        return this.extractSingleFromPluginResponse(data, types_1.ServiceAgentSchema);
     }
     sanitizeToolResponse(response, callbacks, options = {}) {
         if (!response || typeof response !== "object") {
             return response;
         }
-        const updates = Array.isArray(response._updates)
-            ? response._updates
-            : [];
-        const progressUpdates = Array.isArray(response._progress)
-            ? response._progress
-            : [];
-        const processes = Array.isArray(response._processes)
-            ? response._processes
-            : [];
+        const resp = response;
+        const updates = Array.isArray(resp._updates) ? resp._updates : [];
+        const progressUpdates = Array.isArray(resp._progress) ? resp._progress : [];
+        const processes = Array.isArray(resp._processes) ? resp._processes : [];
         if (callbacks?.onUIUpdate) {
             for (const update of updates) {
                 callbacks.onUIUpdate(update);
@@ -1172,10 +571,10 @@ class DainServiceConnection {
                 callbacks.onProcess(processId);
             }
         }
-        const { _updates, _progress, _processes, ...remaining } = response;
+        const { _updates: _, _progress: __, _processes: ___, ...remaining } = resp;
         const cleanResponse = { ...remaining };
         if (options.stripToolResultSuccess && cleanResponse.toolResult && typeof cleanResponse.toolResult === "object") {
-            const { success: _ignored, ...rest } = cleanResponse.toolResult;
+            const { success: ____, ...rest } = cleanResponse.toolResult;
             cleanResponse.toolResult = rest;
         }
         return cleanResponse;