@dainprotocol/service-sdk - npm Package Compare versions

Comparing version 1.1.0 to 1.1.1

dist/__tests__/integration.test.js

@@ -457,4 +457,4 @@ "use strict";
             expect(response).toEqual({
-                text: "Extra data: {\"testExtraData\":\"testExtraData\"}",
-                data: { extraData: { testExtraData: "testExtraData" } },
+                text: `Extra data: ${JSON.stringify({ testExtraData: "testExtraData", plugins: {} })}`,
+                data: { extraData: { testExtraData: "testExtraData", plugins: {} } },
                 ui: null,
@@ -461,0 +461,0 @@ });

dist/client/client-auth.d.ts

@@ -25,2 +25,3 @@ interface DainClientAuthConfig {
     static verifyMessage(message: string, signature: string, publicKey: Uint8Array): boolean;
+    verifyEventSignature(data: string, signature: string, timestamp: string, publicKeyBase58: string): boolean;
     getAgentId(): string;
@@ -27,0 +28,0 @@ getOrgId(): string;

dist/client/client-auth.js

@@ -78,2 +78,17 @@ "use strict";
     }
+    // Add a method to verify SSE event signatures
+    verifyEventSignature(data, signature, timestamp, publicKeyBase58) {
+        try {
+            // Combine data and timestamp to create the message that was signed
+            const message = `${data}:${timestamp}`;
+            const messageHash = (0, sha256_1.sha256)(message);
+            const publicKey = bs58_1.default.decode(publicKeyBase58);
+            // Verify the signature
+            return ed25519_1.ed25519.verify(signature, messageHash, publicKey);
+        }
+        catch (error) {
+            console.error('Error verifying event signature:', error);
+            return false;
+        }
+    }
     // Helper methods to get agentId, orgId, publicKey, etc.
@@ -80,0 +95,0 @@ getAgentId() {

dist/client/client.d.ts

 import { CoreTool } from "ai";
 import { DainClientAuth } from "./client-auth";
+import { DainPlugin } from "../plugins/types";
 import { ServiceMetadata, ServiceConfig, ToolboxConfig, ToolConfig, ServiceContext, ServiceContextWithData, ToolWithJsonSchema, ServicePinnable, ServicePinnableWithWidget, OAuth2ProviderInfo, ExampleQueries, HumanActionStep, ServiceDatasource, ServiceDatasourceWithData } from "./types";
@@ -8,3 +9,6 @@ export type { ServiceMetadata, ServiceConfig, ToolboxConfig, ToolConfig };
     private clientAuth;
-    constructor(baseUrl: string, clientAuth: DainClientAuth);
+    private plugins;
+    constructor(baseUrl: string, clientAuth: DainClientAuth, options?: {
+        plugins?: DainPlugin[];
+    });
     makeRequest(method: string, path: string, body?: any): Promise<any>;
@@ -11,0 +15,0 @@ getMetadata(): Promise<ServiceMetadata>;

dist/client/client.js

@@ -13,9 +13,26 @@ "use strict";
     clientAuth;
-    constructor(baseUrl, clientAuth) {
+    plugins;
+    constructor(baseUrl, clientAuth, options = {}) {
         this.baseUrl = baseUrl;
         this.clientAuth = clientAuth;
+        this.plugins = options.plugins || [];
     }
     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;
+                    }
+                }
+            }
+        }
         const fullPath = `${this.baseUrl}${path}`;
-        const bodyString = JSON.stringify(body);
+        const bodyString = JSON.stringify(processedBody);
         const { signature, timestamp } = await this.clientAuth.signRequest(method, path, bodyString);
@@ -25,3 +42,3 @@ const response = await (0, axios_1.default)({
             url: fullPath,
-            data: method === "POST" ? body : undefined,
+            data: method === "POST" ? processedBody : undefined,
             headers: {
@@ -33,3 +50,12 @@ "Content-Type": "application/json",
         });
-        return response.data;
+        // 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;
     }
