@dainprotocol/service-sdk 2.0.54 → 2.0.56

package/dist/__tests__/plugin.test.js

@@ -1,900 +0,0 @@
-"use strict";
-// File: src/__tests__/plugin.test.ts
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-const client_auth_1 = require("@/client/client-auth");
-const client_1 = require("@/client/client");
-const ed25519_1 = require("@noble/curves/ed25519");
-const bs58_1 = tslib_1.__importDefault(require("bs58"));
-const nodeService_1 = require("@/service/nodeService");
-const core_1 = require("@/service/core");
-const zod_1 = require("zod");
-const time_plugin_1 = require("@/plugins/time-plugin");
-const crypto_plugin_1 = require("@/plugins/crypto-plugin");
-describe("DAIN Framework Plugin System", () => {
-    const privateKey = ed25519_1.ed25519.utils.randomPrivateKey();
-    const publicKey = ed25519_1.ed25519.getPublicKey(privateKey);
-    const address = bs58_1.default.encode(publicKey);
-    const clientPrivateKey = ed25519_1.ed25519.utils.randomPrivateKey();
-    const agentAuth = new client_auth_1.DainClientAuth({
-        privateKeyBase58: bs58_1.default.encode(clientPrivateKey),
-        agentId: "agent-12",
-        orgId: "org-12",
-    });
-    // Create a TimePlugin instance
-    const timePlugin = new time_plugin_1.TimePlugin({ includeTimezone: true });
-    // Create a CryptoPlugin instance with test wallet data
-    const testWallets = [
-        { chain: "sol", address: "SolTestAddress123456789" },
-        { chain: "eth", address: "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266" }
-    ];
-    const cryptoPlugin = new crypto_plugin_1.CryptoPlugin(testWallets);
-    // Create a wallet info tool to specifically test crypto plugin
-    const walletInfoTool = (0, core_1.createTool)({
-        id: "wallet-info",
-        name: "Wallet Info Tool",
-        description: "Shows information about connected wallets",
-        input: zod_1.z.object({}),
-        output: zod_1.z.object({
-            connectedWallets: zod_1.z.array(zod_1.z.object({
-                chain: zod_1.z.string(),
-                address: zod_1.z.string()
-            })),
-            walletsCount: zod_1.z.number()
-        }),
-        handler: async ({}, agentInfo, context) => {
-            // Extract wallet information from crypto plugin
-            const cryptoData = context.extraData?.plugins?.['crypto-plugin'];
-            console.log(`Wallet handler: received crypto plugin data:`, cryptoData);
-            let wallets = [];
-            if (cryptoData && cryptoData.wallets) {
-                wallets = cryptoData.wallets;
-            }
-            return {
-                text: `Found ${wallets.length} wallet(s)`,
-                data: {
-                    connectedWallets: wallets,
-                    walletsCount: wallets.length
-                },
-                ui: null
-            };
-        }
-    });
-    // Create a test context
-    const testContext = {
-        id: "test-context",
-        name: "Test Context",
-        description: "A test context for plugin testing",
-        getContextData: async (agentInfo, context) => {
-            // Use the time plugin data if available
-            const timeData = context?.plugins?.["time-plugin"] || {};
-            return {
-                message: "This is test context data",
-                timestamp: Date.now(),
-                pluginData: timeData
-            };
-        }
-    };
-    // Create a test widget
-    const testWidget = {
-        id: "test-widget",
-        name: "Test Widget",
-        description: "A test widget for plugin testing",
-        icon: "🧪",
-        getWidget: async (agentInfo, context) => {
-            // Use the crypto plugin data if available
-            const cryptoData = context?.plugins?.["crypto-plugin"] || {};
-            return {
-                text: "This is a test widget",
-                data: {
-                    type: "text",
-                    content: "This is a test widget",
-                    timestamp: Date.now(),
-                    wallets: cryptoData?.wallets || []
-                },
-                ui: { type: "text" }
-            };
-        }
-    };
-    // Initialize the connection to the DAIN service with both plugins
-    const dainConnection = new client_1.DainServiceConnection("http://localhost:4484", agentAuth, {
-        plugins: [timePlugin, cryptoPlugin]
-    });
-    // Create a test tool
-    const echoTool = (0, core_1.createTool)({
-        id: "echo",
-        name: "Echo Tool",
-        description: "Echoes back the input with plugin data",
-        input: zod_1.z.object({ message: zod_1.z.string() }),
-        output: zod_1.z.object({ message: zod_1.z.string(), plugins: zod_1.z.any() }),
-        handler: async ({ message }, agentInfo, context) => {
-            console.log("Context:", JSON.stringify(context, null, 2));
-            // Use the TimePlugin helper to get plugin data from context
-            const timeData = timePlugin.getTimeDataFromContext(context);
-            const clientTimezone = timePlugin.getClientTimezone(context);
-            console.log(`Tool handling: received client timestamp ${timeData.clientTimestamp}`);
-            if (clientTimezone) {
-                console.log(`Client timezone: ${clientTimezone}`);
-            }
-            return {
-                text: `Echoed: ${message}`,
-                data: {
-                    message,
-                    plugins: context.extraData?.plugins || {}
-                },
-                ui: null,
-            };
-        },
-    });
-    // Initialize the DAIN service with both plugins
-    const dainService = (0, nodeService_1.defineDAINService)({
-        metadata: {
-            title: "Plugin Test Service",
-            description: "A DAIN service for testing plugins",
-            version: "1.0.0",
-            author: "Test Author",
-            tags: ["plugin", "test"],
-        },
-        identity: {
-            publicKey: bs58_1.default.encode(publicKey),
-            agentId: "plugin-agent",
-            orgId: "plugin-org",
-            privateKey: bs58_1.default.encode(privateKey),
-        },
-        tools: [echoTool, walletInfoTool],
-        plugins: [timePlugin, cryptoPlugin],
-        contexts: [testContext],
-        widgets: [testWidget],
-        exampleQueries: [
-            { category: "General", queries: ["How does this work?", "Show me the weather"] }
-        ]
-    });
-    let server;
-    beforeAll(async () => {
-        server = await dainService.startNode({ port: 4484 });
-        await new Promise(resolve => setTimeout(resolve, 500)); // Give server time to start
-    });
-    afterAll(async () => {
-        await server.shutdown();
-    });
-    it("should process plugin data in requests and responses", async () => {
-        // Call the echo tool with a message
-        const result = await dainConnection.callTool("echo", { message: "Hello, plugins!" });
-        console.log("Tool result:", JSON.stringify(result, null, 2));
-        // Verify that the message was echoed correctly
-        expect(result.data.message).toBe("Hello, plugins!");
-        // Verify that the time plugin data is in the response
-        expect(result.plugins).toBeDefined();
-        expect(result.plugins["time-plugin"]).toBeDefined();
-        // Use the TimePlugin helper to get typed response data
-        const timeData = timePlugin.getResponseData(result);
-        expect(timeData).toBeDefined();
-        // Check the time plugin data
-        expect(timeData.clientTimestamp).toBeDefined();
-        expect(timeData.serviceTimestamp).toBeDefined();
-        expect(timeData.roundtripTime).toBeDefined();
-        expect(timeData.timezone).toBeDefined();
-        // The service timestamp should be later than the client timestamp
-        expect(timeData.serviceTimestamp).toBeGreaterThanOrEqual(timeData.clientTimestamp);
-        // The roundtrip time should be non-negative
-        expect(timeData.roundtripTime).toBeGreaterThanOrEqual(0);
-        // The timezone should be a non-empty string
-        expect(typeof timeData.timezone).toBe("string");
-        expect(timeData.timezone.length).toBeGreaterThan(0);
-        console.log("Time plugin data:", timeData);
-        // Use TimePlugin's helper methods for displaying timestamps nicely
-        console.log(`Request started at: ${timePlugin.formatTimestamp(timeData.clientTimestamp)}`);
-        console.log(`Response created at: ${timePlugin.formatTimestamp(timeData.serviceTimestamp)}`);
-        console.log(`Roundtrip time: ${timeData.roundtripTime}ms`);
-        console.log(`Client timezone: ${timeData.timezone}`);
-        // Demonstrate the elapsed time calculation helper
-        const processingTime = timePlugin.calculateElapsedTime(timeData.clientTimestamp, timeData.serviceTimestamp);
-        console.log(`Service processing time: ${processingTime}ms`);
-    });
-    it("should verify crypto plugin automatically sends wallet data to server", async () => {
-        // Call the wallet info tool
-        const result = await dainConnection.callTool("wallet-info", {});
-        console.log("Wallet info result:", JSON.stringify(result, null, 2));
-        // Verify that wallet information was received by the service
-        expect(result.data.walletsCount).toBe(testWallets.length);
-        expect(result.data.connectedWallets.length).toBe(testWallets.length);
-        // Check that the wallet information matches what we provided
-        const solWallet = result.data.connectedWallets.find(w => w.chain === "sol");
-        expect(solWallet).toBeDefined();
-        expect(solWallet?.address).toBe("SolTestAddress123456789");
-        const ethWallet = result.data.connectedWallets.find(w => w.chain === "eth");
-        expect(ethWallet).toBeDefined();
-        expect(ethWallet?.address).toBe("0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266");
-        // Verify that time plugin data is also present in the response
-        // This confirms both plugins work together
-        expect(result.plugins).toBeDefined();
-        expect(result.plugins["time-plugin"]).toBeDefined();
-        console.log("Wallet information was successfully transferred from client to service");
-    });
-    it("should work with streaming responses", async () => {
-        const events = [];
-        // Call the echo tool with streaming enabled
-        const result = await dainConnection.callTool("echo", { message: "Hello with streaming!" }, {
-            onUIUpdate: (update) => {
-                events.push({ type: 'ui', timestamp: Date.now(), data: update });
-            }
-        });
-        // Add the final result to the events
-        events.push({ type: 'result', timestamp: Date.now(), data: result });
-        // Verify the result has plugin data
-        expect(result.plugins).toBeDefined();
-        expect(result.plugins["time-plugin"]).toBeDefined();
-        // Get typed plugin data using helper
-        const timeData = timePlugin.getResponseData(result);
-        expect(timeData).toBeDefined();
-        expect(timeData.roundtripTime).toBeDefined();
-        console.log("Streaming result time data:", timeData);
-        console.log(`Streaming roundtrip time: ${timeData.roundtripTime}ms`);
-    });
-    it("should work when calling a tool and getting context", async () => {
-        // Call the echo tool and get context
-        const result = await dainConnection.callToolAndGetNewContext("echo", {
-            message: "Hello with context!"
-        });
-        // Verify the result has plugin data
-        expect(result.plugins).toBeDefined();
-        expect(result.plugins["time-plugin"]).toBeDefined();
-        // Get typed plugin data using helper
-        const timeData = timePlugin.getResponseData(result);
-        expect(timeData).toBeDefined();
-        expect(timeData.roundtripTime).toBeDefined();
-        // Verify the tool result
-        expect(result.toolResult.data.message).toBe("Hello with context!");
-        console.log("Context result time data:", timeData);
-        console.log(`Context roundtrip time: ${timeData.roundtripTime}ms`);
-    });
-    it("should use helper methods to create custom time responses", async () => {
-        // Create a mock context with plugin data
-        const mockContext = {
-            extraData: {
-                plugins: {
-                    "time-plugin": {
-                        clientTimestamp: Date.now() - 100, // 100ms ago
-                        timezone: "Europe/London"
-                    }
-                }
-            }
-        };
-        // Use helper to extract the plugin data
-        const inputData = timePlugin.getTimeDataFromContext(mockContext);
-        expect(inputData.clientTimestamp).toBeDefined();
-        expect(inputData.timezone).toBe("Europe/London");
-        // Use helper to create a response
-        const response = timePlugin.createTimestampResponse(inputData);
-        expect(response.clientTimestamp).toBe(inputData.clientTimestamp);
-        expect(response.serviceTimestamp).toBeDefined();
-        expect(response.timezone).toBe("Europe/London");
-        // Calculate processing time
-        const processingTime = timePlugin.calculateElapsedTime(response.clientTimestamp, response.serviceTimestamp);
-        console.log(`Mock request: client timestamp is ${timePlugin.formatTimestamp(inputData.clientTimestamp)}`);
-        console.log(`Mock response: service timestamp is ${timePlugin.formatTimestamp(response.serviceTimestamp)}`);
-        console.log(`Mock processing time: ${processingTime}ms`);
-    });
-    it("should demonstrate the createResponse method for plugin responses", async () => {
-        console.log("=== DEMONSTRATING createResponse METHOD ===");
-        // Scenario 1: Create a minimal response with just required fields
-        const minimalResponse = timePlugin.createResponse({
-            clientTimestamp: 1742160000000,
-            serviceTimestamp: 1742160000050
-        });
-        console.log("Minimal Response:", minimalResponse);
-        expect(minimalResponse.clientTimestamp).toBe(1742160000000);
-        expect(minimalResponse.serviceTimestamp).toBe(1742160000050);
-        expect(minimalResponse.timezone).toBeUndefined();
-        expect(minimalResponse.roundtripTime).toBeUndefined();
-        // Scenario 2: Create a complete response with all fields
-        const completeResponse = timePlugin.createResponse({
-            clientTimestamp: 1742160000100,
-            serviceTimestamp: 1742160000150,
-            timezone: "America/Chicago",
-            roundtripTime: 75
-        });
-        console.log("Complete Response:", completeResponse);
-        expect(completeResponse.clientTimestamp).toBe(1742160000100);
-        expect(completeResponse.serviceTimestamp).toBe(1742160000150);
-        expect(completeResponse.timezone).toBe("America/Chicago");
-        expect(completeResponse.roundtripTime).toBe(75);
-        // Scenario 3: Using createResponse to transform or annotate data
-        const rawData = {
-            clientTimestamp: Date.now() - 200,
-            serviceTimestamp: Date.now() - 100
-        };
-        // Add a timezone and calculate a roundtrip time
-        const enhancedResponse = timePlugin.createResponse({
-            ...rawData,
-            timezone: "UTC",
-            roundtripTime: rawData.serviceTimestamp - rawData.clientTimestamp
-        });
-        console.log("Enhanced Response:", enhancedResponse);
-        expect(enhancedResponse.timezone).toBe("UTC");
-        expect(enhancedResponse.roundtripTime).toBe(100);
-        // Scenario 4: Practical example - modifying an existing plugin response
-        const existingResponse = {
-            clientTimestamp: 1742160000200,
-            serviceTimestamp: 1742160000300,
-            timezone: "Europe/Berlin"
-        };
-        // Add roundtrip time to an existing response
-        const updatedResponse = timePlugin.createResponse({
-            ...existingResponse,
-            roundtripTime: 120 // Custom roundtrip calculation
-        });
-        console.log("Updated Response:", updatedResponse);
-        expect(updatedResponse).toEqual({
-            clientTimestamp: 1742160000200,
-            serviceTimestamp: 1742160000300,
-            timezone: "Europe/Berlin",
-            roundtripTime: 120
-        });
-        // Scenario 5: Integration with other helper methods
-        const now = Date.now();
-        const sampleInput = { clientTimestamp: now - 150, timezone: "Asia/Tokyo" };
-        // Create a response using multiple helper methods together
-        const integratedResponse = timePlugin.createResponse({
-            clientTimestamp: sampleInput.clientTimestamp,
-            serviceTimestamp: now,
-            timezone: sampleInput.timezone,
-            roundtripTime: timePlugin.calculateElapsedTime(sampleInput.clientTimestamp, now)
-        });
-        console.log("Integrated Response:", integratedResponse);
-        console.log(`From ${timePlugin.formatTimestamp(integratedResponse.clientTimestamp)}`);
-        console.log(`To ${timePlugin.formatTimestamp(integratedResponse.serviceTimestamp)}`);
-        console.log(`Elapsed: ${integratedResponse.roundtripTime}ms in ${integratedResponse.timezone}`);
-        expect(integratedResponse.roundtripTime).toBe(150);
-        expect(integratedResponse.timezone).toBe("Asia/Tokyo");
-    });
-    it("should demonstrate practical usage of createTimingResponse for real-world scenarios", async () => {
-        console.log("\n=== DEMONSTRATING PRACTICAL USAGE OF TIME PLUGIN ===\n");
-        // Example 1: Measuring execution time of an expensive operation
-        const simulateExpensiveOperation = async (duration) => {
-            return new Promise(resolve => setTimeout(() => resolve(`Operation completed`), duration));
-        };
-        console.log("Example 1: Measuring database query performance");
-        console.log("----------------------------------------------");
-        const dbQueryStart = Date.now();
-        // Simulate a database query that takes 50ms
-        await simulateExpensiveOperation(50);
-        // Generate timing information for this operation
-        const dbQueryTiming = timePlugin.createTimingResponse(dbQueryStart, {
-            operationType: "database-query",
-            includeTimezone: true,
-            metadata: {
-                table: "users",
-                rowsReturned: 250,
-                indexUsed: "user_id_idx"
-            }
-        });
-        console.log(`Database query timing: ${JSON.stringify(dbQueryTiming, null, 2)}`);
-        console.log(`Query started at: ${timePlugin.formatTimestamp(dbQueryTiming.clientTimestamp)}`);
-        console.log(`Query completed at: ${timePlugin.formatTimestamp(dbQueryTiming.serviceTimestamp)}`);
-        console.log(`Query took approximately: ${dbQueryTiming.roundtripTime}ms`);
-        expect(dbQueryTiming.roundtripTime).toBeGreaterThanOrEqual(50);
-        expect(dbQueryTiming.timezone).toBeDefined();
-        // Example 2: API request/response cycle with multiple operations
-        console.log("\nExample 2: Full API request cycle with multiple operations");
-        console.log("------------------------------------------------------");
-        // Simulate a complete API request handler with multiple operations
-        const handleApiRequest = async (requestData) => {
-            // 1. Record request start time
-            const requestStart = Date.now();
-            // 2. Validate request (10ms)
-            await simulateExpensiveOperation(10);
-            const validationTiming = timePlugin.createTimingResponse(requestStart, {
-                operationType: "request-validation"
-            });
-            // 3. Process data (30ms)
-            const processingStart = Date.now();
-            await simulateExpensiveOperation(30);
-            const processingTiming = timePlugin.createTimingResponse(processingStart, {
-                operationType: "data-processing"
-            });
-            // 4. Generate response with detailed timing information
-            return {
-                data: { result: "Success", id: requestData.id },
-                timing: {
-                    total: timePlugin.createTimingResponse(requestStart),
-                    validation: validationTiming,
-                    processing: processingTiming
-                }
-            };
-        };
-        // Simulate an API request
-        const apiResponse = await handleApiRequest({ id: 12345, action: "getData" });
-        console.log("API Response:", JSON.stringify(apiResponse, null, 2));
-        console.log(`Total request time: ${apiResponse.timing.total.roundtripTime}ms`);
-        console.log(`- Validation time: ${apiResponse.timing.validation.roundtripTime}ms`);
-        console.log(`- Processing time: ${apiResponse.timing.processing.roundtripTime}ms`);
-        expect(apiResponse.timing.total.roundtripTime).toBeGreaterThanOrEqual(40);
-        expect(apiResponse.timing.validation.roundtripTime).toBeGreaterThanOrEqual(10);
-        expect(apiResponse.timing.processing.roundtripTime).toBeGreaterThanOrEqual(30);
-        // Show how this would be integrated into a real DAIN plugin response
-        const pluginResponse = {
-            data: apiResponse.data,
-            plugins: {
-                "time-plugin": timePlugin.createTimingResponse(apiResponse.timing.total.clientTimestamp, {
-                    includeTimezone: true
-                })
-            }
-        };
-        console.log("\nFinal plugin response:");
-        console.log(JSON.stringify(pluginResponse, null, 2));
-        expect(pluginResponse.plugins["time-plugin"].roundtripTime).toBeGreaterThanOrEqual(40);
-        expect(pluginResponse.plugins["time-plugin"].timezone).toBeDefined();
-    });
-    it("should verify multiple plugins can work together and consistently provide data", async () => {
-        // We'll call wallet-info tool multiple times sequentially to ensure different timestamps
-        const result1 = await dainConnection.callTool("wallet-info", {});
-        // Small delay to ensure different timestamps
-        await new Promise(resolve => setTimeout(resolve, 10));
-        const result2 = await dainConnection.callTool("wallet-info", {});
-        await new Promise(resolve => setTimeout(resolve, 10));
-        const result3 = await dainConnection.callTool("wallet-info", {});
-        const results = [result1, result2, result3];
-        // Verify all calls received wallet data
-        results.forEach((result, index) => {
-            console.log(`Call ${index + 1} wallet count:`, result.data.walletsCount);
-            expect(result.data.walletsCount).toBe(testWallets.length);
-            // Each call should also have time plugin data
-            expect(result.plugins["time-plugin"]).toBeDefined();
-            // Times should be different for each call (now that we're using sequential requests)
-            if (index > 0) {
-                const prevTimeData = timePlugin.getResponseData(results[index - 1]);
-                const currTimeData = timePlugin.getResponseData(result);
-                // With sequential requests and delay, timestamps should now be different
-                expect(currTimeData?.clientTimestamp).not.toBe(prevTimeData?.clientTimestamp);
-                expect(currTimeData?.serviceTimestamp).not.toBe(prevTimeData?.serviceTimestamp);
-            }
-        });
-        // Modify wallet data during the test
-        const newWallet = { chain: "arb", address: "0xArbTestWalletAddress" };
-        cryptoPlugin.addWallet(newWallet);
-        // Call again and verify the new wallet data was sent
-        const finalResult = await dainConnection.callTool("wallet-info", {});
-        expect(finalResult.data.walletsCount).toBe(testWallets.length + 1); // Added one more wallet
-        // Verify the new wallet is in the result
-        const arbWallet = finalResult.data.connectedWallets.find(w => w.chain === "arb");
-        expect(arbWallet).toBeDefined();
-        expect(arbWallet?.address).toBe("0xArbTestWalletAddress");
-        console.log("Multiple plugin test complete - wallet data is consistently provided");
-    });
-    it("should ensure getAllContexts returns an array when plugins are used", async () => {
-        // Get all contexts using a connection with plugins enabled
-        const contexts = await dainConnection.getAllContexts();
-        // Log out the contexts for debugging
-        console.log("Contexts with plugins:", contexts);
-        // Verify that the result is an array
-        expect(Array.isArray(contexts)).toBe(true);
-        // Contexts might be empty in this test, but the type should be correct
-        // The point is to verify we're not getting an object with plugins property instead of an array
-        if (contexts.length > 0) {
-            // If there are contexts, verify they have the expected structure
-            expect(contexts[0]).toHaveProperty('id');
-            expect(contexts[0]).toHaveProperty('name');
-            expect(contexts[0]).toHaveProperty('description');
-            expect(contexts[0]).toHaveProperty('data');
-        }
-    });
-    it("should ensure getContext returns a context object when plugins are used", async () => {
-        // Only run this test if there are contexts available
-        const allContexts = await dainConnection.getAllContexts();
-        if (allContexts.length === 0) {
-            console.log("Skipping getContext test as no contexts are available");
-            return;
-        }
-        // Get the first context using a connection with plugins enabled
-        const contextId = allContexts[0].id;
-        const context = await dainConnection.getContext(contextId);
-        // Log out the context for debugging
-        console.log("Context with plugins:", context);
-        // Verify that the result is a context object, not a response with plugins
-        expect(context).toHaveProperty('id');
-        expect(context).toHaveProperty('name');
-        expect(context).toHaveProperty('description');
-        expect(context).toHaveProperty('data');
-        // Make sure the context has the correct ID
-        expect(context.id).toBe(contextId);
-    });
-    it("should ensure getAllWidgets returns an array when plugins are used", async () => {
-        // Get all widgets using a connection with plugins enabled
-        const widgets = await dainConnection.getAllWidgets();
-        // Log out the widgets for debugging
-        console.log("Widgets with plugins:", widgets);
-        // Verify that the result is an array
-        expect(Array.isArray(widgets)).toBe(true);
-        // Widgets might be empty in this test, but the type should be correct
-        // The point is to verify we're not getting an object with plugins property instead of an array
-        if (widgets.length > 0) {
-            // If there are widgets, verify they have the expected structure
-            expect(widgets[0]).toHaveProperty('id');
-            expect(widgets[0]).toHaveProperty('name');
-            expect(widgets[0]).toHaveProperty('description');
-            expect(widgets[0]).toHaveProperty('icon');
-            expect(widgets[0]).toHaveProperty('text');
-        }
-    });
-    it("should ensure getWidget returns a widget object when plugins are used", async () => {
-        // Only run this test if there are widgets available
-        const allWidgets = await dainConnection.getAllWidgets();
-        if (allWidgets.length === 0) {
-            console.log("Skipping getWidget test as no widgets are available");
-            return;
-        }
-        // Get the first widget using a connection with plugins enabled
-        const widgetId = allWidgets[0].id;
-        const widget = await dainConnection.getWidget(widgetId);
-        // Log out the widget for debugging
-        console.log("Widget with plugins:", widget);
-        // Verify that the result is a widget object, not a response with plugins
-        expect(widget).toHaveProperty('id');
-        expect(widget).toHaveProperty('name');
-        expect(widget).toHaveProperty('description');
-        expect(widget).toHaveProperty('icon');
-        expect(widget).toHaveProperty('text');
-        // Make sure the widget has the correct ID
-        expect(widget.id).toBe(widgetId);
-    });
-    it("should ensure listDatasources and postAllDatasources handle plugins correctly", async () => {
-        // Try calling the methods to ensure they work properly with plugins enabled
-        const datasources1 = await dainConnection.listDatasources();
-        expect(Array.isArray(datasources1)).toBe(true);
-        const datasources2 = await dainConnection.postAllDatasources();
-        expect(Array.isArray(datasources2)).toBe(true);
-    });
-    it("should ensure getDatasource returns a datasource object when plugins are used", async () => {
-        // Skip the datasource test until we have a proper way to register datasources for testing
-        console.log("Skipping active getDatasource test as it requires datasource registration");
-    });
-    it("should ensure getAllToolsAsJsonSchema properly handles plugin data", async () => {
-        // Call getAllToolsAsJsonSchema with plugins enabled
-        const result = await dainConnection.getAllToolsAsJsonSchema();
-        // Log for debugging
-        console.log("getAllToolsAsJsonSchema result:", result);
-        // Verify the result structure
-        expect(result).toHaveProperty('tools');
-        expect(result).toHaveProperty('reccomendedPrompts');
-        expect(Array.isArray(result.tools)).toBe(true);
-        // Verify tools contain expected properties
-        if (result.tools.length > 0) {
-            const tool = result.tools[0];
-            expect(tool).toHaveProperty('id');
-            expect(tool).toHaveProperty('name');
-            expect(tool).toHaveProperty('description');
-            expect(tool).toHaveProperty('inputSchema');
-        }
-        // The plugins themselves shouldn't be in the result - they should be handled internally
-        expect(result).not.toHaveProperty('plugins');
-    });
-    it("should ensure getMetadata properly handles plugin data", async () => {
-        // Call getMetadata with plugins enabled
-        const metadata = await dainConnection.getMetadata();
-        // Log for debugging
-        console.log("getMetadata result:", metadata);
-        // Verify metadata structure
-        expect(metadata).toHaveProperty('title');
-        expect(metadata).toHaveProperty('description');
-        expect(metadata).toHaveProperty('version');
-        // The plugins themselves shouldn't be in the result - they should be handled internally
-        expect(metadata).not.toHaveProperty('plugins');
-    });
-    it("should ensure getWidgets properly handles plugin data", async () => {
-        // Call getWidgets with plugins enabled
-        const widgets = await dainConnection.getWidgets();
-        // Log for debugging
-        console.log("getWidgets result:", widgets);
-        // Verify the result is an array, even when plugins are used
-        expect(Array.isArray(widgets)).toBe(true);
-        // Verify widgets structure if any exist
-        if (widgets.length > 0) {
-            const widgetId = widgets[0];
-            expect(typeof widgetId).toBe('string');
-        }
-    });
-    it("should ensure getExampleQueries properly handles plugin data", async () => {
-        // Call getExampleQueries with plugins enabled
-        const queries = await dainConnection.getExampleQueries();
-        // Log for debugging
-        console.log("getExampleQueries result:", queries);
-        // Verify the result is an array, even when plugins are used
-        expect(Array.isArray(queries)).toBe(true);
-        // The plugins themselves shouldn't be in the result - they should be handled internally
-        if (queries.length > 0) {
-            // Example queries can be strings or objects with category and queries
-            const firstQuery = queries[0];
-            if (typeof firstQuery === 'string') {
-                expect(typeof firstQuery).toBe('string');
-            }
-            else {
-                expect(firstQuery).toHaveProperty('category');
-                expect(firstQuery).toHaveProperty('queries');
-                expect(Array.isArray(firstQuery.queries)).toBe(true);
-            }
-        }
-    });
-});
-/**
- * Additional plugin tests specifically for handling plugin data in API responses
- * Tests all API methods both with and without data, ensuring proper handling of plugin-wrapped responses
- */
-describe("Plugin Data Handling in API Responses", () => {
-    // Generate keys for both services
-    const fullPrivateKey = ed25519_1.ed25519.utils.randomPrivateKey();
-    const fullPublicKey = ed25519_1.ed25519.getPublicKey(fullPrivateKey);
-    const emptyPrivateKey = ed25519_1.ed25519.utils.randomPrivateKey();
-    const emptyPublicKey = ed25519_1.ed25519.getPublicKey(emptyPrivateKey);
-    // Client auth
-    const clientPrivateKey = ed25519_1.ed25519.utils.randomPrivateKey();
-    const clientAuth = new client_auth_1.DainClientAuth({
-        privateKeyBase58: bs58_1.default.encode(clientPrivateKey),
-        agentId: "api-client",
-        orgId: "api-org",
-    });
-    // Create test plugins
-    const timePlugin = new time_plugin_1.TimePlugin({ includeTimezone: true });
-    const testWallets = [
-        { chain: "sol", address: "ApiTestSolAddress123" }
-    ];
-    const cryptoPlugin = new crypto_plugin_1.CryptoPlugin(testWallets);
-    // Create test context, pinnable, datasource
-    const testContext = {
-        id: "api-context",
-        name: "API Test Context",
-        description: "Context for API plugin tests",
-        getContextData: async (agentInfo, context) => {
-            // Include plugin data in the response for verification
-            return {
-                value: "Context data",
-                timestamp: Date.now(),
-                pluginInfo: context?.plugins || {}
-            };
-        }
-    };
-    const testWidget = {
-        id: "api-widget",
-        name: "API Test Widget",
-        description: "Widget for API plugin tests",
-        icon: "🔧",
-        getWidget: async (agentInfo, context) => {
-            return {
-                text: "API Test Widget",
-                data: {
-                    type: "text",
-                    content: "API Test Widget",
-                    timestamp: Date.now(),
-                    pluginInfo: context?.plugins || {}
-                },
-                ui: { type: "text" }
-            };
-        }
-    };
-    const testDatasource = {
-        id: "api-datasource",
-        name: "API Test Datasource",
-        description: "Datasource for API plugin tests",
-        type: "json",
-        input: zod_1.z.object({
-            query: zod_1.z.string().optional()
-        }),
-        getDatasource: async (agentInfo, params, context) => {
-            return {
-                results: ["Result 1", "Result 2"],
-                timestamp: Date.now(),
-                pluginInfo: context?.plugins || {}
-            };
-        }
-    };
-    // Create test tool
-    const testTool = (0, core_1.createTool)({
-        id: "api-tool",
-        name: "API Test Tool",
-        description: "Tool for API plugin tests",
-        input: zod_1.z.object({ data: zod_1.z.string() }),
-        output: zod_1.z.object({ result: zod_1.z.string() }),
-        handler: async ({ data }, agentInfo, context) => {
-            return {
-                text: `Processed: ${data}`,
-                data: {
-                    result: data,
-                    pluginInfo: context.extraData?.plugins || {}
-                },
-                ui: null
-            };
-        }
-    });
-    // Service with all data types
-    const fullService = (0, nodeService_1.defineDAINService)({
-        metadata: {
-            title: "Full API Test Service",
-            description: "Service with all data types for testing plugin handling",
-            version: "1.0.0",
-            author: "Test",
-            tags: ["test"]
-        },
-        identity: {
-            publicKey: bs58_1.default.encode(fullPublicKey),
-            agentId: "full-agent",
-            orgId: "full-org",
-            privateKey: bs58_1.default.encode(fullPrivateKey)
-        },
-        tools: [testTool],
-        plugins: [timePlugin, cryptoPlugin],
-        contexts: [testContext],
-        widgets: [testWidget],
-        datasources: [testDatasource],
-        exampleQueries: [
-            { category: "Test", queries: ["Test query 1", "Test query 2"] }
-        ]
-    });
-    // Service with minimal data
-    const emptyService = (0, nodeService_1.defineDAINService)({
-        metadata: {
-            title: "Empty API Test Service",
-            description: "Service with minimal data for testing plugin handling",
-            version: "1.0.0",
-            author: "Test",
-            tags: ["test"]
-        },
-        identity: {
-            publicKey: bs58_1.default.encode(emptyPublicKey),
-            agentId: "empty-agent",
-            orgId: "empty-org",
-            privateKey: bs58_1.default.encode(emptyPrivateKey)
-        },
-        tools: [testTool],
-        plugins: [timePlugin, cryptoPlugin],
-        contexts: [],
-        widgets: [],
-        datasources: [],
-        exampleQueries: []
-    });
-    // Client connections
-    const fullConnection = new client_1.DainServiceConnection("http://localhost:4581", clientAuth, { plugins: [timePlugin, cryptoPlugin] });
-    const emptyConnection = new client_1.DainServiceConnection("http://localhost:4582", clientAuth, { plugins: [timePlugin, cryptoPlugin] });
-    // Server instances
-    let fullServer;
-    let emptyServer;
-    beforeAll(async () => {
-        fullServer = await fullService.startNode({ port: 4581 });
-        emptyServer = await emptyService.startNode({ port: 4582 });
-        await new Promise(resolve => setTimeout(resolve, 500)); // Server startup time
-    });
-    afterAll(async () => {
-        await fullServer?.shutdown();
-        await emptyServer?.shutdown();
-    });
-    // TEST METADATA
-    it("getMetadata handles plugins with either service", async () => {
-        // With data
-        const fullMetadata = await fullConnection.getMetadata();
-        expect(fullMetadata).toHaveProperty('title');
-        expect(fullMetadata).not.toHaveProperty('plugins');
-        // Without data
-        const emptyMetadata = await emptyConnection.getMetadata();
-        expect(emptyMetadata).toHaveProperty('title');
-        expect(emptyMetadata).not.toHaveProperty('plugins');
-    });
-    // TEST TOOLS
-    it("getTools handles plugins with either service", async () => {
-        // With data
-        const fullTools = await fullConnection.getTools();
-        expect(Array.isArray(fullTools)).toBe(true);
-        expect(fullTools.length).toBeGreaterThan(0);
-        expect(fullTools[0]).not.toHaveProperty('plugins');
-        // Without data
-        const emptyTools = await emptyConnection.getTools();
-        expect(Array.isArray(emptyTools)).toBe(true);
-        expect(emptyTools.length).toBeGreaterThan(0);
-        expect(emptyTools[0]).not.toHaveProperty('plugins');
-    });
-    it("getAllToolsAsJsonSchema handles plugins with either service", async () => {
-        // With data
-        const fullTools = await fullConnection.getAllToolsAsJsonSchema();
-        expect(fullTools).toHaveProperty('tools');
-        expect(Array.isArray(fullTools.tools)).toBe(true);
-        expect(fullTools).not.toHaveProperty('plugins');
-        // Without data
-        const emptyTools = await emptyConnection.getAllToolsAsJsonSchema();
-        expect(emptyTools).toHaveProperty('tools');
-        expect(Array.isArray(emptyTools.tools)).toBe(true);
-        expect(emptyTools).not.toHaveProperty('plugins');
-    });
-    // TEST CONTEXTS
-    it("getAllContexts handles plugins with either service", async () => {
-        // With data
-        const fullContexts = await fullConnection.getAllContexts();
-        expect(Array.isArray(fullContexts)).toBe(true);
-        expect(fullContexts.length).toBeGreaterThan(0);
-        expect(fullContexts[0]).toHaveProperty('data');
-        expect(fullContexts[0]).not.toHaveProperty('plugins');
-        // Without data - should return empty array, not object with plugins
-        const emptyContexts = await emptyConnection.getAllContexts();
-        expect(Array.isArray(emptyContexts)).toBe(true);
-        expect(emptyContexts.length).toBe(0);
-    });
-    it("getContext handles plugins with full service", async () => {
-        const contexts = await fullConnection.getAllContexts();
-        const context = await fullConnection.getContext(contexts[0].id);
-        expect(context).toHaveProperty('id');
-        expect(context).toHaveProperty('data');
-        expect(context).not.toHaveProperty('plugins');
-        // Context data should have the structure defined in testContext
-        expect(context.data).toHaveProperty('value');
-        expect(context.data).toHaveProperty('timestamp');
-    });
-    // TEST WIDGETS
-    it("getAllWidgets handles plugins with either service", async () => {
-        // With data
-        const fullWidgets = await fullConnection.getAllWidgets();
-        expect(Array.isArray(fullWidgets)).toBe(true);
-        expect(fullWidgets.length).toBeGreaterThan(0);
-        expect(fullWidgets[0]).toHaveProperty('icon');
-        expect(fullWidgets[0]).toHaveProperty('text');
-        expect(fullWidgets[0]).not.toHaveProperty('plugins');
-        // Without data - should return empty array, not object with plugins
-        const emptyWidgets = await emptyConnection.getAllWidgets();
-        expect(Array.isArray(emptyWidgets)).toBe(true);
-        expect(emptyWidgets.length).toBe(0);
-    });
-    it("getWidget handles plugins with full service", async () => {
-        const widgets = await fullConnection.getAllWidgets();
-        const widget = await fullConnection.getWidget(widgets[0].id);
-        expect(widget).toHaveProperty('id');
-        expect(widget).toHaveProperty('icon');
-        expect(widget).toHaveProperty('text');
-        expect(widget).not.toHaveProperty('plugins');
-        // Widget data should have the structure defined in testWidget or be empty
-        // Some implementations might return empty widget objects in tests
-        if (widget.data && Object.keys(widget.data).length > 0) {
-            expect(widget.data).toHaveProperty('content');
-            expect(widget.data).toHaveProperty('timestamp');
-        }
-    });
-    it("getWidgets handles plugins with either service", async () => {
-        // With data
-        const fullWidgetIds = await fullConnection.getWidgets();
-        expect(Array.isArray(fullWidgetIds)).toBe(true);
-        expect(fullWidgetIds.length).toBeGreaterThan(0);
-        expect(typeof fullWidgetIds[0]).toBe('string');
-        // Without data
-        const emptyWidgetIds = await emptyConnection.getWidgets();
-        expect(Array.isArray(emptyWidgetIds)).toBe(true);
-        expect(emptyWidgetIds.length).toBe(0);
-    });
-    // TEST DATASOURCES
-    it("listDatasources handles plugins with either service", async () => {
-        // With data
-        const fullDatasources = await fullConnection.listDatasources();
-        expect(Array.isArray(fullDatasources)).toBe(true);
-        expect(fullDatasources.length).toBeGreaterThan(0);
-        expect(fullDatasources[0]).not.toHaveProperty('plugins');
-        // Without data
-        const emptyDatasources = await emptyConnection.listDatasources();
-        expect(Array.isArray(emptyDatasources)).toBe(true);
-        expect(emptyDatasources.length).toBe(0);
-    });
-    it("getDatasource handles plugins with full service", async () => {
-        const datasource = await fullConnection.getDatasource("api-datasource", { query: "test" });
-        expect(datasource).toHaveProperty('id');
-        expect(datasource).toHaveProperty('data');
-        expect(datasource).not.toHaveProperty('plugins');
-        // Datasource data should have the structure defined in testDatasource
-        expect(datasource.data).toHaveProperty('results');
-        expect(Array.isArray(datasource.data.results)).toBe(true);
-    });
-    // TEST EXAMPLE QUERIES
-    it("getExampleQueries handles plugins with either service", async () => {
-        // With data
-        const fullQueries = await fullConnection.getExampleQueries();
-        expect(Array.isArray(fullQueries)).toBe(true);
-        expect(fullQueries.length).toBeGreaterThan(0);
-        // Without data
-        const emptyQueries = await emptyConnection.getExampleQueries();
-        expect(Array.isArray(emptyQueries)).toBe(true);
-        expect(emptyQueries.length).toBe(0);
-    });
-});
-//# sourceMappingURL=plugin.test.js.map