@shuttl-io/core 0.2.0

package/dist/tests/server/http.test.js

@@ -0,0 +1,553 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const events_1 = require("events");
+// Create mock instances before jest.mock calls
+const mockStdin = new events_1.EventEmitter();
+const mockStdoutWrite = jest.fn();
+const mockReadlineInterface = new events_1.EventEmitter();
+mockReadlineInterface.close = jest.fn();
+// Increase max listeners to avoid warnings during tests
+mockReadlineInterface.setMaxListeners(50);
+// Mock process module
+jest.mock("process", () => ({
+    stdin: mockStdin,
+    stdout: {
+        write: (data) => mockStdoutWrite(data),
+    },
+}));
+// Mock readline module
+jest.mock("readline", () => ({
+    createInterface: jest.fn(() => mockReadlineInterface),
+}));
+const http_1 = require("../../src/server/http");
+const tool_1 = require("../../src/tools/tool");
+describe("StdInServer", () => {
+    let server;
+    // Helper to parse captured responses
+    const getResponses = () => {
+        return mockStdoutWrite.mock.calls.map((call) => {
+            const json = call[0].replace(/\n$/, "");
+            return JSON.parse(json);
+        });
+    };
+    // Helper to get the last response
+    const getLastResponse = () => {
+        const responses = getResponses();
+        return responses[responses.length - 1];
+    };
+    // Helper to simulate sending a line of input
+    const sendLine = (line) => {
+        mockReadlineInterface.emit("line", line);
+    };
+    // Helper to send a request object
+    const sendRequest = (request) => {
+        sendLine(JSON.stringify(request));
+    };
+    beforeEach(() => {
+        jest.clearAllMocks();
+        server = new http_1.StdInServer();
+    });
+    afterEach(async () => {
+        await server.stop();
+    });
+    describe("accept()", () => {
+        it("should accept an app", () => {
+            const mockApp = { name: "TestApp", agents: [], toolkits: new Set() };
+            expect(() => server.accept(mockApp)).not.toThrow();
+        });
+    });
+    describe("start()", () => {
+        it("should throw if no app is registered", async () => {
+            await expect(server.start()).rejects.toThrow("No app registered. Call accept() before start().");
+        });
+        it("should send ready signal on start", async () => {
+            const mockApp = { name: "TestApp", agents: [], toolkits: new Set() };
+            server.accept(mockApp);
+            // Start in background (don't await, it runs indefinitely)
+            void server.start();
+            // Give it a tick to send ready signal
+            await new Promise((resolve) => setTimeout(resolve, 10));
+            const readyResponse = getResponses().find((r) => r.id === "__ready__");
+            expect(readyResponse).toBeDefined();
+            expect(readyResponse.success).toBe(true);
+            expect(readyResponse.result).toEqual({
+                name: "TestApp",
+                protocol: "ndjson",
+                version: "1.0",
+            });
+            await server.stop();
+        });
+    });
+    describe("handleLine()", () => {
+        beforeEach(async () => {
+            const mockApp = { name: "TestApp", agents: [], toolkits: new Set() };
+            server.accept(mockApp);
+            void server.start(); // Start but don't await
+            await new Promise((resolve) => setTimeout(resolve, 10));
+            jest.clearAllMocks(); // Clear ready signal
+        });
+        it("should skip empty lines", () => {
+            sendLine("");
+            sendLine("   ");
+            sendLine("\t");
+            expect(mockStdoutWrite).not.toHaveBeenCalled();
+        });
+        it("should return parse error for invalid JSON", () => {
+            sendLine("not valid json");
+            const response = getLastResponse();
+            expect(response.id).toBe("__parse_error__");
+            expect(response.success).toBe(false);
+            expect(response.errorObj?.code).toBe("PARSE_ERROR");
+        });
+        it("should return error for missing id field", () => {
+            sendLine(JSON.stringify({ method: "ping" }));
+            const response = getLastResponse();
+            expect(response.id).toBe("__invalid__");
+            expect(response.success).toBe(false);
+            expect(response.errorObj?.code).toBe("INVALID_REQUEST");
+            expect(response.errorObj?.message).toContain("'id' field");
+        });
+        it("should return error for non-string id field", () => {
+            sendLine(JSON.stringify({ id: 123, method: "ping" }));
+            const response = getLastResponse();
+            expect(response.success).toBe(false);
+            expect(response.errorObj?.code).toBe("INVALID_REQUEST");
+        });
+        it("should return error for missing method field", () => {
+            sendLine(JSON.stringify({ id: "1" }));
+            const response = getLastResponse();
+            expect(response.id).toBe("1");
+            expect(response.success).toBe(false);
+            expect(response.errorObj?.code).toBe("INVALID_REQUEST");
+            expect(response.errorObj?.message).toContain("'method' field");
+        });
+        it("should return error for non-string method field", () => {
+            sendLine(JSON.stringify({ id: "1", method: 123 }));
+            const response = getLastResponse();
+            expect(response.success).toBe(false);
+            expect(response.errorObj?.code).toBe("INVALID_REQUEST");
+        });
+    });
+    describe("handleRequest()", () => {
+        beforeEach(async () => {
+            const mockApp = { name: "TestApp", agents: [], toolkits: new Set() };
+            server.accept(mockApp);
+            void server.start();
+            await new Promise((resolve) => setTimeout(resolve, 10));
+            jest.clearAllMocks();
+        });
+        describe("ping", () => {
+            it("should respond with pong and timestamp", () => {
+                const now = Date.now();
+                sendRequest({ id: "1", method: "ping" });
+                const response = getLastResponse();
+                expect(response.id).toBe("1");
+                expect(response.success).toBe(true);
+                expect(response.result).toMatchObject({
+                    pong: true,
+                    protocol_version: "1.0",
+                });
+                expect(response.result.timestamp).toBeGreaterThanOrEqual(now);
+            });
+        });
+        describe("getAppInfo", () => {
+            it("should return app information", () => {
+                sendRequest({ id: "2", method: "getAppInfo" });
+                const response = getLastResponse();
+                expect(response.id).toBe("2");
+                expect(response.success).toBe(true);
+                expect(response.result).toEqual({
+                    name: "TestApp",
+                    agentCount: 0,
+                    toolkitCount: 0,
+                });
+            });
+        });
+        describe("listAgents", () => {
+            it("should return empty array when no agents", () => {
+                sendRequest({ id: "3", method: "listAgents" });
+                const response = getLastResponse();
+                expect(response.id).toBe("3");
+                expect(response.success).toBe(true);
+                expect(response.result).toEqual([]);
+            });
+            it("should return agent information", async () => {
+                const mockAgent = {
+                    name: "TestAgent",
+                    systemPrompt: "You are a test agent",
+                    model: { provider: "openai", name: "gpt-4" },
+                    toolkits: [{ name: "toolkit1" }],
+                };
+                const mockApp = {
+                    name: "TestApp",
+                    agents: [mockAgent],
+                    toolkits: new Set(),
+                };
+                await server.stop();
+                server = new http_1.StdInServer();
+                server.accept(mockApp);
+                void server.start();
+                await new Promise((resolve) => setTimeout(resolve, 10));
+                jest.clearAllMocks();
+                sendRequest({ id: "4", method: "listAgents" });
+                const response = getLastResponse();
+                expect(response.success).toBe(true);
+                expect(response.result).toEqual([
+                    {
+                        name: "TestAgent",
+                        systemPrompt: "You are a test agent",
+                        model: { provider: "openai", name: "gpt-4" },
+                        toolkits: ["toolkit1"],
+                    },
+                ]);
+            });
+        });
+        describe("listToolkits", () => {
+            it("should return empty array when no toolkits", () => {
+                sendRequest({ id: "5", method: "listToolkits" });
+                const response = getLastResponse();
+                expect(response.id).toBe("5");
+                expect(response.success).toEqual(true);
+                expect(response.result).toEqual([]);
+            });
+            it("should return toolkit information with tools", async () => {
+                const mockTool = {
+                    name: "testTool",
+                    description: "A test tool",
+                    schema: tool_1.Schema.objectValue({
+                        arg1: tool_1.Schema.stringValue("A test argument").isRequired(),
+                    }),
+                    execute: jest.fn(),
+                };
+                const mockToolkit = {
+                    name: "TestToolkit",
+                    description: "A test toolkit",
+                    tools: [mockTool],
+                };
+                const mockApp = {
+                    name: "TestApp",
+                    agents: [],
+                    toolkits: new Set([mockToolkit]),
+                };
+                await server.stop();
+                server = new http_1.StdInServer();
+                server.accept(mockApp);
+                void server.start();
+                await new Promise((resolve) => setTimeout(resolve, 10));
+                jest.clearAllMocks();
+                sendRequest({ id: "6", method: "listToolkits" });
+                const response = getLastResponse();
+                console.log(response);
+                expect(response.success).toBe(true);
+                expect(response.result).toEqual([
+                    {
+                        name: "TestToolkit",
+                        description: "A test toolkit",
+                        tools: [
+                            {
+                                name: "testTool",
+                                description: "A test tool",
+                                args: {
+                                    arg1: { argType: "string", required: true, description: "A test argument" }
+                                },
+                            },
+                        ],
+                    },
+                ]);
+            });
+        });
+        describe("shutdown", () => {
+            it("should respond and stop the server", async () => {
+                sendRequest({ id: "7", method: "shutdown" });
+                const response = getLastResponse();
+                expect(response.id).toBe("7");
+                expect(response.success).toBe(true);
+                expect(response.result).toEqual({ shutting_down: true });
+            });
+        });
+        describe("unknown method", () => {
+            it("should return error for unknown method", () => {
+                sendRequest({ id: "8", method: "unknownMethod" });
+                const response = getLastResponse();
+                expect(response.id).toBe("8");
+                expect(response.success).toBe(false);
+                expect(response.errorObj?.code).toBe("UNKNOWN_METHOD");
+                expect(response.errorObj?.message).toContain("unknownMethod");
+            });
+        });
+    });
+    describe("handleInvokeTool()", () => {
+        let mockTool;
+        let mockToolkit;
+        beforeEach(async () => {
+            mockTool = {
+                name: "testTool",
+                description: "A test tool",
+                execute: jest.fn().mockReturnValue({ result: "success" }),
+                produceArgs: jest.fn().mockReturnValue({}),
+            };
+            mockToolkit = {
+                name: "TestToolkit",
+                description: "A test toolkit",
+                tools: [mockTool],
+            };
+            const mockApp = {
+                name: "TestApp",
+                agents: [],
+                toolkits: new Set([mockToolkit]),
+            };
+            server.accept(mockApp);
+            void server.start();
+            await new Promise((resolve) => setTimeout(resolve, 10));
+            jest.clearAllMocks();
+        });
+        it("should return error if toolkit param is missing", () => {
+            sendRequest({
+                id: "10",
+                method: "invokeTool",
+                body: { tool: "testTool" },
+            });
+            const response = getLastResponse();
+            expect(response.success).toBe(false);
+            expect(response.errorObj?.code).toBe("INVALID_PARAMS");
+        });
+        it("should return error if tool param is missing", () => {
+            sendRequest({
+                id: "11",
+                method: "invokeTool",
+                body: { toolkit: "TestToolkit" },
+            });
+            const response = getLastResponse();
+            expect(response.success).toBe(false);
+            expect(response.errorObj?.code).toBe("INVALID_PARAMS");
+        });
+        it("should return error if toolkit not found", () => {
+            sendRequest({
+                id: "12",
+                method: "invokeTool",
+                body: { toolkit: "NonExistent", tool: "testTool" },
+            });
+            const response = getLastResponse();
+            expect(response.success).toBe(false);
+            expect(response.errorObj?.code).toBe("NOT_FOUND");
+            expect(response.errorObj?.message).toContain("Toolkit not found");
+        });
+        it("should return error if tool not found in toolkit", () => {
+            sendRequest({
+                id: "13",
+                method: "invokeTool",
+                body: { toolkit: "TestToolkit", tool: "nonExistentTool" },
+            });
+            const response = getLastResponse();
+            expect(response.success).toBe(false);
+            expect(response.errorObj?.code).toBe("NOT_FOUND");
+            expect(response.errorObj?.message).toContain("Tool not found");
+        });
+        it("should execute tool and return result", () => {
+            sendRequest({
+                id: "14",
+                method: "invokeTool",
+                body: { toolkit: "TestToolkit", tool: "testTool", args: { foo: "bar" } },
+            });
+            expect(mockTool.execute).toHaveBeenCalledWith({ foo: "bar" });
+            const response = getLastResponse();
+            expect(response.success).toBe(true);
+            expect(response.result).toEqual({ result: "success" });
+        });
+        it("should handle async tool execution", async () => {
+            mockTool.execute.mockResolvedValue({ asyncResult: "done" });
+            sendRequest({
+                id: "15",
+                method: "invokeTool",
+                body: { toolkit: "TestToolkit", tool: "testTool" },
+            });
+            // Wait for async resolution
+            await new Promise((resolve) => setTimeout(resolve, 10));
+            const response = getLastResponse();
+            expect(response.id).toBe("15");
+            expect(response.success).toBe(true);
+            expect(response.result).toEqual({ asyncResult: "done" });
+        });
+        it("should handle async tool error", async () => {
+            mockTool.execute.mockRejectedValue(new Error("Async error"));
+            sendRequest({
+                id: "16",
+                method: "invokeTool",
+                body: { toolkit: "TestToolkit", tool: "testTool" },
+            });
+            // Wait for async rejection
+            await new Promise((resolve) => setTimeout(resolve, 10));
+            const response = getLastResponse();
+            expect(response.id).toBe("16");
+            expect(response.success).toBe(false);
+            expect(response.errorObj?.code).toBe("TOOL_ERROR");
+            expect(response.errorObj?.message).toBe("Async error");
+        });
+        it("should handle sync tool error", () => {
+            mockTool.execute.mockImplementation(() => {
+                throw new Error("Sync error");
+            });
+            sendRequest({
+                id: "17",
+                method: "invokeTool",
+                body: { toolkit: "TestToolkit", tool: "testTool" },
+            });
+            const response = getLastResponse();
+            expect(response.success).toBe(false);
+            expect(response.errorObj?.code).toBe("TOOL_ERROR");
+            expect(response.errorObj?.message).toBe("Sync error");
+        });
+        it("should use empty args if not provided", () => {
+            sendRequest({
+                id: "18",
+                method: "invokeTool",
+                body: { toolkit: "TestToolkit", tool: "testTool" },
+            });
+            expect(mockTool.execute).toHaveBeenCalledWith({});
+        });
+    });
+    describe("handleInvokeAgent()", () => {
+        let mockAgent;
+        beforeEach(async () => {
+            mockAgent = {
+                name: "TestAgent",
+                systemPrompt: "You are a test agent",
+                model: { provider: "openai", name: "gpt-4" },
+                toolkits: [{ name: "toolkit1" }],
+                invoke: jest.fn().mockResolvedValue({ threadId: "thread-123" }),
+            };
+            const mockApp = {
+                name: "TestApp",
+                agents: [mockAgent],
+                toolkits: new Set(),
+            };
+            server.accept(mockApp);
+            void server.start();
+            await new Promise((resolve) => setTimeout(resolve, 10));
+            jest.clearAllMocks();
+        });
+        it("should return error if agent param is missing", () => {
+            sendRequest({
+                id: "20",
+                method: "invokeAgent",
+                body: { prompt: "Hello" },
+            });
+            const response = getLastResponse();
+            expect(response.success).toBe(false);
+            expect(response.errorObj?.code).toBe("INVALID_PARAMS");
+            expect(response.errorObj?.message).toContain("'agent'");
+        });
+        it("should return error if agent not found", () => {
+            sendRequest({
+                id: "21",
+                method: "invokeAgent",
+                body: { agent: "NonExistentAgent", prompt: "Hello" },
+            });
+            const response = getLastResponse();
+            expect(response.success).toBe(false);
+            expect(response.errorObj?.code).toBe("NOT_FOUND");
+            expect(response.errorObj?.message).toContain("Agent not found");
+        });
+        it("should invoke agent and return thread info on success", async () => {
+            sendRequest({
+                id: "22",
+                method: "invokeAgent",
+                body: { agent: "TestAgent", prompt: "Hello, agent!" },
+            });
+            // Wait for async invoke
+            await new Promise((resolve) => setTimeout(resolve, 10));
+            expect(mockAgent.invoke).toHaveBeenCalled();
+            const response = getLastResponse();
+            expect(response.id).toBe("22");
+            expect(response.success).toBe(true);
+            expect(response.result).toMatchObject({
+                threadId: "thread-123",
+                status: "invoked",
+            });
+        });
+        it("should invoke agent with empty prompt if not provided", async () => {
+            sendRequest({
+                id: "23",
+                method: "invokeAgent",
+                body: { agent: "TestAgent" },
+            });
+            // Wait for async invoke
+            await new Promise((resolve) => setTimeout(resolve, 10));
+            expect(mockAgent.invoke).toHaveBeenCalledWith("", undefined, expect.anything(), undefined);
+        });
+        it("should pass threadId if provided", async () => {
+            sendRequest({
+                id: "24",
+                method: "invokeAgent",
+                body: { agent: "TestAgent", prompt: "Continue...", threadId: "existing-thread" },
+            });
+            await new Promise((resolve) => setTimeout(resolve, 10));
+            expect(mockAgent.invoke).toHaveBeenCalledWith("Continue...", "existing-thread", expect.anything(), undefined);
+        });
+        it("should pass attachments if provided", async () => {
+            const attachments = [
+                { name: "test.txt", content: "SGVsbG8gV29ybGQ=", mimeType: "text/plain" },
+            ];
+            sendRequest({
+                id: "25a",
+                method: "invokeAgent",
+                body: { agent: "TestAgent", prompt: "Check this file", attachments },
+            });
+            await new Promise((resolve) => setTimeout(resolve, 10));
+            expect(mockAgent.invoke).toHaveBeenCalledWith("Check this file", undefined, expect.anything(), attachments);
+        });
+        it("should return error on agent invoke failure", async () => {
+            mockAgent.invoke.mockRejectedValue(new Error("Agent failed"));
+            sendRequest({
+                id: "25",
+                method: "invokeAgent",
+                body: { agent: "TestAgent", prompt: "Hello" },
+            });
+            // Wait for async rejection
+            await new Promise((resolve) => setTimeout(resolve, 10));
+            const response = getLastResponse();
+            expect(response.id).toBe("25");
+            expect(response.success).toBe(false);
+            expect(response.errorObj?.code).toBe("INTERNAL_ERROR");
+        });
+        it("should handle no body at all", () => {
+            sendRequest({
+                id: "26",
+                method: "invokeAgent",
+            });
+            const response = getLastResponse();
+            expect(response.success).toBe(false);
+            expect(response.errorObj?.code).toBe("INVALID_PARAMS");
+        });
+    });
+    describe("stop()", () => {
+        it("should stop the server gracefully", async () => {
+            const mockApp = { name: "TestApp", agents: [], toolkits: new Set() };
+            server.accept(mockApp);
+            const startPromise = server.start();
+            await new Promise((resolve) => setTimeout(resolve, 10));
+            await server.stop();
+            // Server should exit the start loop
+            await expect(Promise.race([
+                startPromise,
+                new Promise((_, reject) => setTimeout(() => reject(new Error("Timeout")), 500)),
+            ])).resolves.toBeUndefined();
+        });
+    });
+    describe("readline close event", () => {
+        it("should stop running when readline closes", async () => {
+            const mockApp = { name: "TestApp", agents: [], toolkits: new Set() };
+            server.accept(mockApp);
+            const startPromise = server.start();
+            await new Promise((resolve) => setTimeout(resolve, 10));
+            // Simulate stdin close
+            mockReadlineInterface.emit("close");
+            // Server should exit
+            await expect(Promise.race([
+                startPromise,
+                new Promise((_, reject) => setTimeout(() => reject(new Error("Timeout")), 500)),
+            ])).resolves.toBeUndefined();
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"http.test.js","sourceRoot":"","sources":["../../../tests/server/http.test.ts"],"names":[],"mappings":"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","sourcesContent":["import { EventEmitter } from \"events\";\n\n// Create mock instances before jest.mock calls\nconst mockStdin = new EventEmitter();\nconst mockStdoutWrite = jest.fn();\nconst mockReadlineInterface = new EventEmitter() as EventEmitter & { close: jest.Mock };\nmockReadlineInterface.close = jest.fn();\n\n// Increase max listeners to avoid warnings during tests\nmockReadlineInterface.setMaxListeners(50);\n\n// Mock process module\njest.mock(\"process\", () => ({\n    stdin: mockStdin,\n    stdout: {\n        write: (data: string) => mockStdoutWrite(data),\n    },\n}));\n\n// Mock readline module\njest.mock(\"readline\", () => ({\n    createInterface: jest.fn(() => mockReadlineInterface),\n}));\n\nimport { StdInServer, IPCRequest, IPCResponse } from \"../../src/server/http\";\nimport { Schema } from \"../../src/tools/tool\";\n\ndescribe(\"StdInServer\", () => {\n    let server: StdInServer;\n\n    // Helper to parse captured responses\n    const getResponses = (): IPCResponse[] => {\n        return mockStdoutWrite.mock.calls.map((call) => {\n            const json = call[0].replace(/\\n$/, \"\");\n            return JSON.parse(json) as IPCResponse;\n        });\n    };\n\n    // Helper to get the last response\n    const getLastResponse = (): IPCResponse => {\n        const responses = getResponses();\n        return responses[responses.length - 1];\n    };\n\n    // Helper to simulate sending a line of input\n    const sendLine = (line: string) => {\n        mockReadlineInterface.emit(\"line\", line);\n    };\n\n    // Helper to send a request object\n    const sendRequest = (request: IPCRequest) => {\n        sendLine(JSON.stringify(request));\n    };\n\n    beforeEach(() => {\n        jest.clearAllMocks();\n        server = new StdInServer();\n    });\n\n    afterEach(async () => {\n        await server.stop();\n    });\n\n    describe(\"accept()\", () => {\n        it(\"should accept an app\", () => {\n            const mockApp = { name: \"TestApp\", agents: [], toolkits: new Set() };\n            expect(() => server.accept(mockApp)).not.toThrow();\n        });\n    });\n\n    describe(\"start()\", () => {\n        it(\"should throw if no app is registered\", async () => {\n            await expect(server.start()).rejects.toThrow(\n                \"No app registered. Call accept() before start().\"\n            );\n        });\n\n        it(\"should send ready signal on start\", async () => {\n            const mockApp = { name: \"TestApp\", agents: [], toolkits: new Set() };\n            server.accept(mockApp);\n\n            // Start in background (don't await, it runs indefinitely)\n            void server.start();\n\n            // Give it a tick to send ready signal\n            await new Promise((resolve) => setTimeout(resolve, 10));\n\n            const readyResponse = getResponses().find((r) => r.id === \"__ready__\");\n            expect(readyResponse).toBeDefined();\n            expect(readyResponse!.success).toBe(true);\n            expect(readyResponse!.result).toEqual({\n                name: \"TestApp\",\n                protocol: \"ndjson\",\n                version: \"1.0\",\n            });\n\n            await server.stop();\n        });\n    });\n\n    describe(\"handleLine()\", () => {\n        beforeEach(async () => {\n            const mockApp = { name: \"TestApp\", agents: [], toolkits: new Set() };\n            server.accept(mockApp);\n            void server.start(); // Start but don't await\n            await new Promise((resolve) => setTimeout(resolve, 10));\n            jest.clearAllMocks(); // Clear ready signal\n        });\n\n        it(\"should skip empty lines\", () => {\n            sendLine(\"\");\n            sendLine(\"   \");\n            sendLine(\"\\t\");\n            expect(mockStdoutWrite).not.toHaveBeenCalled();\n        });\n\n        it(\"should return parse error for invalid JSON\", () => {\n            sendLine(\"not valid json\");\n\n            const response = getLastResponse();\n            expect(response.id).toBe(\"__parse_error__\");\n            expect(response.success).toBe(false);\n            expect(response.errorObj?.code).toBe(\"PARSE_ERROR\");\n        });\n\n        it(\"should return error for missing id field\", () => {\n            sendLine(JSON.stringify({ method: \"ping\" }));\n\n            const response = getLastResponse();\n            expect(response.id).toBe(\"__invalid__\");\n            expect(response.success).toBe(false);\n            expect(response.errorObj?.code).toBe(\"INVALID_REQUEST\");\n            expect(response.errorObj?.message).toContain(\"'id' field\");\n        });\n\n        it(\"should return error for non-string id field\", () => {\n            sendLine(JSON.stringify({ id: 123, method: \"ping\" }));\n\n            const response = getLastResponse();\n            expect(response.success).toBe(false);\n            expect(response.errorObj?.code).toBe(\"INVALID_REQUEST\");\n        });\n\n        it(\"should return error for missing method field\", () => {\n            sendLine(JSON.stringify({ id: \"1\" }));\n\n            const response = getLastResponse();\n            expect(response.id).toBe(\"1\");\n            expect(response.success).toBe(false);\n            expect(response.errorObj?.code).toBe(\"INVALID_REQUEST\");\n            expect(response.errorObj?.message).toContain(\"'method' field\");\n        });\n\n        it(\"should return error for non-string method field\", () => {\n            sendLine(JSON.stringify({ id: \"1\", method: 123 }));\n\n            const response = getLastResponse();\n            expect(response.success).toBe(false);\n            expect(response.errorObj?.code).toBe(\"INVALID_REQUEST\");\n        });\n    });\n\n    describe(\"handleRequest()\", () => {\n        beforeEach(async () => {\n            const mockApp = { name: \"TestApp\", agents: [], toolkits: new Set() };\n            server.accept(mockApp);\n            void server.start();\n            await new Promise((resolve) => setTimeout(resolve, 10));\n            jest.clearAllMocks();\n        });\n\n        describe(\"ping\", () => {\n            it(\"should respond with pong and timestamp\", () => {\n                const now = Date.now();\n                sendRequest({ id: \"1\", method: \"ping\" });\n\n                const response = getLastResponse();\n                expect(response.id).toBe(\"1\");\n                expect(response.success).toBe(true);\n                expect(response.result).toMatchObject({\n                    pong: true,\n                    protocol_version: \"1.0\",\n                });\n                expect((response.result as Record<string, unknown>).timestamp).toBeGreaterThanOrEqual(now);\n            });\n        });\n\n        describe(\"getAppInfo\", () => {\n            it(\"should return app information\", () => {\n                sendRequest({ id: \"2\", method: \"getAppInfo\" });\n\n                const response = getLastResponse();\n                expect(response.id).toBe(\"2\");\n                expect(response.success).toBe(true);\n                expect(response.result).toEqual({\n                    name: \"TestApp\",\n                    agentCount: 0,\n                    toolkitCount: 0,\n                });\n            });\n        });\n\n        describe(\"listAgents\", () => {\n            it(\"should return empty array when no agents\", () => {\n                sendRequest({ id: \"3\", method: \"listAgents\" });\n\n                const response = getLastResponse();\n                expect(response.id).toBe(\"3\");\n                expect(response.success).toBe(true);\n                expect(response.result).toEqual([]);\n            });\n\n            it(\"should return agent information\", async () => {\n                const mockAgent = {\n                    name: \"TestAgent\",\n                    systemPrompt: \"You are a test agent\",\n                    model: { provider: \"openai\", name: \"gpt-4\" },\n                    toolkits: [{ name: \"toolkit1\" }],\n                };\n                const mockApp = {\n                    name: \"TestApp\",\n                    agents: [mockAgent],\n                    toolkits: new Set(),\n                };\n\n                await server.stop();\n                server = new StdInServer();\n                server.accept(mockApp);\n                void server.start();\n                await new Promise((resolve) => setTimeout(resolve, 10));\n                jest.clearAllMocks();\n\n                sendRequest({ id: \"4\", method: \"listAgents\" });\n\n                const response = getLastResponse();\n                expect(response.success).toBe(true);\n                expect(response.result).toEqual([\n                    {\n                        name: \"TestAgent\",\n                        systemPrompt: \"You are a test agent\",\n                        model: { provider: \"openai\", name: \"gpt-4\" },\n                        toolkits: [\"toolkit1\"],\n                    },\n                ]);\n            });\n        });\n\n        describe(\"listToolkits\", () => {\n            it(\"should return empty array when no toolkits\", () => {\n                sendRequest({ id: \"5\", method: \"listToolkits\" });\n\n                const response = getLastResponse();\n                \n                expect(response.id).toBe(\"5\");\n                expect(response.success).toEqual(true);\n                expect(response.result).toEqual([]);\n            });\n\n            it(\"should return toolkit information with tools\", async () => {\n                const mockTool = {\n                    name: \"testTool\",\n                    description: \"A test tool\",\n                    schema: Schema.objectValue({\n                        arg1: Schema.stringValue(\"A test argument\").isRequired(),\n                    }),\n                    execute: jest.fn(),\n                };\n                const mockToolkit = {\n                    name: \"TestToolkit\",\n                    description: \"A test toolkit\",\n                    tools: [mockTool],\n                };\n                const mockApp = {\n                    name: \"TestApp\",\n                    agents: [],\n                    toolkits: new Set([mockToolkit]),\n                };\n\n                await server.stop();\n                server = new StdInServer();\n                server.accept(mockApp);\n                void server.start();\n                await new Promise((resolve) => setTimeout(resolve, 10));\n                jest.clearAllMocks();\n\n                sendRequest({ id: \"6\", method: \"listToolkits\" });\n\n                const response = getLastResponse();\n                console.log(response);\n                expect(response.success).toBe(true);\n                expect(response.result).toEqual([\n                    {\n                        name: \"TestToolkit\",\n                        description: \"A test toolkit\",\n                        tools: [\n                            {\n                                name: \"testTool\",\n                                description: \"A test tool\",\n                                args: { \n                                    arg1: { argType: \"string\", required: true, description: \"A test argument\" } },\n                            },\n                        ],\n                    },\n                ]);\n            });\n        });\n\n        describe(\"shutdown\", () => {\n            it(\"should respond and stop the server\", async () => {\n                sendRequest({ id: \"7\", method: \"shutdown\" });\n\n                const response = getLastResponse();\n                expect(response.id).toBe(\"7\");\n                expect(response.success).toBe(true);\n                expect(response.result).toEqual({ shutting_down: true });\n            });\n        });\n\n        describe(\"unknown method\", () => {\n            it(\"should return error for unknown method\", () => {\n                sendRequest({ id: \"8\", method: \"unknownMethod\" });\n\n                const response = getLastResponse();\n                expect(response.id).toBe(\"8\");\n                expect(response.success).toBe(false);\n                expect(response.errorObj?.code).toBe(\"UNKNOWN_METHOD\");\n                expect(response.errorObj?.message).toContain(\"unknownMethod\");\n            });\n        });\n    });\n\n    describe(\"handleInvokeTool()\", () => {\n        let mockTool: {\n            name: string;\n            description: string;\n            execute: jest.Mock;\n            produceArgs: jest.Mock;\n        };\n        let mockToolkit: {\n            name: string;\n            description: string;\n            tools: typeof mockTool[];\n        };\n\n        beforeEach(async () => {\n            mockTool = {\n                name: \"testTool\",\n                description: \"A test tool\",\n                execute: jest.fn().mockReturnValue({ result: \"success\" }),\n                produceArgs: jest.fn().mockReturnValue({}),\n            };\n            mockToolkit = {\n                name: \"TestToolkit\",\n                description: \"A test toolkit\",\n                tools: [mockTool],\n            };\n            const mockApp = {\n                name: \"TestApp\",\n                agents: [],\n                toolkits: new Set([mockToolkit]),\n            };\n\n            server.accept(mockApp);\n            void server.start();\n            await new Promise((resolve) => setTimeout(resolve, 10));\n            jest.clearAllMocks();\n        });\n\n        it(\"should return error if toolkit param is missing\", () => {\n            sendRequest({\n                id: \"10\",\n                method: \"invokeTool\",\n                body: { tool: \"testTool\" },\n            });\n\n            const response = getLastResponse();\n            expect(response.success).toBe(false);\n            expect(response.errorObj?.code).toBe(\"INVALID_PARAMS\");\n        });\n\n        it(\"should return error if tool param is missing\", () => {\n            sendRequest({\n                id: \"11\",\n                method: \"invokeTool\",\n                body: { toolkit: \"TestToolkit\" },\n            });\n\n            const response = getLastResponse();\n            expect(response.success).toBe(false);\n            expect(response.errorObj?.code).toBe(\"INVALID_PARAMS\");\n        });\n\n        it(\"should return error if toolkit not found\", () => {\n            sendRequest({\n                id: \"12\",\n                method: \"invokeTool\",\n                body: { toolkit: \"NonExistent\", tool: \"testTool\" },\n            });\n\n            const response = getLastResponse();\n            expect(response.success).toBe(false);\n            expect(response.errorObj?.code).toBe(\"NOT_FOUND\");\n            expect(response.errorObj?.message).toContain(\"Toolkit not found\");\n        });\n\n        it(\"should return error if tool not found in toolkit\", () => {\n            sendRequest({\n                id: \"13\",\n                method: \"invokeTool\",\n                body: { toolkit: \"TestToolkit\", tool: \"nonExistentTool\" },\n            });\n\n            const response = getLastResponse();\n            expect(response.success).toBe(false);\n            expect(response.errorObj?.code).toBe(\"NOT_FOUND\");\n            expect(response.errorObj?.message).toContain(\"Tool not found\");\n        });\n\n        it(\"should execute tool and return result\", () => {\n            sendRequest({\n                id: \"14\",\n                method: \"invokeTool\",\n                body: { toolkit: \"TestToolkit\", tool: \"testTool\", args: { foo: \"bar\" } },\n            });\n\n            expect(mockTool.execute).toHaveBeenCalledWith({ foo: \"bar\" });\n            const response = getLastResponse();\n            expect(response.success).toBe(true);\n            expect(response.result).toEqual({ result: \"success\" });\n        });\n\n        it(\"should handle async tool execution\", async () => {\n            mockTool.execute.mockResolvedValue({ asyncResult: \"done\" });\n\n            sendRequest({\n                id: \"15\",\n                method: \"invokeTool\",\n                body: { toolkit: \"TestToolkit\", tool: \"testTool\" },\n            });\n\n            // Wait for async resolution\n            await new Promise((resolve) => setTimeout(resolve, 10));\n\n            const response = getLastResponse();\n            expect(response.id).toBe(\"15\");\n            expect(response.success).toBe(true);\n            expect(response.result).toEqual({ asyncResult: \"done\" });\n        });\n\n        it(\"should handle async tool error\", async () => {\n            mockTool.execute.mockRejectedValue(new Error(\"Async error\"));\n\n            sendRequest({\n                id: \"16\",\n                method: \"invokeTool\",\n                body: { toolkit: \"TestToolkit\", tool: \"testTool\" },\n            });\n\n            // Wait for async rejection\n            await new Promise((resolve) => setTimeout(resolve, 10));\n\n            const response = getLastResponse();\n            expect(response.id).toBe(\"16\");\n            expect(response.success).toBe(false);\n            expect(response.errorObj?.code).toBe(\"TOOL_ERROR\");\n            expect(response.errorObj?.message).toBe(\"Async error\");\n        });\n\n        it(\"should handle sync tool error\", () => {\n            mockTool.execute.mockImplementation(() => {\n                throw new Error(\"Sync error\");\n            });\n\n            sendRequest({\n                id: \"17\",\n                method: \"invokeTool\",\n                body: { toolkit: \"TestToolkit\", tool: \"testTool\" },\n            });\n\n            const response = getLastResponse();\n            expect(response.success).toBe(false);\n            expect(response.errorObj?.code).toBe(\"TOOL_ERROR\");\n            expect(response.errorObj?.message).toBe(\"Sync error\");\n        });\n\n        it(\"should use empty args if not provided\", () => {\n            sendRequest({\n                id: \"18\",\n                method: \"invokeTool\",\n                body: { toolkit: \"TestToolkit\", tool: \"testTool\" },\n            });\n\n            expect(mockTool.execute).toHaveBeenCalledWith({});\n        });\n    });\n\n    describe(\"handleInvokeAgent()\", () => {\n        let mockAgent: {\n            name: string;\n            systemPrompt: string;\n            model: { provider: string; name: string };\n            toolkits: { name: string }[];\n            invoke: jest.Mock;\n        };\n\n        beforeEach(async () => {\n            mockAgent = {\n                name: \"TestAgent\",\n                systemPrompt: \"You are a test agent\",\n                model: { provider: \"openai\", name: \"gpt-4\" },\n                toolkits: [{ name: \"toolkit1\" }],\n                invoke: jest.fn().mockResolvedValue({ threadId: \"thread-123\" }),\n            };\n            const mockApp = {\n                name: \"TestApp\",\n                agents: [mockAgent],\n                toolkits: new Set(),\n            };\n\n            server.accept(mockApp);\n            void server.start();\n            await new Promise((resolve) => setTimeout(resolve, 10));\n            jest.clearAllMocks();\n        });\n\n        it(\"should return error if agent param is missing\", () => {\n            sendRequest({\n                id: \"20\",\n                method: \"invokeAgent\",\n                body: { prompt: \"Hello\" },\n            });\n\n            const response = getLastResponse();\n            expect(response.success).toBe(false);\n            expect(response.errorObj?.code).toBe(\"INVALID_PARAMS\");\n            expect(response.errorObj?.message).toContain(\"'agent'\");\n        });\n\n        it(\"should return error if agent not found\", () => {\n            sendRequest({\n                id: \"21\",\n                method: \"invokeAgent\",\n                body: { agent: \"NonExistentAgent\", prompt: \"Hello\" },\n            });\n\n            const response = getLastResponse();\n            expect(response.success).toBe(false);\n            expect(response.errorObj?.code).toBe(\"NOT_FOUND\");\n            expect(response.errorObj?.message).toContain(\"Agent not found\");\n        });\n\n        it(\"should invoke agent and return thread info on success\", async () => {\n            sendRequest({\n                id: \"22\",\n                method: \"invokeAgent\",\n                body: { agent: \"TestAgent\", prompt: \"Hello, agent!\" },\n            });\n\n            // Wait for async invoke\n            await new Promise((resolve) => setTimeout(resolve, 10));\n\n            expect(mockAgent.invoke).toHaveBeenCalled();\n            const response = getLastResponse();\n            expect(response.id).toBe(\"22\");\n            expect(response.success).toBe(true);\n            expect(response.result).toMatchObject({\n                threadId: \"thread-123\",\n                status: \"invoked\",\n            });\n        });\n\n        it(\"should invoke agent with empty prompt if not provided\", async () => {\n            sendRequest({\n                id: \"23\",\n                method: \"invokeAgent\",\n                body: { agent: \"TestAgent\" },\n            });\n\n            // Wait for async invoke\n            await new Promise((resolve) => setTimeout(resolve, 10));\n\n            expect(mockAgent.invoke).toHaveBeenCalledWith(\n                \"\",\n                undefined,\n                expect.anything(),\n                undefined\n            );\n        });\n\n        it(\"should pass threadId if provided\", async () => {\n            sendRequest({\n                id: \"24\",\n                method: \"invokeAgent\",\n                body: { agent: \"TestAgent\", prompt: \"Continue...\", threadId: \"existing-thread\" },\n            });\n\n            await new Promise((resolve) => setTimeout(resolve, 10));\n\n            expect(mockAgent.invoke).toHaveBeenCalledWith(\n                \"Continue...\",\n                \"existing-thread\",\n                expect.anything(),\n                undefined\n            );\n        });\n\n        it(\"should pass attachments if provided\", async () => {\n            const attachments = [\n                { name: \"test.txt\", content: \"SGVsbG8gV29ybGQ=\", mimeType: \"text/plain\" },\n            ];\n            sendRequest({\n                id: \"25a\",\n                method: \"invokeAgent\",\n                body: { agent: \"TestAgent\", prompt: \"Check this file\", attachments },\n            });\n\n            await new Promise((resolve) => setTimeout(resolve, 10));\n\n            expect(mockAgent.invoke).toHaveBeenCalledWith(\n                \"Check this file\",\n                undefined,\n                expect.anything(),\n                attachments\n            );\n        });\n\n        it(\"should return error on agent invoke failure\", async () => {\n            mockAgent.invoke.mockRejectedValue(new Error(\"Agent failed\"));\n\n            sendRequest({\n                id: \"25\",\n                method: \"invokeAgent\",\n                body: { agent: \"TestAgent\", prompt: \"Hello\" },\n            });\n\n            // Wait for async rejection\n            await new Promise((resolve) => setTimeout(resolve, 10));\n\n            const response = getLastResponse();\n            expect(response.id).toBe(\"25\");\n            expect(response.success).toBe(false);\n            expect(response.errorObj?.code).toBe(\"INTERNAL_ERROR\");\n        });\n\n        it(\"should handle no body at all\", () => {\n            sendRequest({\n                id: \"26\",\n                method: \"invokeAgent\",\n            });\n\n            const response = getLastResponse();\n            expect(response.success).toBe(false);\n            expect(response.errorObj?.code).toBe(\"INVALID_PARAMS\");\n        });\n    });\n\n    describe(\"stop()\", () => {\n        it(\"should stop the server gracefully\", async () => {\n            const mockApp = { name: \"TestApp\", agents: [], toolkits: new Set() };\n            server.accept(mockApp);\n\n            const startPromise = server.start();\n            await new Promise((resolve) => setTimeout(resolve, 10));\n\n            await server.stop();\n\n            // Server should exit the start loop\n            await expect(\n                Promise.race([\n                    startPromise,\n                    new Promise((_, reject) =>\n                        setTimeout(() => reject(new Error(\"Timeout\")), 500)\n                    ),\n                ])\n            ).resolves.toBeUndefined();\n        });\n    });\n\n    describe(\"readline close event\", () => {\n        it(\"should stop running when readline closes\", async () => {\n            const mockApp = { name: \"TestApp\", agents: [], toolkits: new Set() };\n            server.accept(mockApp);\n\n            const startPromise = server.start();\n            await new Promise((resolve) => setTimeout(resolve, 10));\n\n            // Simulate stdin close\n            mockReadlineInterface.emit(\"close\");\n\n            // Server should exit\n            await expect(\n                Promise.race([\n                    startPromise,\n                    new Promise((_, reject) =>\n                        setTimeout(() => reject(new Error(\"Timeout\")), 500)\n                    ),\n                ])\n            ).resolves.toBeUndefined();\n        });\n    });\n});\n"]}