@@ -129,6 +155,21 @@ async getMetadata() {
     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;
+                    }
+                }
+            }
+        }
         if (options?.onUIUpdate || options?.onProcess) {
             try {
                 // Try streaming first
-                const { signature, timestamp } = await this.clientAuth.signRequest('POST', `/tools/${toolId}`, JSON.stringify(params));
+                const { signature, timestamp } = await this.clientAuth.signRequest('POST', `/tools/${toolId}`, JSON.stringify(processedParams));
                 const response = await fetch(`${this.baseUrl}/tools/${toolId}`, {
@@ -141,7 +182,17 @@ method: 'POST',
                     },
-                    body: JSON.stringify(params),
+                    body: JSON.stringify(processedParams),
                 });
                 // If server doesn't support streaming, it will respond with regular JSON
                 if (response.headers.get('content-type')?.includes('application/json')) {
-                    return response.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;
                 }
@@ -171,12 +222,60 @@ const reader = response.body?.getReader();
                             if (currentEvent && currentData) {
-                                const data = JSON.parse(currentData);
-                                if (currentEvent === 'uipage-update') {
-                                    options.onUIUpdate?.(data);
+                                try {
+                                    // Parse the signed data
+                                    const wrappedData = JSON.parse(currentData);
+                                    // Extract and verify signature
+                                    if (wrappedData._signature) {
+                                        const { signature, timestamp, address } = wrappedData._signature;
+                                        const dataString = JSON.stringify(wrappedData.data);
+                                        // Verify the signature
+                                        const isSignatureValid = this.clientAuth.verifyEventSignature(dataString, signature, timestamp, address);
+                                        if (!isSignatureValid) {
+                                            console.warn('SSE event signature verification failed');
+                                            // For security, could choose to ignore invalid events
+                                            // continue;
+                                        }
+                                        let data = wrappedData.data;
+                                        // Process event data with plugins if it's a result
+                                        if (currentEvent === 'result' && this.plugins.length > 0) {
+                                            for (const plugin of this.plugins) {
+                                                if (plugin.processOutputClient) {
+                                                    data = await plugin.processOutputClient(data);
+                                                }
+                                            }
+                                        }
+                                        if (currentEvent === 'uipage-update' && options.onUIUpdate) {
+                                            options.onUIUpdate(data);
+                                        }
+                                        else if (currentEvent === 'process-created' && options.onProcess) {
+                                            options.onProcess(data.processId);
+                                        }
+                                        else if (currentEvent === 'result') {
+                                            return data;
+                                        }
+                                    }
+                                    else {
+                                        // Handle legacy or unsigned events
+                                        let data = wrappedData;
+                                        // Process event data with plugins if it's a result
+                                        if (currentEvent === 'result' && this.plugins.length > 0) {
+                                            for (const plugin of this.plugins) {
+                                                if (plugin.processOutputClient) {
+                                                    data = await plugin.processOutputClient(data);
+                                                }
+                                            }
+                                        }
+                                        if (currentEvent === 'uipage-update' && options.onUIUpdate) {
+                                            options.onUIUpdate(data);
+                                        }
+                                        else if (currentEvent === 'process-created' && options.onProcess) {
+                                            options.onProcess(data.processId);
+                                        }
+                                        else if (currentEvent === 'result') {
+                                            return data;
+                                        }
+                                    }
                                 }
-                                else if (currentEvent === 'process-created' && options.onProcess) {
-                                    options.onProcess(data.processId);
+                                catch (error) {
+                                    console.error('Error processing SSE event:', error);
                                 }
-                                else if (currentEvent === 'result') {
-                                    return data;
-                                }
                                 currentEvent = null;
@@ -193,3 +292,3 @@ currentData = null;
                 console.warn('Streaming failed, falling back to regular request:', error);
-                return this.makeRequest("POST", `/tools/${toolId}`, params);
+                return this.makeRequest("POST", `/tools/${toolId}`, processedParams);
             }
@@ -199,9 +298,24 @@ }
             // Use regular JSON request for backwards compatibility
-            return this.makeRequest("POST", `/tools/${toolId}`, params);
+            return this.makeRequest("POST", `/tools/${toolId}`, processedParams);
         }
     }
     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;
