@dainprotocol/service-sdk 2.0.51 → 2.0.53

package/dist/__tests__/integration.test.js

@@ -1,1573 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-//File: src/___tests___/integration.test.ts
-const nodeService_1 = require("../service/nodeService");
-const core_1 = require("@/service/core");
-const interfaces_1 = require("@/interfaces");
-const zod_1 = require("zod");
-const supertest_1 = tslib_1.__importDefault(require("supertest"));
-const ed25519_1 = require("@noble/curves/ed25519");
-const bs58_1 = tslib_1.__importDefault(require("bs58"));
-const convertToVercelTool_1 = require("@/lib/convertToVercelTool");
-const schemaStructure_1 = require("@/lib/schemaStructure");
-const client_auth_1 = require("@/client/client-auth");
-const client_1 = require("@/client/client");
-describe("DAIN Framework Integration", () => {
-    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",
-    });
-    // Initialize the connection to the DAIN service
-    const dainConnection = new client_1.DainServiceConnection(
-    //agent URI
-    "http://localhost:3003", agentAuth);
-    const weatherTool = (0, nodeService_1.createTool)({
-        id: "get-weather",
-        name: "Get Weather",
-        description: "Fetches weather for a city",
-        input: zod_1.z.object({ city: zod_1.z.string() }),
-        output: zod_1.z.object({ temperature: zod_1.z.number(), condition: zod_1.z.string() }),
-        pricing: { pricePerUse: 0.01, currency: "USD" },
-        handler: async ({ city }, agentInfo, context) => {
-            // Send loading state
-            if (context.updateUI) {
-                await context.updateUI({ ui: { type: "loading", message: "Fetching weather..." } });
-            }
-            // Add a delay to ensure events are spaced out
-            await new Promise(resolve => setTimeout(resolve, 1000));
-            // Create a process
-            const processId = await context.app.processes.createProcess(agentInfo, "one-time", "Weather Update", `Getting weather for ${city}`);
-            // Notify about process creation
-            if (context.addProcess) {
-                await context.addProcess(processId);
-            }
-            // Add another delay
-            await new Promise(resolve => setTimeout(resolve, 1000));
-            if (context.updateUI) {
-                await context.updateUI({ ui: { type: "progress", message: "Processing data..." } });
-            }
-            // Final delay before result
-            await new Promise(resolve => setTimeout(resolve, 1000));
-            return {
-                text: `The weather in ${city} is Sunny with a temperature of 22°C.`,
-                data: { temperature: 22, condition: "Sunny" },
-                ui: null,
-            };
-        },
-    });
-    const extraDataTool = (0, nodeService_1.createTool)({
-        id: "extra-data-tool",
-        name: "Extra Data Tool",
-        description: "Tool to test extra data",
-        input: zod_1.z.object({ cool: zod_1.z.string() }),
-        output: zod_1.z.any(),
-        pricing: { pricePerUse: 0.01, currency: "USD" },
-        handler: async (cool, agentInfo, { extraData }) => {
-            console.log("cool", cool);
-            console.log("agentInfo", agentInfo);
-            console.log("extraData", extraData);
-            return {
-                text: `Extra data: ${JSON.stringify(extraData)}`,
-                data: { extraData },
-                ui: null,
-            };
-        },
-    });
-    // Add a tool with all optional parameters for testing empty param calls
-    const optionalParamsTool = (0, nodeService_1.createTool)({
-        id: "optional-params-tool",
-        name: "Optional Parameters Tool",
-        description: "Tool that can be called with empty parameters",
-        input: zod_1.z.object({
-            param1: zod_1.z.string().optional(),
-            param2: zod_1.z.number().optional(),
-            param3: zod_1.z.boolean().optional()
-        }),
-        output: zod_1.z.object({
-            providedParams: zod_1.z.array(zod_1.z.string()),
-            message: zod_1.z.string()
-        }),
-        handler: async (params, agentInfo, context) => {
-            // Track which parameters were provided
-            const providedParams = Object.keys(params || {});
-            console.log("Received parameters:", providedParams.length ? providedParams : "none");
-            return {
-                text: `Called with ${providedParams.length} parameter(s): ${providedParams.join(', ')}`,
-                data: {
-                    providedParams,
-                    message: providedParams.length > 0 ? "Parameters received" : "No parameters provided"
-                },
-                ui: null,
-            };
-        },
-    });
-    // Add a tool with no parameters for testing empty param calls
-    const noParamsTool = (0, nodeService_1.createTool)({
-        id: "no-params-tool",
-        name: "No Parameters Tool",
-        description: "Tool that requires no parameters",
-        input: zod_1.z.object({}), // Empty schema - no parameters required
-        output: zod_1.z.object({ message: zod_1.z.string() }),
-        handler: async (_params, _agentInfo, _context) => {
-            console.log("No-params tool called successfully");
-            return {
-                text: "No parameters tool executed successfully",
-                data: { message: "Success - no parameters needed" },
-                ui: null,
-            };
-        },
-    });
-    // Add a new tool with confirmation for testing
-    const confirmationTool = (0, nodeService_1.createTool)({
-        id: "confirmation-test-tool",
-        name: "Confirmation Test Tool",
-        description: "Tool that requires confirmation",
-        input: zod_1.z.object({ action: zod_1.z.string() }),
-        output: zod_1.z.object({ result: zod_1.z.string() }),
-        suggestConfirmation: true,
-        suggestConfirmationUI: async (input) => ({
-            success: input.action !== "dangerous",
-            ui: {
-                type: "confirmation",
-                title: "Confirm Action",
-                message: `Are you sure you want to perform: ${input.action}?`,
-                fields: [
-                    {
-                        type: "text",
-                        label: "Additional Notes",
-                        placeholder: "Add any notes here..."
-                    }
-                ]
-            }
-        }),
-        handler: async ({ action }) => ({
-            text: `Performed action: ${action}`,
-            data: { result: `completed-${action}` },
-            ui: null,
-        }),
-    });
-    const weatherService = (0, nodeService_1.createService)({
-        id: "weather-service",
-        name: "Weather Service",
-        description: "Provides weather information",
-        metadata: {
-            capabilities: ["current-weather"],
-            languages: ["en"],
-        },
-        recommendedPrompt: "Ask about the weather",
-        recommendedTools: ["get-weather", "extra-data-tool"],
-    });
-    const weatherToolbox = (0, nodeService_1.createToolbox)({
-        id: "weather-toolbox",
-        name: "Weather Toolbox",
-        description: "Collection of weather tools",
-        tools: ["get-weather", "extra-data-tool"],
-        metadata: {
-            complexity: "Low",
-            applicableFields: ["Meteorology", "Travel"],
-        },
-        recommendedPrompt: "Use these tools for weather-related tasks",
-    });
-    const weatherContext = (0, core_1.createContext)({
-        id: "weather-context",
-        name: "Weather Context",
-        description: "Context for weather data",
-        getContextData: async () => {
-            return "Weather data";
-        },
-    });
-    // Create a datasource for testing
-    const weatherDatasource = (0, core_1.createDatasource)({
-        id: "weather-datasource",
-        name: "Weather Datasource",
-        description: "Datasource for weather data",
-        type: "json",
-        input: zod_1.z.object({
-            city: zod_1.z.string().describe("The city to get weather data for"),
-            days: zod_1.z.number().optional().describe("Number of days for forecast")
-        }),
-        getDatasource: async (agentInfo, params) => {
-            return {
-                city: params.city,
-                forecast: [
-                    { day: 1, temperature: 22, condition: "Sunny" },
-                    { day: 2, temperature: 24, condition: "Partly Cloudy" },
-                    { day: 3, temperature: 20, condition: "Rainy" }
-                ].slice(0, params.days || 3)
-            };
-        },
-    });
-    const weatherWidget = (0, core_1.createWidget)({
-        id: "weather-widget",
-        name: "Weather Info",
-        description: "Displays current weather information",
-        icon: "☀️",
-        size: "lg",
-        getWidget: async () => ({
-            text: "Current weather: Sunny, 22°C",
-            data: { temperature: 22, condition: "Sunny" },
-            ui: { type: "text" },
-        }),
-    });
-    // Create a dedicated error tool for testing
-    const errorTool = (0, nodeService_1.createTool)({
-        id: "integration-error-tool",
-        name: "Integration Error Tool",
-        description: "Tool that deliberately throws errors for testing",
-        input: zod_1.z.object({
-            errorType: zod_1.z.enum(["none", "synchronous", "async", "input"]),
-            errorMessage: zod_1.z.string().optional()
-        }),
-        output: zod_1.z.object({ result: zod_1.z.string() }),
-        handler: async ({ errorType, errorMessage = "Deliberate test error" }, agentInfo, context) => {
-            // Send UI update first to test partial success
-            if (context.updateUI) {
-                await context.updateUI({ ui: { type: "loading", message: "Starting error test..." } });
-                // Small delay to ensure UI update goes through
-                await new Promise(resolve => setTimeout(resolve, 200));
-            }
-            // Handle different error types
-            switch (errorType) {
-                case "none":
-                    return {
-                        text: "No error occurred",
-                        data: { result: "success" },
-                        ui: null
-                    };
-                case "synchronous":
-                    throw new Error(errorMessage);
-                case "async":
-                    await new Promise(resolve => setTimeout(resolve, 300));
-                    throw new Error(errorMessage);
-                case "input":
-                    // This simulates validation errors
-                    throw new Error(`Invalid input: ${errorMessage}`);
-            }
-        },
-    });
-    // Create a tool that implements the KnowledgeSearch interface
-    const knowledgeSearchTool = (0, core_1.createToolWithInterface)({
-        id: "test-knowledge-search",
-        name: "Test Knowledge Search",
-        description: "A test implementation of knowledge search",
-        interface: interfaces_1.ToolInterfaceType.KNOWLEDGE_SEARCH,
-        input: interfaces_1.KnowledgeSearchInterface.input,
-        output: interfaces_1.KnowledgeSearchInterface.output,
-        handler: async ({ query, limit = 5 }) => {
-            // Simulate search results
-            const queries = Array.isArray(query) ? query : [query];
-            const results = queries.flatMap((q, queryIndex) => Array.from({ length: Math.min(limit, 3) }, (_, i) => ({
-                content: `This is search result ${i + 1} for query "${q}". It contains relevant information about the topic.`,
-                id: `result-${queryIndex}-${i + 1}`,
-                citation: {
-                    id: `citation-${queryIndex}-${i + 1}`,
-                    ui: {
-                        type: "citation",
-                        title: `Source ${i + 1} for ${q}`,
-                        preview: `Preview of source ${i + 1}`
-                    },
-                    url: `https://example.com/source-${queryIndex}-${i + 1}`,
-                    title: `Source ${i + 1} for ${q}`,
-                    author: `Author ${i + 1}`,
-                    date: "2024-01-15",
-                    type: "article",
-                    source: "Test Knowledge Base",
-                }
-            })));
-            return {
-                text: `Found ${results.length} results for your search`,
-                data: {
-                    results,
-                    totalCount: results.length,
-                    searchId: `search-${Date.now()}`,
-                },
-                ui: {
-                    type: "search-results",
-                    results: results.map(r => ({
-                        title: r.citation.title,
-                        preview: r.content.substring(0, 100) + "...",
-                        url: r.citation.url,
-                    }))
-                },
-            };
-        },
-    });
-    // Create a test agent
-    const helpAgent = (0, core_1.createAgent)({
-        id: "help-assistant",
-        name: "Help Assistant Agent",
-        context: ["You are a helpful AI assistant", "Always provide accurate and concise answers"],
-        prompt: "Answer user questions helpfully and accurately. Provide context when necessary.",
-        resolveCondition: "User question has been answered completely and accurately",
-        input: zod_1.z.object({
-            question: zod_1.z.string().describe("The user's question"),
-            context: zod_1.z.string().optional().describe("Additional context for the question"),
-            urgency: zod_1.z.enum(["low", "medium", "high"]).optional().describe("Question urgency level")
-        }),
-        output: zod_1.z.object({
-            answer: zod_1.z.string().describe("The detailed answer to the user's question"),
-            confidence: zod_1.z.number().min(0).max(1).describe("Confidence score for the answer"),
-            sources: zod_1.z.array(zod_1.z.string()).optional().describe("Source references used"),
-            followUpQuestions: zod_1.z.array(zod_1.z.string()).optional().describe("Suggested follow-up questions")
-        }),
-        serviceConnections: ["http://localhost:3003", "https://api.example.com"]
-    });
-    const dainService = (0, nodeService_1.defineDAINService)({
-        metadata: {
-            title: "Weather DAIN Service",
-            description: "A DAIN service for weather information",
-            version: "1.0.0",
-            author: "Test Author",
-            tags: ["weather", "dain"],
-        },
-        identity: {
-            publicKey: bs58_1.default.encode(publicKey),
-            agentId: "weather-agent",
-            orgId: "weather-org",
-            privateKey: bs58_1.default.encode(privateKey),
-        },
-        services: [weatherService],
-        tools: [weatherTool, extraDataTool, confirmationTool, optionalParamsTool, noParamsTool, errorTool, knowledgeSearchTool],
-        toolboxes: [weatherToolbox],
-        contexts: [weatherContext],
-        widgets: [weatherWidget],
-        datasources: [weatherDatasource],
-        agents: [helpAgent],
-    });
-    let server;
-    beforeAll(async () => {
-        server = await dainService.startNode({ port: 3003 });
-    });
-    afterAll(async () => {
-        // Use a more robust approach to shutting down with proper cleanup
-        if (server) {
-            // Set a timeout for shutdown to complete
-            const timeout = setTimeout(() => {
-                console.warn('Server shutdown timed out, process may still have open handles');
-            }, 5000);
-            try {
-                await server.shutdown();
-            }
-            catch (err) {
-                console.error('Error shutting down server:', err);
-            }
-            finally {
-                clearTimeout(timeout);
-                server = null;
-                // Wait a moment to allow any lingering connections to close
-                await new Promise(resolve => setTimeout(resolve, 500));
-            }
-        }
-    });
-    test("Service metadata is correct", () => {
-        const metadata = dainService.getMetadata();
-        expect(metadata.title).toBe("Weather DAIN Service");
-        expect(metadata.tags).toContain("weather");
-    });
-    test("Service has correct tools and services", () => {
-        expect(dainService.getTools()).toHaveLength(7);
-        expect(dainService.getServices()).toHaveLength(1);
-        expect(dainService.getToolboxes()).toHaveLength(1);
-    });
-    test("Can call weather tool with valid signature", async () => {
-        const app = server.address();
-        const port = app.port;
-        const response = await dainConnection.makeRequest("POST", "/tools/get-weather", { city: "New York" });
-        expect(response).toEqual({
-            data: { temperature: 22, condition: "Sunny" },
-            text: "The weather in New York is Sunny with a temperature of 22°C.",
-            ui: null,
-        });
-    });
-    test("Rejects call with invalid signature", async () => {
-        const app = server.address();
-        const port = app.port;
-        const method = "POST";
-        const path = "/tools/get-weather";
-        const body = JSON.stringify({ city: "New York" });
-        const headers = {
-            "Content-Type": "application/json",
-            "X-DAIN-Address": address,
-        };
-        const timestamp = new Date().toISOString();
-        headers["X-DAIN-Timestamp"] = timestamp;
-        const response = await (0, supertest_1.default)(`http://localhost:${port}`)
-            .post("/tools/get-weather")
-            .set("X-DAIN-Signature", "1231232113121")
-            .set("X-DAIN-Address", address)
-            .set("X-DAIN-Timestamp", timestamp)
-            .send({ city: "New York" });
-        expect(response.status).toBe(401);
-    });
-    describe("HTTP Output to Vercel AI Tool", () => {
-        it("should convert a DAIN tool to HTTP output and then to Vercel AI tool format", () => {
-            // Simulate a DAIN tool
-            const dainTool = {
-                id: "get-weather",
-                name: "Get Weather",
-                description: "Fetches weather for a city",
-                pricing: { pricePerUse: 0.01, currency: "USD" },
-                input: zod_1.z.object({
-                    city: zod_1.z.string().describe("The name of the city"),
-                    country: zod_1.z.string().optional().describe("The country of the city"),
-                }),
-                output: zod_1.z.object({
-                    temperature: zod_1.z.number(),
-                    condition: zod_1.z.string(),
-                }),
-                handler: async () => ({ temperature: 22, condition: "Sunny" }),
-            };
-            // Simulate the HTTP output
-            const httpOutput = {
-                id: dainTool.id,
-                name: dainTool.name,
-                description: dainTool.description,
-                pricing: dainTool.pricing,
-                inputSchema: (0, schemaStructure_1.getDetailedSchemaStructure)(dainTool.input),
-                outputSchema: (0, schemaStructure_1.getDetailedSchemaStructure)(dainTool.output),
-            };
-            // Convert HTTP output to Vercel AI tool
-            const vercelAITool = (0, convertToVercelTool_1.convertHttpToolToVercelAITool)(httpOutput);
-            // Assertions
-            expect(vercelAITool.name).toBe("get-weather");
-            expect(vercelAITool.description).toBe("Fetches weather for a city");
-            expect(vercelAITool.parameters).toBeInstanceOf(zod_1.z.ZodObject);
-            const params = vercelAITool.parameters.safeParse({
-                city: "New York",
-                country: "USA",
-            });
-            expect(params.success).toBe(true);
-            // Use Zod's built-in methods to inspect the schema
-            const schemaShape = vercelAITool.parameters._def.shape();
-            expect(schemaShape.city.description).toBe("The name of the city");
-            expect(schemaShape.country.description).toBe("The country of the city");
-            // Test that the optional field is correctly preserved
-            const paramsWithoutCountry = vercelAITool.parameters.safeParse({
-                city: "Tokyo",
-            });
-            expect(paramsWithoutCountry.success).toBe(true);
-            // Additional check for the optional nature of the country field
-            expect(schemaShape.country instanceof zod_1.z.ZodOptional).toBe(true);
-        });
-    });
-    it("Can List Contexts", async () => {
-        const app = server.address();
-        const port = app.port;
-        const response = await dainConnection.listContexts();
-        expect(response).toEqual([
-            {
-                id: "weather-context",
-                name: "Weather Context",
-                description: "Context for weather data",
-            },
-        ]);
-    });
-    it("Can call weather context with valid signature", async () => {
-        const app = server.address();
-        const port = app.port;
-        const response = await dainConnection.getContext("weather-context");
-        expect(response).toEqual({
-            id: "weather-context",
-            name: "Weather Context",
-            description: "Context for weather data",
-            data: "Weather data",
-        });
-    });
-    it("Can get all tools as json schema", async () => {
-        const app = server.address();
-        const port = app.port;
-        const response = await dainConnection.makeRequest("GET", "/getAllToolsAsJsonSchema", {});
-        console.log("JSON SCHEMA", JSON.stringify(response, null, 2));
-        // fs.writeFileSync("jsonSchema.json", JSON.stringify(response, null, 2));
-        // Verify the response structure
-        expect(response).toHaveProperty('tools');
-        expect(response).toHaveProperty('reccomendedPrompts');
-        expect(Array.isArray(response.tools)).toBe(true);
-        expect(Array.isArray(response.reccomendedPrompts)).toBe(true);
-        // Verify we have the expected number of tools (7 total)
-        expect(response.tools).toHaveLength(7);
-        // Verify each tool has the required properties
-        response.tools.forEach((tool) => {
-            expect(tool).toHaveProperty('id');
-            expect(tool).toHaveProperty('name');
-            expect(tool).toHaveProperty('description');
-            expect(tool).toHaveProperty('inputSchema');
-            expect(tool).toHaveProperty('outputSchema');
-            // interface property is optional
-        });
-        // Verify specific tools exist
-        const toolIds = response.tools.map((tool) => tool.id);
-        expect(toolIds).toContain('get-weather');
-        expect(toolIds).toContain('extra-data-tool');
-        expect(toolIds).toContain('confirmation-test-tool');
-        expect(toolIds).toContain('optional-params-tool');
-        expect(toolIds).toContain('no-params-tool');
-        expect(toolIds).toContain('integration-error-tool');
-        expect(toolIds).toContain('test-knowledge-search');
-        // Verify the knowledge search tool has interface information
-        const knowledgeTool = response.tools.find((tool) => tool.id === 'test-knowledge-search');
-        expect(knowledgeTool).toBeDefined();
-        expect(knowledgeTool.interface).toBe(interfaces_1.ToolInterfaceType.KNOWLEDGE_SEARCH);
-        // Verify confirmation tool has suggestConfirmation
-        const confirmationTool = response.tools.find((tool) => tool.id === 'confirmation-test-tool');
-        expect(confirmationTool).toBeDefined();
-        expect(confirmationTool.suggestConfirmation).toBe(true);
-        // Verify recommended prompts
-        expect(response.reccomendedPrompts).toContain("Use these tools for weather-related tasks");
-    });
-    describe("Widgets", () => {
-        it("Can get widget IDs", async () => {
-            const response = await dainConnection.getWidgets();
-            expect(response).toHaveLength(1);
-            expect(response[0]).toBe("weather-widget");
-        });
-        it("Can get a specific widget", async () => {
-            const response = await dainConnection.getWidget("weather-widget");
-            expect(response).toEqual({
-                id: "weather-widget",
-                name: "Weather Info",
-                description: "Displays current weather information",
-                icon: "☀️",
-                size: "lg",
-                text: "Current weather: Sunny, 22°C",
-                data: { temperature: 22, condition: "Sunny" },
-                ui: { type: "text" },
-            });
-        });
-        it("Can call extra data tool", async () => {
-            const response = await dainConnection.callTool("extra-data-tool", {
-                cool: "cool",
-                DAIN_EXTRA_DATA: {
-                    testExtraData: "testExtraData",
-                },
-            });
-            expect(response).toEqual({
-                text: `Extra data: ${JSON.stringify({ testExtraData: "testExtraData", plugins: {} })}`,
-                data: { extraData: { testExtraData: "testExtraData", plugins: {} } },
-                ui: null,
-            });
-        });
-        it("Can get all widgets with their data", async () => {
-            const response = await dainConnection.getAllWidgets();
-            expect(response).toHaveLength(1);
-            expect(response[0]).toEqual({
-                id: "weather-widget",
-                name: "Weather Info",
-                description: "Displays current weather information",
-                icon: "☀️",
-                size: "lg",
-                text: "Current weather: Sunny, 22°C",
-                data: { temperature: 22, condition: "Sunny" },
-                ui: { type: "text" },
-            });
-        });
-        it("Defaults to 'sm' size when not specified", async () => {
-            // Create a widget without specifying size
-            const smallWidget = (0, core_1.createWidget)({
-                id: "small-widget",
-                name: "Small Widget",
-                description: "A widget with default size",
-                icon: "📊",
-                // No size specified - should default to "sm"
-                getWidget: async () => ({
-                    text: "Small widget content",
-                    data: { type: "default" },
-                    ui: { type: "text" },
-                }),
-            });
-            // Test that it defaults to "sm"
-            expect(smallWidget.size).toBe("sm");
-        });
-        it("Supports medium 'md' size", async () => {
-            // Create a widget with medium size
-            const mediumWidget = (0, core_1.createWidget)({
-                id: "medium-widget",
-                name: "Medium Widget",
-                description: "A widget with medium size",
-                icon: "📈",
-                size: "md", // Medium size
-                getWidget: async () => ({
-                    text: "Medium widget content",
-                    data: { type: "medium" },
-                    ui: { type: "chart" },
-                }),
-            });
-            // Test that medium size is preserved
-            expect(mediumWidget.size).toBe("md");
-        });
-        it("Rejects request for non-existent widget", async () => {
-            await expect(dainConnection.getWidget("non-existent-widget")).rejects.toThrow();
-        });
-    });
-    // Add new test suite for confirmation functionality
-    describe("Tool Confirmation", () => {
-        it("Tool metadata includes confirmation settings", async () => {
-            const tool = await dainConnection.getTool("confirmation-test-tool");
-            expect(tool.suggestConfirmation).toBe(true);
-        });
-        it("Can get confirmation UI for a tool", async () => {
-            const confirmation = await dainConnection.getToolConfirmation("confirmation-test-tool", {
-                action: "test-action"
-            });
-            expect(confirmation).toEqual({
-                success: true,
-                ui: {
-                    type: "confirmation",
-                    title: "Confirm Action",
-                    message: "Are you sure you want to perform: test-action?",
-                    fields: [
-                        {
-                            type: "text",
-                            label: "Additional Notes",
-                            placeholder: "Add any notes here..."
-                        }
-                    ]
-                }
-            });
-        });
-        it("Returns success: false for dangerous actions", async () => {
-            const confirmation = await dainConnection.getToolConfirmation("confirmation-test-tool", {
-                action: "dangerous"
-            });
-            expect(confirmation.success).toBe(false);
-        });
-        it("Returns default success response for tools without confirmation UI", async () => {
-            const confirmation = await dainConnection.getToolConfirmation("get-weather", {
-                city: "London"
-            });
-            expect(confirmation).toEqual({
-                success: true
-            });
-        });
-        it("Rejects confirmation request for non-existent tool", async () => {
-            await expect(dainConnection.getToolConfirmation("non-existent-tool", {})).rejects.toThrow();
-        });
-    });
-    it("Can stream UI updates from weather tool", async () => {
-        const uiUpdates = [];
-        const result = await dainConnection.callTool("get-weather", { city: "London" }, {
-            onUIUpdate: (update) => {
-                uiUpdates.push(update.ui);
-            }
-        });
-        // Verify UI updates were received
-        expect(uiUpdates).toHaveLength(2);
-        expect(uiUpdates[0]).toEqual({ type: "loading", message: "Fetching weather..." });
-        expect(uiUpdates[1]).toEqual({ type: "progress", message: "Processing data..." });
-        // Verify final result
-        expect(result).toEqual({
-            text: "The weather in London is Sunny with a temperature of 22°C.",
-            data: { temperature: 22, condition: "Sunny" },
-            ui: null,
-        });
-    });
-    it("Maintains backwards compatibility with non-streaming clients", async () => {
-        // Create a legacy client by removing the onUIUpdate option
-        const result = await dainConnection.callTool("get-weather", {
-            city: "London"
-        });
-        // Verify we get the final result without any streaming
-        expect(result).toEqual({
-            text: "The weather in London is Sunny with a temperature of 22°C.",
-            data: { temperature: 22, condition: "Sunny" },
-            ui: null,
-        });
-    });
-    it("Maintains backwards compatibility for callToolAndGetNewContext", async () => {
-        const result = await dainConnection.callToolAndGetNewContext("get-weather", {
-            city: "London"
-        });
-        expect(result.toolResult).toEqual({
-            text: "The weather in London is Sunny with a temperature of 22°C.",
-            data: { temperature: 22, condition: "Sunny" },
-            ui: null,
-        });
-        // Verify we still get context data
-        expect(result.context).toBeDefined();
-        expect(Array.isArray(result.context)).toBe(true);
-        expect(result.context[0]).toHaveProperty('id', 'weather-context');
-    });
-    it("Can stream UI updates from weather tool with callToolAndGetNewContext", async () => {
-        const uiUpdates = [];
-        const result = await dainConnection.callToolAndGetNewContext("get-weather", { city: "Paris" }, {
-            onUIUpdate: (update) => {
-                uiUpdates.push(update.ui);
-            }
-        });
-        // Verify UI updates were received
-        expect(uiUpdates).toHaveLength(2);
-        expect(uiUpdates[0]).toEqual({ type: "loading", message: "Fetching weather..." });
-        expect(uiUpdates[1]).toEqual({ type: "progress", message: "Processing data..." });
-        // Verify final result includes both tool result and context
-        expect(result.toolResult).toEqual({
-            text: "The weather in Paris is Sunny with a temperature of 22°C.",
-            data: { temperature: 22, condition: "Sunny" },
-            ui: null,
-        });
-        // Verify context data
-        expect(result.context).toBeDefined();
-        expect(Array.isArray(result.context)).toBe(true);
-        expect(result.context[0]).toHaveProperty('id', 'weather-context');
-    });
-    it("Can stream process updates from weather tool", async () => {
-        const uiUpdates = [];
-        const processes = [];
-        const result = await dainConnection.callTool("get-weather", { city: "London" }, {
-            onUIUpdate: (update) => {
-                uiUpdates.push(update.ui);
-            },
-            onProcess: (processId) => {
-                processes.push(processId);
-            }
-        });
-        // Verify process updates were received
-        expect(processes).toHaveLength(1);
-        expect(processes[0]).toMatch(/^service_.*_.*$/); // Check process ID format
-        // Verify UI updates still work
-        expect(uiUpdates).toHaveLength(2);
-        // ... rest of the assertions ...
-    });
-    // Keep this test but modify it to be more explicit about timing
-    it("Sends SSE events immediately rather than buffering", async () => {
-        const events = [];
-        let lastTimestamp = Date.now();
-        const result = await dainConnection.callTool("get-weather", { city: "London" }, {
-            onUIUpdate: () => {
-                const now = Date.now();
-                const delay = now - lastTimestamp;
-                events.push({ type: 'ui', timestamp: now, delay });
-                lastTimestamp = now;
-                console.log('UI Update received at:', now, 'delay:', delay); // Add logging
-            },
-            onProcess: () => {
-                const now = Date.now();
-                const delay = now - lastTimestamp;
-                events.push({ type: 'process', timestamp: now, delay });
-                lastTimestamp = now;
-                console.log('Process Update received at:', now, 'delay:', delay); // Add logging
-            }
-        });
-        const now = Date.now();
-        events.push({ type: 'result', timestamp: now, delay: now - lastTimestamp });
-        console.log('Final result received at:', now); // Add logging
-        // Verify we got all expected events
-        expect(events).toHaveLength(4);
-        // Log the events to see what's happening
-        console.log('Events with delays:', events);
-        // Check each event came after the previous one with reasonable delay
-        events.slice(1).forEach(event => {
-            expect(event.delay).toBeGreaterThan(30); // Each event should be at least 30ms after the previous
-        });
-    });
-    // Add tests for datasources
-    describe("Datasources", () => {
-        it("Can list datasources", async () => {
-            const response = await dainConnection.listDatasources();
-            expect(response).toHaveLength(1);
-            expect(response[0]).toEqual({
-                id: "weather-datasource",
-                name: "Weather Datasource",
-                description: "Datasource for weather data",
-                type: "json",
-                inputSchema: expect.any(Object),
-            });
-        });
-        it("Can get data from a datasource", async () => {
-            const response = await dainConnection.getDatasource("weather-datasource", {
-                city: "London",
-                days: 2
-            });
-            expect(response).toEqual({
-                id: "weather-datasource",
-                name: "Weather Datasource",
-                description: "Datasource for weather data",
-                type: "json",
-                data: {
-                    city: "London",
-                    forecast: [
-                        { day: 1, temperature: 22, condition: "Sunny" },
-                        { day: 2, temperature: 24, condition: "Partly Cloudy" }
-                    ]
-                }
-            });
-        });
-        it("Handles missing parameters correctly", async () => {
-            await expect(dainConnection.getDatasource("weather-datasource", {})).rejects.toThrow();
-        });
-        it("Rejects request for non-existent datasource", async () => {
-            await expect(dainConnection.getDatasource("non-existent-datasource", { city: "London" })).rejects.toThrow();
-        });
-    });
-    // Add tests for empty parameter tool calls
-    describe("Empty Parameter Tool Calls", () => {
-        it("Can call a tool with empty parameters object", async () => {
-            const response = await dainConnection.callTool("optional-params-tool", {});
-            expect(response.data.providedParams).toEqual([]);
-            expect(response.data.message).toBe("No parameters provided");
-            expect(response.text).toBe("Called with 0 parameter(s): ");
-        });
-        it("Can call a tool with some optional parameters", async () => {
-            const response = await dainConnection.callTool("optional-params-tool", {
-                param1: "test",
-                param3: true
-            });
-            expect(response.data.providedParams).toContain("param1");
-            expect(response.data.providedParams).toContain("param3");
-            expect(response.data.providedParams).not.toContain("param2");
-            expect(response.data.providedParams.length).toBe(2);
-        });
-        it("Can call a tool that requires no parameters", async () => {
-            const response = await dainConnection.callTool("no-params-tool", {});
-            expect(response.data.message).toBe("Success - no parameters needed");
-            expect(response.text).toBe("No parameters tool executed successfully");
-        });
-        it("Handles undefined parameters gracefully", async () => {
-            // Call with undefined instead of an empty object
-            const response = await dainConnection.callTool("optional-params-tool", undefined);
-            expect(response.data.providedParams).toEqual([]);
-            expect(response.data.message).toBe("No parameters provided");
-        });
-        it("Works with streaming for empty parameter calls", async () => {
-            const events = [];
-            const result = await dainConnection.callTool("no-params-tool", {}, {
-                onUIUpdate: (update) => {
-                    events.push({ type: 'ui', data: update });
-                }
-            });
-            expect(result.data.message).toBe("Success - no parameters needed");
-        });
-    });
-    // Add a new test suite for error handling
-    describe("Error Handling", () => {
-        it("Handles synchronous errors in non-streaming mode", async () => {
-            const errorResult = await dainConnection.callTool("integration-error-tool", {
-                errorType: "synchronous",
-                errorMessage: "Test sync error"
-            });
-            // Verify the error format matches our expected structure
-            expect(errorResult).toHaveProperty('error');
-            expect(errorResult).toHaveProperty('text');
-            expect(errorResult.error).toBe("Test sync error");
-            expect(errorResult.text).toBe("Error: Test sync error");
-            expect(errorResult.data).toBeNull();
-            expect(errorResult.ui).toBeNull();
-        });
-        it("Handles asynchronous errors in non-streaming mode", async () => {
-            const errorResult = await dainConnection.callTool("integration-error-tool", {
-                errorType: "async",
-                errorMessage: "Test async error"
-            });
-            expect(errorResult).toHaveProperty('error');
-            expect(errorResult.error).toBe("Test async error");
-            expect(errorResult.data).toBeNull();
-        });
-        it("Formats errors correctly in context endpoint", async () => {
-            const errorResult = await dainConnection.callToolAndGetNewContext("integration-error-tool", {
-                errorType: "synchronous",
-                errorMessage: "Test context error"
-            });
-            // Verify the context endpoint error format
-            expect(errorResult).toHaveProperty('toolResult');
-            expect(errorResult).toHaveProperty('context');
-            expect(errorResult.toolResult).toHaveProperty('error');
-            expect(errorResult.toolResult.error).toBe("Test context error");
-            expect(errorResult.toolResult.text).toBe("Error: Test context error");
-            expect(errorResult.toolResult.data).toBeNull();
-            expect(errorResult.toolResult.ui).toBeNull();
-            expect(Array.isArray(errorResult.context)).toBe(true);
-            expect(errorResult.context.length).toBe(0);
-        });
-        it("Handles errors in streaming mode and sends error events", async () => {
-            const events = [];
-            const errorResult = await dainConnection.callTool("integration-error-tool", {
-                errorType: "async",
-                errorMessage: "Test streaming error"
-            }, {
-                onUIUpdate: (update) => {
-                    events.push({ type: 'ui', data: update.ui });
-                }
-            });
-            // Verify we received UI updates before the error
-            expect(events.length).toBeGreaterThan(0);
-            expect(events[0].type).toBe('ui');
-            // Verify the error format in streaming mode
-            expect(errorResult).toHaveProperty('error');
-            expect(errorResult.error).toBe("Test streaming error");
-            expect(errorResult.text).toBe("Error: Test streaming error");
-            expect(errorResult.data).toBeNull();
-            expect(errorResult.ui).toBeNull();
-        });
-        it("Handles streaming errors in context endpoint", async () => {
-            const events = [];
-            const errorResult = await dainConnection.callToolAndGetNewContext("integration-error-tool", {
-                errorType: "async",
-                errorMessage: "Test streaming context error"
-            }, {
-                onUIUpdate: (update) => {
-                    events.push({ type: 'ui', data: update.ui });
-                }
-            });
-            // Verify we received UI updates before the error
-            expect(events.length).toBeGreaterThan(0);
-            // Verify the context endpoint error format in streaming mode
-            expect(errorResult).toHaveProperty('toolResult');
-            expect(errorResult).toHaveProperty('context');
-            expect(errorResult.toolResult).toHaveProperty('error');
-            expect(errorResult.toolResult.error).toBe("Test streaming context error");
-            expect(errorResult.toolResult.data).toBeNull();
-            expect(Array.isArray(errorResult.context)).toBe(true);
-        });
-        it("Verifies successful execution still works after error handling improvements", async () => {
-            const result = await dainConnection.callTool("integration-error-tool", {
-                errorType: "none"
-            });
-            expect(result).toEqual({
-                text: "No error occurred",
-                data: { result: "success" },
-                ui: null
-            });
-        });
-    });
-    // Add tests for empty collections
-    describe("Empty Collections", () => {
-        // Create an empty DAIN service with no contexts or pinnables
-        let emptyServer;
-        let emptyConnection;
-        beforeAll(async () => {
-            const emptyPrivateKey = ed25519_1.ed25519.utils.randomPrivateKey();
-            const emptyPublicKey = ed25519_1.ed25519.getPublicKey(emptyPrivateKey);
-            const emptyAddress = bs58_1.default.encode(emptyPublicKey);
-            const emptyClientPrivateKey = ed25519_1.ed25519.utils.randomPrivateKey();
-            const emptyClientAuth = new client_auth_1.DainClientAuth({
-                privateKeyBase58: bs58_1.default.encode(emptyClientPrivateKey),
-                agentId: "empty-agent",
-                orgId: "empty-org",
-            });
-            // Create a minimal dummy tool to satisfy validation
-            const dummyTool = (0, nodeService_1.createTool)({
-                id: "dummy-tool",
-                name: "Dummy Tool",
-                description: "Required dummy tool for validation",
-                input: zod_1.z.object({}),
-                output: zod_1.z.object({}),
-                handler: async () => {
-                    return {
-                        text: "Dummy response",
-                        data: {},
-                        ui: null
-                    };
-                }
-            });
-            // Create a minimal dummy toolbox with the dummy tool
-            const dummyToolbox = (0, nodeService_1.createToolbox)({
-                id: "dummy-toolbox",
-                name: "Dummy Toolbox",
-                description: "Required dummy toolbox for validation",
-                tools: ["dummy-tool"],
-                metadata: {
-                    complexity: "Low",
-                    applicableFields: ["Testing"]
-                },
-                recommendedPrompt: "Dummy prompt"
-            });
-            // Define an empty service with no contexts or pinnables but with required tool/toolbox
-            const emptyDainService = (0, nodeService_1.defineDAINService)({
-                metadata: {
-                    title: "Empty DAIN Service",
-                    description: "A DAIN service with no contexts or pinnables",
-                    version: "1.0.0",
-                    author: "Test Author",
-                    tags: ["empty", "test"],
-                },
-                identity: {
-                    publicKey: bs58_1.default.encode(emptyPublicKey),
-                    agentId: "empty-agent",
-                    orgId: "empty-org",
-                    privateKey: bs58_1.default.encode(emptyPrivateKey),
-                },
-                services: [],
-                tools: [dummyTool], // Include the dummy tool
-                toolboxes: [dummyToolbox], // Include the dummy toolbox
-                contexts: [], // No contexts - this is what we're testing
-                widgets: [], // No widgets - this is what we're testing 
-                datasources: [], // No datasources - this is what we're testing
-                agents: [], // No agents - this is what we're testing
-            });
-            emptyServer = await emptyDainService.startNode({ port: 3004 });
-            // Connect to the empty service
-            emptyConnection = new client_1.DainServiceConnection("http://localhost:3004", emptyClientAuth);
-        });
-        afterAll(async () => {
-            if (emptyServer) {
-                await emptyServer.shutdown();
-            }
-        });
-        it("getAllContexts() returns an empty array when no contexts exist", async () => {
-            const contexts = await emptyConnection.getAllContexts();
-            console.log("getAllContexts", contexts);
-            expect(contexts).toEqual([]);
-            expect(Array.isArray(contexts)).toBe(true);
-            expect(contexts.length).toBe(0);
-        });
-        it("getWidgets() returns an empty array when no widgets exist", async () => {
-            const widgets = await emptyConnection.getWidgets();
-            expect(widgets).toEqual([]);
-            expect(Array.isArray(widgets)).toBe(true);
-            expect(widgets.length).toBe(0);
-        });
-        it("getAllDatasources() returns an empty array when no datasources exist", async () => {
-            const datasources = await emptyConnection.listDatasources();
-            expect(datasources).toEqual([]);
-            expect(Array.isArray(datasources)).toBe(true);
-            expect(datasources.length).toBe(0);
-        });
-        it("getAgents() returns an empty array when no agents exist", async () => {
-            const agents = await emptyConnection.getAgents();
-            expect(agents).toEqual([]);
-            expect(Array.isArray(agents)).toBe(true);
-            expect(agents.length).toBe(0);
-        });
-        it("listAgents() returns an empty array when no agents exist", async () => {
-            const agents = await emptyConnection.listAgents();
-            expect(agents).toEqual([]);
-            expect(Array.isArray(agents)).toBe(true);
-            expect(agents.length).toBe(0);
-        });
-        it("getAllToolsAsJsonSchema() returns array with only the dummy tool", async () => {
-            const result = await emptyConnection.getAllToolsAsJsonSchema();
-            expect(Array.isArray(result.tools)).toBe(true);
-            expect(result.tools.length).toBe(1);
-            expect(result.tools[0].id).toBe("dummy-tool");
-            expect(result.reccomendedPrompts).toEqual(["Dummy prompt"]);
-        });
-        it("should get tools as JSON schema using the POST method", async () => {
-            // We have one dummy tool defined in the test setup
-            const result = await dainConnection.getAllToolsAsJsonSchema();
-            // Verify we get the tools in the result
-            expect(result.tools.length).toBeGreaterThan(0);
-            expect(result.tools[0]).toHaveProperty('id');
-            expect(result.tools[0]).toHaveProperty('inputSchema');
-            expect(result.tools[0]).toHaveProperty('outputSchema');
-            expect(result.reccomendedPrompts).toBeDefined();
-        });
-    });
-    // Add comprehensive tests for Tool Interfaces
-    describe("Tool Interfaces", () => {
-        it("should include interface information in tool metadata", async () => {
-            const tools = await dainConnection.getTools();
-            // Find the knowledge search tool
-            const knowledgeTool = tools.find(t => t.id === "test-knowledge-search");
-            expect(knowledgeTool).toBeDefined();
-            expect(knowledgeTool?.interface).toBe(interfaces_1.ToolInterfaceType.KNOWLEDGE_SEARCH);
-            // Verify other tools don't have interfaces (unless they should)
-            const weatherTool = tools.find(t => t.id === "get-weather");
-            expect(weatherTool?.interface).toBeUndefined();
-        });
-        it("should include interface information in JSON schema response", async () => {
-            const result = await dainConnection.getAllToolsAsJsonSchema();
-            // Find the knowledge search tool in the JSON schema response
-            const knowledgeTool = result.tools.find(t => t.id === "test-knowledge-search");
-            expect(knowledgeTool).toBeDefined();
-            expect(knowledgeTool?.interface).toBe(interfaces_1.ToolInterfaceType.KNOWLEDGE_SEARCH);
-        });
-        it("should filter tools by interface type", async () => {
-            const knowledgeTools = await dainConnection.getToolsByInterface(interfaces_1.ToolInterfaceType.KNOWLEDGE_SEARCH);
-            expect(knowledgeTools).toHaveLength(1);
-            expect(knowledgeTools[0].id).toBe("test-knowledge-search");
-            expect(knowledgeTools[0].interface).toBe(interfaces_1.ToolInterfaceType.KNOWLEDGE_SEARCH);
-        });
-        it("should return empty array for non-existent interface", async () => {
-            // Cast to test with a non-existent interface
-            const nonExistentInterface = "non-existent-interface";
-            const tools = await dainConnection.getToolsByInterface(nonExistentInterface);
-            expect(tools).toHaveLength(0);
-        });
-        it("should get available interfaces from tools", async () => {
-            const interfaces = await dainConnection.getAvailableInterfaces();
-            expect(interfaces).toContain(interfaces_1.ToolInterfaceType.KNOWLEDGE_SEARCH);
-            expect(interfaces).toHaveLength(1); // Only one interface in our test setup
-        });
-        it("should call knowledge search tool with interface-compliant input/output", async () => {
-            const result = await dainConnection.callTool("test-knowledge-search", {
-                query: "What is DAIN?",
-                limit: 2
-            });
-            // Verify the response structure matches the KnowledgeSearch interface
-            expect(result.data).toHaveProperty('results');
-            expect(result.data).toHaveProperty('totalCount');
-            expect(result.data).toHaveProperty('searchId');
-            // Verify results structure
-            expect(Array.isArray(result.data.results)).toBe(true);
-            expect(result.data.results.length).toBeGreaterThan(0);
-            // Verify each result has the correct structure
-            const firstResult = result.data.results[0];
-            expect(firstResult).toHaveProperty('content');
-            expect(firstResult).toHaveProperty('id');
-            expect(firstResult).toHaveProperty('citation');
-            // Verify citation structure (including the new id field)
-            expect(firstResult.citation).toHaveProperty('id');
-            expect(firstResult.citation).toHaveProperty('ui');
-            expect(firstResult.citation).toHaveProperty('url');
-            expect(firstResult.citation).toHaveProperty('title');
-            expect(firstResult.citation).toHaveProperty('author');
-            expect(firstResult.citation).toHaveProperty('date');
-            expect(firstResult.citation).toHaveProperty('type');
-            expect(firstResult.citation).toHaveProperty('source');
-            // Verify citation id is present and is a string
-            expect(typeof firstResult.citation.id).toBe('string');
-            expect(firstResult.citation.id.length).toBeGreaterThan(0);
-        });
-        it("should handle array queries in knowledge search", async () => {
-            const result = await dainConnection.callTool("test-knowledge-search", {
-                query: ["What is DAIN?", "How does it work?"],
-                limit: 2
-            });
-            // Should get results for both queries
-            expect(result.data.results.length).toBeGreaterThan(0);
-            // Verify that results contain content from both queries
-            const resultContents = result.data.results.map(r => r.content);
-            const hasFirstQuery = resultContents.some(content => content.includes("What is DAIN?"));
-            const hasSecondQuery = resultContents.some(content => content.includes("How does it work?"));
-            expect(hasFirstQuery || hasSecondQuery).toBe(true); // At least one query should be represented
-        });
-        it("should handle optional parameters in knowledge search", async () => {
-            // Test with minimal parameters
-            const result1 = await dainConnection.callTool("test-knowledge-search", {
-                query: "test query"
-            });
-            expect(result1.data.results).toBeDefined();
-            expect(result1.data.totalCount).toBeDefined();
-            // Test with all parameters
-            const result2 = await dainConnection.callTool("test-knowledge-search", {
-                query: "test query",
-                limit: 1,
-                filters: { category: "test" }
-            });
-            expect(result2.data.results).toBeDefined();
-            expect(result2.data.results.length).toBeLessThanOrEqual(1);
-        });
-        it("should work with streaming for interface-implementing tools", async () => {
-            const uiUpdates = [];
-            const result = await dainConnection.callTool("test-knowledge-search", { query: "streaming test", limit: 1 }, {
-                onUIUpdate: (update) => {
-                    uiUpdates.push(update.ui);
-                }
-            });
-            // Verify the interface-compliant response structure is maintained in streaming
-            expect(result.data).toHaveProperty('results');
-            expect(result.data).toHaveProperty('totalCount');
-            expect(result.data).toHaveProperty('searchId');
-            // Verify citation structure is maintained
-            const firstResult = result.data.results[0];
-            expect(firstResult.citation).toHaveProperty('id');
-            expect(typeof firstResult.citation.id).toBe('string');
-        });
-        it("should maintain interface compliance in callToolAndGetNewContext", async () => {
-            const result = await dainConnection.callToolAndGetNewContext("test-knowledge-search", {
-                query: "context test"
-            });
-            // Verify tool result maintains interface compliance
-            expect(result.toolResult.data).toHaveProperty('results');
-            expect(result.toolResult.data).toHaveProperty('totalCount');
-            expect(result.toolResult.data).toHaveProperty('searchId');
-            // Verify context is also returned
-            expect(result.context).toBeDefined();
-            expect(Array.isArray(result.context)).toBe(true);
-        });
-        it("should validate that interface tools have correct input/output schemas", async () => {
-            const tool = await dainConnection.getTool("test-knowledge-search");
-            // Verify the tool has the interface field
-            expect(tool.interface).toBe(interfaces_1.ToolInterfaceType.KNOWLEDGE_SEARCH);
-            // Verify input schema structure (should match KnowledgeSearch interface)
-            expect(tool.inputSchema).toBeDefined();
-            expect(tool.outputSchema).toBeDefined();
-            // The schemas should be objects with the expected structure
-            expect(typeof tool.inputSchema).toBe('object');
-            expect(typeof tool.outputSchema).toBe('object');
-        });
-    });
-    // Add tests for Agents
-    describe("Agents", () => {
-        it("Can list agents", async () => {
-            const response = await dainConnection.getAgents();
-            expect(response).toHaveLength(1);
-            expect(response[0]).toEqual({
-                id: "help-assistant",
-                name: "Help Assistant Agent",
-                context: ["You are a helpful AI assistant", "Always provide accurate and concise answers"],
-                prompt: "Answer user questions helpfully and accurately. Provide context when necessary.",
-                resolveCondition: "User question has been answered completely and accurately",
-                serviceConnections: ["http://localhost:3003", "https://api.example.com"],
-                inputSchema: expect.any(Object),
-                outputSchema: expect.any(Object),
-            });
-        });
-        it("Can list agents using POST method with plugin support", async () => {
-            const response = await dainConnection.listAgents();
-            expect(response).toHaveLength(1);
-            expect(response[0]).toEqual({
-                id: "help-assistant",
-                name: "Help Assistant Agent",
-                context: ["You are a helpful AI assistant", "Always provide accurate and concise answers"],
-                prompt: "Answer user questions helpfully and accurately. Provide context when necessary.",
-                resolveCondition: "User question has been answered completely and accurately",
-                serviceConnections: ["http://localhost:3003", "https://api.example.com"],
-                inputSchema: expect.any(Object),
-                outputSchema: expect.any(Object),
-            });
-        });
-        it("Can get a specific agent", async () => {
-            const response = await dainConnection.getAgent("help-assistant");
-            expect(response).toEqual({
-                id: "help-assistant",
-                name: "Help Assistant Agent",
-                context: ["You are a helpful AI assistant", "Always provide accurate and concise answers"],
-                prompt: "Answer user questions helpfully and accurately. Provide context when necessary.",
-                resolveCondition: "User question has been answered completely and accurately",
-                serviceConnections: ["http://localhost:3003", "https://api.example.com"],
-                inputSchema: expect.any(Object),
-                outputSchema: expect.any(Object),
-            });
-        });
-        it("Can get a specific agent using POST method with plugin support", async () => {
-            const response = await dainConnection.postAgent("help-assistant");
-            expect(response).toEqual({
-                id: "help-assistant",
-                name: "Help Assistant Agent",
-                context: ["You are a helpful AI assistant", "Always provide accurate and concise answers"],
-                prompt: "Answer user questions helpfully and accurately. Provide context when necessary.",
-                resolveCondition: "User question has been answered completely and accurately",
-                serviceConnections: ["http://localhost:3003", "https://api.example.com"],
-                inputSchema: expect.any(Object),
-                outputSchema: expect.any(Object),
-            });
-        });
-        it("Agent schemas are properly converted to JSON Schema format", async () => {
-            const agent = await dainConnection.getAgent("help-assistant");
-            // Verify input schema structure
-            expect(agent.inputSchema).toHaveProperty('type', 'object');
-            expect(agent.inputSchema).toHaveProperty('properties');
-            expect(agent.inputSchema.properties).toHaveProperty('question');
-            expect(agent.inputSchema.properties).toHaveProperty('context');
-            expect(agent.inputSchema.properties).toHaveProperty('urgency');
-            // Verify required fields
-            expect(agent.inputSchema).toHaveProperty('required');
-            expect(agent.inputSchema.required).toContain('question');
-            expect(agent.inputSchema.required).not.toContain('context'); // Optional field
-            // Verify output schema structure
-            expect(agent.outputSchema).toHaveProperty('type', 'object');
-            expect(agent.outputSchema).toHaveProperty('properties');
-            expect(agent.outputSchema.properties).toHaveProperty('answer');
-            expect(agent.outputSchema.properties).toHaveProperty('confidence');
-            expect(agent.outputSchema.properties).toHaveProperty('sources');
-            expect(agent.outputSchema.properties).toHaveProperty('followUpQuestions');
-            // Verify descriptions are included
-            expect(agent.inputSchema.properties.question).toHaveProperty('description', "The user's question");
-            expect(agent.outputSchema.properties.answer).toHaveProperty('description', "The detailed answer to the user's question");
-            // Verify enum handling
-            expect(agent.inputSchema.properties.urgency).toHaveProperty('enum', ["low", "medium", "high"]);
-            // Verify number constraints
-            expect(agent.outputSchema.properties.confidence).toHaveProperty('minimum', 0);
-            expect(agent.outputSchema.properties.confidence).toHaveProperty('maximum', 1);
-        });
-        it("Returns 404 for non-existent agent", async () => {
-            await expect(dainConnection.getAgent("non-existent-agent")).rejects.toThrow();
-        });
-        it("Returns 404 for non-existent agent using POST method", async () => {
-            await expect(dainConnection.postAgent("non-existent-agent")).rejects.toThrow();
-        });
-        it("Agent has default service connection when not specified", async () => {
-            // Create an agent without serviceConnections to test default behavior
-            const defaultAgent = (0, core_1.createAgent)({
-                id: "default-connection-agent",
-                name: "Default Connection Agent",
-                context: ["Test context"],
-                prompt: "Test prompt",
-                resolveCondition: "Test condition",
-                input: zod_1.z.object({ test: zod_1.z.string() }),
-                output: zod_1.z.object({ result: zod_1.z.string() }),
-                // No serviceConnections specified - should default
-            });
-            // Verify default service connection is set
-            expect(defaultAgent.serviceConnections).toEqual([process.env.BASE_URL || 'http://localhost:3000']);
-        });
-        it("Validates required agent fields during creation", () => {
-            // Test missing id
-            expect(() => {
-                (0, core_1.createAgent)({
-                    name: "Test Agent",
-                    context: [],
-                    prompt: "Test prompt",
-                    resolveCondition: "Test condition",
-                    input: zod_1.z.object({}),
-                    output: zod_1.z.object({}),
-                });
-            }).toThrow("Agent config is missing required fields");
-            // Test missing name
-            expect(() => {
-                (0, core_1.createAgent)({
-                    id: "test-agent",
-                    context: [],
-                    prompt: "Test prompt",
-                    resolveCondition: "Test condition",
-                    input: zod_1.z.object({}),
-                    output: zod_1.z.object({}),
-                });
-            }).toThrow("Agent config is missing required fields");
-            // Test missing prompt
-            expect(() => {
-                (0, core_1.createAgent)({
-                    id: "test-agent",
-                    name: "Test Agent",
-                    context: [],
-                    resolveCondition: "Test condition",
-                    input: zod_1.z.object({}),
-                    output: zod_1.z.object({}),
-                });
-            }).toThrow("Agent config is missing required fields");
-        });
-        it("Agent context data is properly included in detailed response", async () => {
-            const agent = await dainConnection.getAgent("help-assistant");
-            // Verify context array is included and correct
-            expect(Array.isArray(agent.context)).toBe(true);
-            expect(agent.context).toHaveLength(2);
-            expect(agent.context).toContain("You are a helpful AI assistant");
-            expect(agent.context).toContain("Always provide accurate and concise answers");
-        });
-        it("Service metadata reflects the total count including agents", () => {
-            // Verify the service includes the agent
-            const agents = dainService.getAgents();
-            expect(agents).toHaveLength(1);
-            expect(agents[0].id).toBe("help-assistant");
-            expect(agents[0].name).toBe("Help Assistant Agent");
-        });
-        it("Can find agent using service's findAgent method", () => {
-            const foundAgent = dainService.findAgent("help-assistant");
-            expect(foundAgent).toBeDefined();
-            expect(foundAgent?.id).toBe("help-assistant");
-            expect(foundAgent?.name).toBe("Help Assistant Agent");
-            // Test non-existent agent
-            const notFound = dainService.findAgent("non-existent");
-            expect(notFound).toBeUndefined();
-        });
-    });
-    describe("Home UI", () => {
-        it("should get home UI widget ID when configured as string", async () => {
-            const homeService = (0, nodeService_1.defineDAINService)({
-                metadata: {
-                    title: "Home UI Test Service",
-                    description: "Test service for home UI",
-                    version: "1.0.0",
-                    author: "Test Author",
-                    tags: ["test"],
-                },
-                identity: {
-                    publicKey: bs58_1.default.encode(publicKey),
-                    agentId: "home-ui-test-agent",
-                    orgId: "home-ui-test-org",
-                    privateKey: bs58_1.default.encode(privateKey),
-                },
-                services: [weatherService],
-                tools: [weatherTool, extraDataTool, confirmationTool, optionalParamsTool, noParamsTool, errorTool, knowledgeSearchTool],
-                toolboxes: [weatherToolbox],
-                contexts: [weatherContext],
-                widgets: [weatherWidget],
-                datasources: [weatherDatasource],
-                agents: [helpAgent],
-                homeUI: "weather-widget", // Static string configuration
-            });
-            const testServerHome = await homeService.startNode({ port: 3005 });
-            const clientHome = new client_1.DainServiceConnection("http://localhost:3005", new client_auth_1.DainClientAuth({
-                privateKeyBase58: bs58_1.default.encode(clientPrivateKey),
-                agentId: "home-ui-test-agent",
-                orgId: "home-ui-test-org",
-            }));
-            // Get home UI widget ID
-            const homeUIId = await clientHome.getHomeUI();
-            expect(homeUIId).toBe("weather-widget");
-            // Verify home widget exists and is accessible
-            const homeWidget = await clientHome.getWidget("weather-widget");
-            expect(homeWidget.name).toBe("Weather Info");
-            expect(homeWidget.ui.type).toBe("text");
-            await testServerHome.shutdown();
-        });
-        it("should get home UI widget ID when configured as function", async () => {
-            const homeService = (0, nodeService_1.defineDAINService)({
-                metadata: {
-                    title: "Dynamic Home UI Test Service",
-                    description: "Test service for dynamic home UI",
-                    version: "1.0.0",
-                    author: "Test Author",
-                    tags: ["test"],
-                },
-                identity: {
-                    publicKey: bs58_1.default.encode(publicKey),
-                    agentId: "dynamic-home-ui-test-agent",
-                    orgId: "dynamic-home-ui-test-org",
-                    privateKey: bs58_1.default.encode(privateKey),
-                },
-                services: [weatherService],
-                tools: [weatherTool, extraDataTool, confirmationTool, optionalParamsTool, noParamsTool, errorTool, knowledgeSearchTool],
-                toolboxes: [weatherToolbox],
-                contexts: [weatherContext],
-                widgets: [weatherWidget],
-                datasources: [weatherDatasource],
-                agents: [helpAgent],
-                // Dynamic function to determine home UI based on agent
-                homeUI: async (agentInfo) => {
-                    // Use different widgets based on agent ID
-                    if (agentInfo.agentId === "dynamic-home-ui-test-agent") {
-                        return "weather-widget";
-                    }
-                    return "weather-widget"; // Fallback to a default widget
-                },
-            });
-            const testServerDynamic = await homeService.startNode({ port: 3006 });
-            // Test with agent dynamic-home-ui-test-agent - should get weather-widget
-            const client1 = new client_1.DainServiceConnection("http://localhost:3006", new client_auth_1.DainClientAuth({
-                privateKeyBase58: bs58_1.default.encode(clientPrivateKey),
-                agentId: "dynamic-home-ui-test-agent",
-                orgId: "dynamic-home-ui-test-org",
-            }));
-            const homeUIId1 = await client1.getHomeUI();
-            expect(homeUIId1).toBe("weather-widget");
-            // Test with a different agent - should get weather-widget
-            const client2 = new client_1.DainServiceConnection("http://localhost:3006", new client_auth_1.DainClientAuth({
-                privateKeyBase58: bs58_1.default.encode(clientPrivateKey),
-                agentId: "another-agent",
-                orgId: "another-org",
-            }));
-            const homeUIId2 = await client2.getHomeUI();
-            expect(homeUIId2).toBe("weather-widget");
-            await testServerDynamic.shutdown();
-        });
-        it("should throw error when no home UI is configured", async () => {
-            // Use the main test service which doesn't have homeUI configured
-            await expect(dainConnection.getHomeUI()).rejects.toThrow("No home UI configured");
-        });
-        it("should throw error when home UI widget doesn't exist", async () => {
-            const badService = (0, nodeService_1.defineDAINService)({
-                metadata: {
-                    title: "Bad Home UI Test Service",
-                    description: "Test service with invalid home UI",
-                    version: "1.0.0",
-                    author: "Test Author",
-                    tags: ["test"],
-                },
-                identity: {
-                    publicKey: bs58_1.default.encode(publicKey),
-                    agentId: "bad-home-ui-test-agent",
-                    orgId: "bad-home-ui-test-org",
-                    privateKey: bs58_1.default.encode(privateKey),
-                },
-                services: [weatherService],
-                tools: [weatherTool, extraDataTool, confirmationTool, optionalParamsTool, noParamsTool, errorTool, knowledgeSearchTool],
-                toolboxes: [weatherToolbox],
-                contexts: [weatherContext],
-                widgets: [weatherWidget],
-                datasources: [weatherDatasource],
-                agents: [helpAgent],
-                homeUI: "non-existent-widget", // Invalid widget ID
-            });
-            const testServerBad = await badService.startNode({ port: 3007 });
-            const clientBad = new client_1.DainServiceConnection("http://localhost:3007", new client_auth_1.DainClientAuth({
-                privateKeyBase58: bs58_1.default.encode(clientPrivateKey),
-                agentId: "bad-home-ui-test-agent",
-                orgId: "bad-home-ui-test-org",
-            }));
-            await expect(clientBad.getHomeUI()).rejects.toThrow("Home UI widget not found");
-            await testServerBad.shutdown();
-        });
-        it("should allow home UI widget to be accessible even with getUserWidgets restriction", async () => {
-            // Create additional widgets for testing restriction
-            const homeWidget = (0, core_1.createWidget)({
-                id: "home-ui-widget",
-                name: "Home UI Widget",
-                description: "The home UI widget",
-                icon: "🏠",
-                getWidget: async () => ({
-                    text: "Welcome to home!",
-                    data: { message: "This is the home UI widget" },
-                    ui: { type: "home" },
-                }),
-            });
-            const sidebarWidget1 = (0, core_1.createWidget)({
-                id: "sidebar-widget-1",
-                name: "Sidebar Widget 1",
-                description: "First sidebar widget",
-                icon: "📊",
-                getWidget: async () => ({
-                    text: "Sidebar 1",
-                    data: { message: "This is sidebar widget 1" },
-                    ui: { type: "sidebar1" },
-                }),
-            });
-            const sidebarWidget2 = (0, core_1.createWidget)({
-                id: "sidebar-widget-2",
-                name: "Sidebar Widget 2",
-                description: "Second sidebar widget",
-                icon: "📈",
-                getWidget: async () => ({
-                    text: "Sidebar 2",
-                    data: { message: "This is sidebar widget 2" },
-                    ui: { type: "sidebar2" },
-                }),
-            });
-            const restrictedService = (0, nodeService_1.defineDAINService)({
-                metadata: {
-                    title: "Restricted Home UI Test Service",
-                    description: "Test service with widget restrictions",
-                    version: "1.0.0",
-                    author: "Test Author",
-                    tags: ["test"],
-                },
-                identity: {
-                    publicKey: bs58_1.default.encode(publicKey),
-                    agentId: "restricted-home-ui-test-agent",
-                    orgId: "restricted-home-ui-test-org",
-                    privateKey: bs58_1.default.encode(privateKey),
-                },
-                services: [weatherService],
-                tools: [weatherTool],
-                toolboxes: [weatherToolbox],
-                contexts: [weatherContext],
-                widgets: [homeWidget, sidebarWidget1, sidebarWidget2],
-                datasources: [weatherDatasource],
-                agents: [helpAgent],
-                homeUI: "home-ui-widget",
-                // This function restricts user to only sidebar widgets, but home UI should still work
-                getUserWidgets: async (agentInfo) => {
-                    return ["sidebar-widget-1", "sidebar-widget-2"]; // Only allow sidebar widgets
-                },
-            });
-            const testServerRestricted = await restrictedService.startNode({ port: 3008 });
-            const clientRestricted = new client_1.DainServiceConnection("http://localhost:3008", new client_auth_1.DainClientAuth({
-                privateKeyBase58: bs58_1.default.encode(clientPrivateKey),
-                agentId: "restricted-home-ui-test-agent",
-                orgId: "restricted-home-ui-test-org",
-            }));
-            // Should be able to get home UI even though getUserWidgets doesn't include it
-            const homeUIId = await clientRestricted.getHomeUI();
-            expect(homeUIId).toBe("home-ui-widget");
-            // Verify regular widget access is restricted to sidebar widgets only
-            const userWidgets = await clientRestricted.getWidgets();
-            expect(userWidgets).toEqual(["sidebar-widget-1", "sidebar-widget-2"]);
-            expect(userWidgets).not.toContain("home-ui-widget");
-            //  Verify we can still fetch the home UI widget data
-            // even though it's not in getUserWidgets
-            const homeWidgetData = await clientRestricted.getWidget("home-ui-widget");
-            expect(homeWidgetData).toBeDefined();
-            expect(homeWidgetData.id).toBe("home-ui-widget");
-            expect(homeWidgetData.name).toBe("Home UI Widget");
-            expect(homeWidgetData.text).toBe("Welcome to home!");
-            await testServerRestricted.shutdown();
-        });
-    });
-});
-//# sourceMappingURL=integration.test.js.map