+                    }
+                }
+            }
+        }
         if (options?.onUIUpdate || options?.onProcess) {
             // Use streaming for UI updates
-            const { signature, timestamp } = await this.clientAuth.signRequest('POST', `/tools/${toolId}/executeAndGetNewContext`, JSON.stringify(params));
+            const { signature, timestamp } = await this.clientAuth.signRequest('POST', `/tools/${toolId}/executeAndGetNewContext`, JSON.stringify(processedParams));
             const response = await fetch(`${this.baseUrl}/tools/${toolId}/executeAndGetNewContext`, {
@@ -214,3 +328,3 @@ method: 'POST',
                 },
-                body: JSON.stringify(params),
+                body: JSON.stringify(processedParams),
             });
@@ -240,12 +354,60 @@ const reader = response.body?.getReader();
                         if (currentEvent && currentData) {
-                            const data = JSON.parse(currentData);
-                            if (currentEvent === 'uipage-update') {
-                                options.onUIUpdate?.(data);
+                            try {
+                                // Parse the signed data
+                                const wrappedData = JSON.parse(currentData);
+                                // Extract and verify signature
+                                if (wrappedData._signature) {
+                                    const { signature, timestamp, address } = wrappedData._signature;
+                                    const dataString = JSON.stringify(wrappedData.data);
+                                    // Verify the signature
+                                    const isSignatureValid = this.clientAuth.verifyEventSignature(dataString, signature, timestamp, address);
+                                    if (!isSignatureValid) {
+                                        console.warn('SSE event signature verification failed');
+                                        // For security, could choose to ignore invalid events
+                                        // continue;
+                                    }
+                                    let data = wrappedData.data;
+                                    // Process event data with plugins if it's a result
+                                    if (currentEvent === 'result' && this.plugins.length > 0) {
+                                        for (const plugin of this.plugins) {
+                                            if (plugin.processOutputClient) {
+                                                data = await plugin.processOutputClient(data);
+                                            }
+                                        }
+                                    }
+                                    if (currentEvent === 'uipage-update' && options.onUIUpdate) {
+                                        options.onUIUpdate(data);
+                                    }
+                                    else if (currentEvent === 'process-created' && options.onProcess) {
+                                        options.onProcess(data.processId);
+                                    }
+                                    else if (currentEvent === 'result') {
+                                        return data;
+                                    }
+                                }
+                                else {
+                                    // Handle legacy or unsigned events
+                                    let data = wrappedData;
+                                    // Process event data with plugins if it's a result
+                                    if (currentEvent === 'result' && this.plugins.length > 0) {
+                                        for (const plugin of this.plugins) {
+                                            if (plugin.processOutputClient) {
+                                                data = await plugin.processOutputClient(data);
+                                            }
+                                        }
+                                    }
+                                    if (currentEvent === 'uipage-update' && options.onUIUpdate) {
+                                        options.onUIUpdate(data);
+                                    }
+                                    else if (currentEvent === 'process-created' && options.onProcess) {
+                                        options.onProcess(data.processId);
+                                    }
+                                    else if (currentEvent === 'result') {
+                                        return data;
+                                    }
+                                }
                             }
-                            else if (currentEvent === 'process-created' && options.onProcess) {
-                                options.onProcess(data.processId);
+                            catch (error) {
+                                console.error('Error processing SSE event:', error);
                             }
-                            else if (currentEvent === 'result') {
-                                return data;
-                            }
                             currentEvent = null;
@@ -261,7 +423,4 @@ currentData = null;
             // Legacy non-streaming behavior
-            const result = await this.makeRequest("POST", `/tools/${toolId}/executeAndGetNewContext`, params);
-            return {
-                toolResult: result.toolResult,
-                context: result.context,
-            };
+            const result = await this.makeRequest("POST", `/tools/${toolId}/executeAndGetNewContext`, processedParams);
+            return result;
         }
@@ -268,0 +427,0 @@ }

dist/service/server.js

@@ -18,2 +18,42 @@ "use strict";
 const z = tslib_1.__importStar(require("zod"));
+const ed25519_1 = require("@noble/curves/ed25519");
+const sha256_1 = require("@noble/hashes/sha256");
+const utils_1 = require("@noble/hashes/utils");
+// Add a helper function to sign SSE events
+function signedStreamSSE(c, privateKey, config, handler) {
+    return (0, streaming_1.streamSSE)(c, async (stream) => {
+        // Wrap the original stream with a version that signs each event
+        const signedStream = {
+            writeSSE: async (event) => {
+                // Get the current timestamp
+                const timestamp = Date.now().toString();
+                // Create the message to sign (data + timestamp)
+                const message = `${event.data}:${timestamp}`;
+                const messageHash = (0, sha256_1.sha256)(message);
+                // Sign the message
+                const signatureBytes = ed25519_1.ed25519.sign(messageHash, privateKey);
+                const signature = (0, utils_1.bytesToHex)(signatureBytes);
+                // Add signature information to the data payload
+                const dataWithSignature = JSON.stringify({
+                    data: JSON.parse(event.data), // Parse and re-stringify to ensure consistent format
+                    _signature: {
+                        signature,
+                        timestamp,
+                        agentId: config.identity.agentId,
+                        orgId: config.identity.orgId,
+                        address: config.identity.publicKey
+                    }
+                });
+                // Send the signed event
+                return stream.writeSSE({
+                    event: event.event,
+                    data: dataWithSignature,
+                    id: event.id
+                });
+            }
+        };
+        // Call the original handler with our signed stream
+        await handler(signedStream);
+    });
+}
 function setupHttpServer(config, tools, services, toolboxes, metadata, privateKey, contexts, pinnables, datasources = []) {
@@ -50,3 +90,3 @@ const app = new hono_1.Hono();
     app.options("*", (c) => {
-        return c.text("Enabling CORS Pre-Flight", 204, {
+        return c.text("Enabling CORS Pre-Flight", 200, {
             "Access-Control-Allow-Origin": "*",
@@ -69,3 +109,9 @@ "Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, OPTIONS",
         }
+        // Check if this is a streaming request before executing the handler
+        const isStreaming = c.req.header("Accept") === "text/event-stream";
         await next();
+        // Skip signature for streaming responses
+        if (isStreaming || c.res.headers.get("content-type")?.includes("text/event-stream")) {
+            return;
+        }
         const body = await c.res.clone().text();
@@ -238,2 +284,39 @@ const { signature, timestamp } = (0, auth_1.signResponse)(privateKey, body);
     app.get("/toolboxes", (c) => c.json(toolboxes));
+    // Process request with plugins
+    async function processPluginsForRequest(request, agentInfo) {
+        if (!config.plugins || config.plugins.length === 0 || !request.plugins) {
+            return request;
+        }
+        let processedRequest = { ...request };
+        for (const plugin of config.plugins) {
+            if (plugin.processInputService) {
+                processedRequest = await plugin.processInputService(processedRequest);
+            }
+        }
+        return processedRequest;
+    }
+    // Process response with plugins
+    async function processPluginsForResponse(response, request, context) {
+        if (!config.plugins || config.plugins.length === 0) {
+            return response;
+        }
+        let processedResponse = { ...response };
+        processedResponse.plugins = processedResponse.plugins || {};
+        for (const plugin of config.plugins) {
+            if (plugin.processOutputService) {
+                // Provide context to the plugin
+                const pluginOutput = await plugin.processOutputService({
+                    ...processedResponse,
+                    context: {
+                        request,
+                        extraData: context
+                    }
+                });
+                if (pluginOutput) {
+                    processedResponse.plugins[plugin.id] = pluginOutput;
+                }
+            }
+        }
+        return processedResponse;
+    }
     // Automatically create routes for each tool
@@ -244,11 +327,19 @@ tools.forEach((tool) => {
                 const agentInfo = await getAgentInfo(c);
-                const body = await c.req.json();
+                let body = await c.req.json();
+                // Process plugins for the request
+                body = await processPluginsForRequest(body, agentInfo);
+                // Extract plugins data for the tool context
+                const pluginsData = body.plugins || {};
+                delete body.plugins;
                 // Only use streaming if explicitly requested by options
                 const wantsStream = c.req.header("Accept") === "text/event-stream";
                 if (wantsStream) {
-                    return (0, streaming_1.streamSSE)(c, async (stream) => {
+                    return signedStreamSSE(c, privateKey, config, async (stream) => {
                         try {
                             const result = await tool.handler({ ...body, DAIN_EXTRA_DATA: undefined }, agentInfo, {
                                 app,
-                                extraData: body.DAIN_EXTRA_DATA,
+                                extraData: {
+                                    ...body.DAIN_EXTRA_DATA,
+                                    plugins: pluginsData
+                                },
                                 updateUI: async (update) => {
@@ -269,6 +360,13 @@ await stream.writeSSE({
                             });
+                            // Process plugins for the response
+                            const processedResult = await processPluginsForResponse(result, body, {
+                                extraData: {
+                                    ...body.DAIN_EXTRA_DATA,
+                                    plugins: pluginsData
+                                }
+                            });
                             // Make sure we send the result event
                             await stream.writeSSE({
                                 event: 'result',
-                                data: JSON.stringify(result),
+                                data: JSON.stringify(processedResult),
                                 id: Date.now().toString(),
@@ -287,5 +385,15 @@ });
                         app,
-                        extraData: body.DAIN_EXTRA_DATA
+                        extraData: {
+                            ...body.DAIN_EXTRA_DATA,
+                            plugins: pluginsData
+                        }
                     });
-                    return c.json(result);
+                    // Process plugins for the response
+                    const processedResult = await processPluginsForResponse(result, body, {
+                        extraData: {
+                            ...body.DAIN_EXTRA_DATA,
+                            plugins: pluginsData
+                        }
+                    });
+                    return c.json(processedResult);
                 }
@@ -302,9 +410,17 @@ }
                 const agentInfo = await getAgentInfo(c);
-                const body = await c.req.json();
+                let body = await c.req.json();
+                // Process plugins for the request
+                body = await processPluginsForRequest(body, agentInfo);
+                // Extract plugins data for the tool context
+                const pluginsData = body.plugins || {};
+                delete body.plugins;
                 const wantsStream = c.req.header("Accept") === "text/event-stream";
                 if (wantsStream) {
-                    return (0, streaming_1.streamSSE)(c, async (stream) => {
+                    return signedStreamSSE(c, privateKey, config, async (stream) => {
                         const result = await tool.handler({ ...body, DAIN_EXTRA_DATA: undefined }, agentInfo, {
                             app,
-                            extraData: body.DAIN_EXTRA_DATA,
+                            extraData: {
+                                ...body.DAIN_EXTRA_DATA,
+                                plugins: pluginsData
+                            },
                             updateUI: async (update) => {
@@ -330,8 +446,17 @@ await stream.writeSSE({
                         })));
+                        // Create the complete response
+                        const completeResult = {
+                            toolResult: result,
+                            context: contextsNow,
+                        };
+                        // Process plugins for the response
+                        const processedResult = await processPluginsForResponse(completeResult, body, {
+                            extraData: {
+                                ...body.DAIN_EXTRA_DATA,
+                                plugins: pluginsData
+                            }
+                        });
                         await stream.writeSSE({
                             event: 'result',
-                            data: JSON.stringify({
-                                toolResult: result,
-                                context: contextsNow,
-                            }),
+                            data: JSON.stringify(processedResult),
                             id: Date.now().toString(),
@@ -345,3 +470,6 @@ });
                         app,
-                        extraData: body.DAIN_EXTRA_DATA,
+                        extraData: {
+                            ...body.DAIN_EXTRA_DATA,
+                            plugins: pluginsData
+                        },
                     });
@@ -354,6 +482,15 @@ let contextsNow = await Promise.all(contexts.map(async (context) => ({
                     })));
-                    return c.json({
+                    // Create the complete response
+                    const completeResult = {
                         toolResult: result,
                         context: contextsNow,
+                    };
+                    // Process plugins for the response
+                    const processedResult = await processPluginsForResponse(completeResult, body, {
+                        extraData: {
+                            ...body.DAIN_EXTRA_DATA,
+                            plugins: pluginsData
+                        }
                     });
+                    return c.json(processedResult);
                 }
@@ -360,0 +497,0 @@ }

dist/service/service.js

@@ -40,2 +40,5 @@ "use strict";
     }
+    if (!config.plugins) {
+        config.plugins = [];
+    }
     if (!config.services || config.services.length === 0) {
@@ -116,2 +119,3 @@ // default it to one that has all the tools and takes in a lot of info from the normal description
     const getDatasources = () => config.datasources;
+    const getPlugins = () => config.plugins || [];
     const findTool = (toolId) => tools.find((tool) => tool.id === toolId);
@@ -128,2 +132,3 @@ const findToolbox = (toolboxId) => toolboxes.find((toolbox) => toolbox.id === toolboxId);
         getDatasources,
+        getPlugins,
         findTool,
@@ -130,0 +135,0 @@ findToolbox,

dist/service/types.d.ts

@@ -7,2 +7,3 @@ import { z, ZodError } from "zod";
 import { ServerType } from "@hono/node-server/.";
+import { DainPlugin } from "../plugins/types";
 export type AgentInfo = {
@@ -145,2 +146,3 @@ agentId: string;
     getToolboxes: () => ToolboxConfig[];
+    getPlugins: () => DainPlugin[];
     findTool: (toolId: string) => ToolConfig | undefined;
@@ -168,2 +170,3 @@ findToolbox: (toolboxId: string) => ToolboxConfig | undefined;
     pinnables?: ServicePinnable[];
+    plugins?: DainPlugin[];
     oauth2?: OAuth2Config & {
@@ -170,0 +173,0 @@ baseUrl: string;

package.json

 {
   "name": "@dainprotocol/service-sdk",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "description": "DAIN Service SDK",
@@ -100,3 +100,4 @@ "main": "dist/index.js",
     "test:watch": "jest --watch",
-    "prepublishOnly": "npm run build && npm run build:types"
+    "prepublishOnly": "npm run build && npm run build:types",
+    "test:streaming": "ts-node src/standalone-streaming-test.ts"
   },
@@ -124,3 +125,3 @@ "keywords": [
     "@dainprotocol/utils": "^0.0.64",
-    "@hono/node-server": "^1.12.0",
+    "@hono/node-server": "^1.13.8",
     "@noble/curves": "^1.4.0",
@@ -140,3 +141,3 @@ "@noble/ed25519": "^2.1.0",
     "express": "^4.19.2",
-    "hono": "^4.4.13",
+    "hono": "^4.7.4",
     "ioredis": "^5.4.1",
@@ -143,0 +144,0 @@ "iron-session": "^8.0.4",

No alert changes

Improved metrics

Total package byte prevSize

731272

17.4%

Number of package files

124

16.98%

Lines of code

10694

16.23%

Dependency changes

• Updated

  @hono/node-server@^1.13.8

• Updated

  hono@^4.7.4