@wingman-ai/gateway 0.5.2 → 0.5.4

package/dist/tests/logger.test.js

@@ -1,347 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { EventLogger, SilentLogger, WingmanLogger, createEventLogger, createLogger, createLoggerFromConfig } from "../logger.js";
-function _define_property(obj, key, value) {
-    if (key in obj) Object.defineProperty(obj, key, {
-        value: value,
-        enumerable: true,
-        configurable: true,
-        writable: true
-    });
-    else obj[key] = value;
-    return obj;
-}
-class MockWriteStream {
-    write(chunk) {
-        this.data += chunk;
-    }
-    constructor(){
-        _define_property(this, "data", "");
-    }
-}
-describe("Logger System", ()=>{
-    describe("WingmanLogger", ()=>{
-        let mockStream;
-        beforeEach(()=>{
-            mockStream = new MockWriteStream();
-        });
-        describe("Log level filtering", ()=>{
-            it("should only log messages at or above configured level", ()=>{
-                const logger = new WingmanLogger("warn", mockStream);
-                logger.debug("debug message");
-                logger.info("info message");
-                logger.warn("warn message");
-                logger.error("error message");
-                expect(mockStream.data).not.toContain("debug message");
-                expect(mockStream.data).not.toContain("info message");
-                expect(mockStream.data).toContain("warn message");
-                expect(mockStream.data).toContain("error message");
-            });
-            it("should log all messages when level is debug", ()=>{
-                const logger = new WingmanLogger("debug", mockStream);
-                logger.debug("debug message");
-                logger.info("info message");
-                logger.warn("warn message");
-                logger.error("error message");
-                expect(mockStream.data).toContain("debug message");
-                expect(mockStream.data).toContain("info message");
-                expect(mockStream.data).toContain("warn message");
-                expect(mockStream.data).toContain("error message");
-            });
-            it("should not log any messages when level is silent", ()=>{
-                const logger = new WingmanLogger("silent", mockStream);
-                logger.debug("debug message");
-                logger.info("info message");
-                logger.warn("warn message");
-                logger.error("error message");
-                expect(mockStream.data).toBe("");
-            });
-        });
-        describe("Log formatting", ()=>{
-            it("should include timestamp and level in log output", ()=>{
-                const logger = new WingmanLogger("info", mockStream);
-                logger.info("test message");
-                expect(mockStream.data).toMatch(/\[\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/);
-                expect(mockStream.data).toContain("[INFO]");
-                expect(mockStream.data).toContain("test message");
-            });
-            it("should serialize additional arguments as JSON", ()=>{
-                const logger = new WingmanLogger("info", mockStream);
-                logger.info("test message", {
-                    key: "value"
-                }, [
-                    1,
-                    2,
-                    3
-                ]);
-                expect(mockStream.data).toContain("test message");
-                expect(mockStream.data).toContain('"key"');
-                expect(mockStream.data).toContain('"value"');
-            });
-            it("should serialize error arguments with message and stack", ()=>{
-                const logger = new WingmanLogger("info", mockStream);
-                const err = new Error("boom");
-                logger.error("test error", err);
-                expect(mockStream.data).toContain("test error");
-                expect(mockStream.data).toContain('"message"');
-                expect(mockStream.data).toContain("boom");
-            });
-            it("should not include args when none provided", ()=>{
-                const logger = new WingmanLogger("info", mockStream);
-                logger.info("test message");
-                const lines = mockStream.data.split("\n");
-                expect(lines.filter((l)=>l.trim()).length).toBe(1);
-            });
-        });
-        describe("Log levels", ()=>{
-            it("should have debug method", ()=>{
-                const logger = new WingmanLogger("debug", mockStream);
-                expect(logger.debug).toBeDefined();
-                expect(typeof logger.debug).toBe("function");
-            });
-            it("should have info method", ()=>{
-                const logger = new WingmanLogger("info", mockStream);
-                expect(logger.info).toBeDefined();
-                expect(typeof logger.info).toBe("function");
-            });
-            it("should have warn method", ()=>{
-                const logger = new WingmanLogger("warn", mockStream);
-                expect(logger.warn).toBeDefined();
-                expect(typeof logger.warn).toBe("function");
-            });
-            it("should have error method", ()=>{
-                const logger = new WingmanLogger("error", mockStream);
-                expect(logger.error).toBeDefined();
-                expect(typeof logger.error).toBe("function");
-            });
-        });
-    });
-    describe("SilentLogger", ()=>{
-        it("should not log any messages", ()=>{
-            const logger = new SilentLogger();
-            const consoleSpy = vi.spyOn(console, "log");
-            logger.debug();
-            logger.info();
-            logger.warn();
-            logger.error();
-            expect(consoleSpy).not.toHaveBeenCalled();
-            consoleSpy.mockRestore();
-        });
-        it("should have all required logger methods", ()=>{
-            const logger = new SilentLogger();
-            expect(logger.debug).toBeDefined();
-            expect(logger.info).toBeDefined();
-            expect(logger.warn).toBeDefined();
-            expect(logger.error).toBeDefined();
-        });
-    });
-    describe("EventLogger", ()=>{
-        let mockCallback;
-        beforeEach(()=>{
-            mockCallback = vi.fn();
-        });
-        describe("Event emission", ()=>{
-            it("should emit log events with correct structure", ()=>{
-                const logger = new EventLogger(mockCallback, "info");
-                logger.info("test message");
-                expect(mockCallback).toHaveBeenCalledTimes(1);
-                expect(mockCallback).toHaveBeenCalledWith({
-                    level: "info",
-                    message: "test message",
-                    timestamp: expect.stringMatching(/\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/),
-                    args: void 0
-                });
-            });
-            it("should include args in events when provided", ()=>{
-                const logger = new EventLogger(mockCallback, "info");
-                const testArgs = [
-                    {
-                        key: "value"
-                    },
-                    [
-                        1,
-                        2,
-                        3
-                    ]
-                ];
-                logger.info("test message", ...testArgs);
-                expect(mockCallback).toHaveBeenCalledWith({
-                    level: "info",
-                    message: "test message",
-                    timestamp: expect.any(String),
-                    args: testArgs
-                });
-            });
-        });
-        describe("Level filtering", ()=>{
-            it("should respect log level filtering", ()=>{
-                const logger = new EventLogger(mockCallback, "warn");
-                logger.debug("debug");
-                logger.info("info");
-                logger.warn("warn");
-                logger.error("error");
-                expect(mockCallback).toHaveBeenCalledTimes(2);
-                expect(mockCallback).toHaveBeenCalledWith(expect.objectContaining({
-                    level: "warn"
-                }));
-                expect(mockCallback).toHaveBeenCalledWith(expect.objectContaining({
-                    level: "error"
-                }));
-            });
-            it("should not emit events when level is silent", ()=>{
-                const logger = new EventLogger(mockCallback, "silent");
-                logger.debug("debug");
-                logger.info("info");
-                logger.warn("warn");
-                logger.error("error");
-                expect(mockCallback).not.toHaveBeenCalled();
-            });
-        });
-        describe("All log levels", ()=>{
-            it("should handle debug level", ()=>{
-                const logger = new EventLogger(mockCallback, "debug");
-                logger.debug("debug message");
-                expect(mockCallback).toHaveBeenCalledWith(expect.objectContaining({
-                    level: "debug",
-                    message: "debug message"
-                }));
-            });
-            it("should handle info level", ()=>{
-                const logger = new EventLogger(mockCallback, "info");
-                logger.info("info message");
-                expect(mockCallback).toHaveBeenCalledWith(expect.objectContaining({
-                    level: "info",
-                    message: "info message"
-                }));
-            });
-            it("should handle warn level", ()=>{
-                const logger = new EventLogger(mockCallback, "info");
-                logger.warn("warn message");
-                expect(mockCallback).toHaveBeenCalledWith(expect.objectContaining({
-                    level: "warn",
-                    message: "warn message"
-                }));
-            });
-            it("should handle error level", ()=>{
-                const logger = new EventLogger(mockCallback, "info");
-                logger.error("error message");
-                expect(mockCallback).toHaveBeenCalledWith(expect.objectContaining({
-                    level: "error",
-                    message: "error message"
-                }));
-            });
-        });
-    });
-    describe("Factory functions", ()=>{
-        describe("createLogger", ()=>{
-            const originalEnv = process.env.WINGMAN_LOG_LEVEL;
-            afterEach(()=>{
-                process.env.WINGMAN_LOG_LEVEL = originalEnv;
-            });
-            it("should create WingmanLogger by default", ()=>{
-                const logger = createLogger("info");
-                expect(logger).toBeInstanceOf(WingmanLogger);
-            });
-            it("should create SilentLogger when level is silent", ()=>{
-                const logger = createLogger("silent");
-                expect(logger).toBeInstanceOf(SilentLogger);
-            });
-            it("should use WINGMAN_LOG_LEVEL env var when no level provided", ()=>{
-                process.env.WINGMAN_LOG_LEVEL = "debug";
-                const logger = createLogger();
-                expect(logger).toBeInstanceOf(WingmanLogger);
-            });
-            it("should default to info level when env var not set", ()=>{
-                delete process.env.WINGMAN_LOG_LEVEL;
-                const logger = createLogger();
-                expect(logger).toBeInstanceOf(WingmanLogger);
-            });
-        });
-        describe("createEventLogger", ()=>{
-            it("should create EventLogger with callback", ()=>{
-                const callback = vi.fn();
-                const logger = createEventLogger(callback, "info");
-                expect(logger).toBeInstanceOf(EventLogger);
-            });
-            it("should create EventLogger with default info level", ()=>{
-                const callback = vi.fn();
-                const logger = createEventLogger(callback);
-                logger.info("test");
-                expect(callback).toHaveBeenCalledWith(expect.objectContaining({
-                    level: "info"
-                }));
-            });
-        });
-        describe("createLoggerFromConfig", ()=>{
-            it("should create logger from serializable config", ()=>{
-                const logger = createLoggerFromConfig({
-                    level: "debug"
-                });
-                expect(logger).toBeInstanceOf(WingmanLogger);
-            });
-            it("should create silent logger from silent config", ()=>{
-                const logger = createLoggerFromConfig({
-                    level: "silent"
-                });
-                expect(logger).toBeInstanceOf(SilentLogger);
-            });
-        });
-    });
-    describe("Log level hierarchy", ()=>{
-        it("should respect level hierarchy: debug < info < warn < error", ()=>{
-            const testCases = [
-                {
-                    level: "debug",
-                    shouldLog: {
-                        debug: true,
-                        info: true,
-                        warn: true,
-                        error: true
-                    }
-                },
-                {
-                    level: "info",
-                    shouldLog: {
-                        debug: false,
-                        info: true,
-                        warn: true,
-                        error: true
-                    }
-                },
-                {
-                    level: "warn",
-                    shouldLog: {
-                        debug: false,
-                        info: false,
-                        warn: true,
-                        error: true
-                    }
-                },
-                {
-                    level: "error",
-                    shouldLog: {
-                        debug: false,
-                        info: false,
-                        warn: false,
-                        error: true
-                    }
-                }
-            ];
-            for (const testCase of testCases){
-                const callback = vi.fn();
-                const logger = new EventLogger(callback, testCase.level);
-                logger.debug("debug");
-                logger.info("info");
-                logger.warn("warn");
-                logger.error("error");
-                const debugCalls = callback.mock.calls.filter(([event])=>"debug" === event.level).length;
-                const infoCalls = callback.mock.calls.filter(([event])=>"info" === event.level).length;
-                const warnCalls = callback.mock.calls.filter(([event])=>"warn" === event.level).length;
-                const errorCalls = callback.mock.calls.filter(([event])=>"error" === event.level).length;
-                expect(debugCalls).toBe(testCase.shouldLog.debug ? 1 : 0);
-                expect(infoCalls).toBe(testCase.shouldLog.info ? 1 : 0);
-                expect(warnCalls).toBe(testCase.shouldLog.warn ? 1 : 0);
-                expect(errorCalls).toBe(testCase.shouldLog.error ? 1 : 0);
-            }
-        });
-    });
-});

package/dist/tests/mediaCompatibilityMiddleware.test.cjs

@@ -1,106 +0,0 @@
-"use strict";
-var __webpack_exports__ = {};
-const external_vitest_namespaceObject = require("vitest");
-const media_compat_cjs_namespaceObject = require("../agent/middleware/media-compat.cjs");
-async function runBeforeAgent(middleware, input) {
-    const beforeAgent = "function" == typeof middleware.beforeAgent ? middleware.beforeAgent : middleware.beforeAgent?.hook;
-    if (!beforeAgent) throw new Error("beforeAgent hook not configured");
-    return await beforeAgent(input, {});
-}
-(0, external_vitest_namespaceObject.describe)("mediaCompatibilityMiddleware", ()=>{
-    (0, external_vitest_namespaceObject.it)("strips audio blocks for Anthropic models and preserves other blocks", async ()=>{
-        const middleware = (0, media_compat_cjs_namespaceObject.mediaCompatibilityMiddleware)({
-            model: {
-                constructor: {
-                    name: "ChatAnthropic"
-                }
-            }
-        });
-        const input = {
-            messages: [
-                {
-                    content: [
-                        {
-                            type: "text",
-                            text: "Hello"
-                        },
-                        {
-                            type: "audio",
-                            source_type: "base64",
-                            data: "abc"
-                        }
-                    ]
-                }
-            ]
-        };
-        const result = await runBeforeAgent(middleware, input);
-        const content = result.messages[0]?.content;
-        (0, external_vitest_namespaceObject.expect)(Array.isArray(content)).toBe(true);
-        (0, external_vitest_namespaceObject.expect)(content).toHaveLength(1);
-        (0, external_vitest_namespaceObject.expect)(content[0]?.type).toBe("text");
-    });
-    (0, external_vitest_namespaceObject.it)("replaces content with a placeholder when only audio blocks remain", async ()=>{
-        const middleware = (0, media_compat_cjs_namespaceObject.mediaCompatibilityMiddleware)({
-            model: {
-                constructor: {
-                    name: "ChatAnthropic"
-                }
-            }
-        });
-        const input = {
-            messages: [
-                {
-                    content: [
-                        {
-                            type: "audio_url",
-                            audio_url: {
-                                url: "https://x/y"
-                            }
-                        }
-                    ]
-                }
-            ]
-        };
-        const result = await runBeforeAgent(middleware, input);
-        const content = result.messages[0]?.content;
-        (0, external_vitest_namespaceObject.expect)(typeof content).toBe("string");
-        (0, external_vitest_namespaceObject.expect)(content).toContain("Audio omitted");
-    });
-    (0, external_vitest_namespaceObject.it)("leaves audio blocks untouched for non-Anthropic models", async ()=>{
-        const middleware = (0, media_compat_cjs_namespaceObject.mediaCompatibilityMiddleware)({
-            model: {
-                constructor: {
-                    name: "ChatOpenAI"
-                }
-            }
-        });
-        const input = {
-            messages: [
-                {
-                    content: [
-                        {
-                            type: "text",
-                            text: "Hello"
-                        },
-                        {
-                            type: "input_audio",
-                            input_audio: {
-                                data: "abc",
-                                format: "wav"
-                            }
-                        }
-                    ]
-                }
-            ]
-        };
-        const result = await runBeforeAgent(middleware, input);
-        const content = result.messages[0]?.content;
-        (0, external_vitest_namespaceObject.expect)(Array.isArray(content)).toBe(true);
-        (0, external_vitest_namespaceObject.expect)(content).toHaveLength(2);
-        (0, external_vitest_namespaceObject.expect)(content[1]?.type).toBe("input_audio");
-    });
-});
-for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
-Object.defineProperty(exports, '__esModule', {
-    value: true
-});

package/dist/tests/mediaCompatibilityMiddleware.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/tests/mediaCompatibilityMiddleware.test.js

@@ -1,100 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { mediaCompatibilityMiddleware } from "../agent/middleware/media-compat.js";
-async function runBeforeAgent(middleware, input) {
-    const beforeAgent = "function" == typeof middleware.beforeAgent ? middleware.beforeAgent : middleware.beforeAgent?.hook;
-    if (!beforeAgent) throw new Error("beforeAgent hook not configured");
-    return await beforeAgent(input, {});
-}
-describe("mediaCompatibilityMiddleware", ()=>{
-    it("strips audio blocks for Anthropic models and preserves other blocks", async ()=>{
-        const middleware = mediaCompatibilityMiddleware({
-            model: {
-                constructor: {
-                    name: "ChatAnthropic"
-                }
-            }
-        });
-        const input = {
-            messages: [
-                {
-                    content: [
-                        {
-                            type: "text",
-                            text: "Hello"
-                        },
-                        {
-                            type: "audio",
-                            source_type: "base64",
-                            data: "abc"
-                        }
-                    ]
-                }
-            ]
-        };
-        const result = await runBeforeAgent(middleware, input);
-        const content = result.messages[0]?.content;
-        expect(Array.isArray(content)).toBe(true);
-        expect(content).toHaveLength(1);
-        expect(content[0]?.type).toBe("text");
-    });
-    it("replaces content with a placeholder when only audio blocks remain", async ()=>{
-        const middleware = mediaCompatibilityMiddleware({
-            model: {
-                constructor: {
-                    name: "ChatAnthropic"
-                }
-            }
-        });
-        const input = {
-            messages: [
-                {
-                    content: [
-                        {
-                            type: "audio_url",
-                            audio_url: {
-                                url: "https://x/y"
-                            }
-                        }
-                    ]
-                }
-            ]
-        };
-        const result = await runBeforeAgent(middleware, input);
-        const content = result.messages[0]?.content;
-        expect(typeof content).toBe("string");
-        expect(content).toContain("Audio omitted");
-    });
-    it("leaves audio blocks untouched for non-Anthropic models", async ()=>{
-        const middleware = mediaCompatibilityMiddleware({
-            model: {
-                constructor: {
-                    name: "ChatOpenAI"
-                }
-            }
-        });
-        const input = {
-            messages: [
-                {
-                    content: [
-                        {
-                            type: "text",
-                            text: "Hello"
-                        },
-                        {
-                            type: "input_audio",
-                            input_audio: {
-                                data: "abc",
-                                format: "wav"
-                            }
-                        }
-                    ]
-                }
-            ]
-        };
-        const result = await runBeforeAgent(middleware, input);
-        const content = result.messages[0]?.content;
-        expect(Array.isArray(content)).toBe(true);
-        expect(content).toHaveLength(2);
-        expect(content[1]?.type).toBe("input_audio");
-    });
-});

package/dist/tests/node-tools.test.cjs

@@ -1,77 +0,0 @@
-"use strict";
-var __webpack_exports__ = {};
-const external_vitest_namespaceObject = require("vitest");
-const toolRegistry_cjs_namespaceObject = require("../agent/config/toolRegistry.cjs");
-const node_invoke_cjs_namespaceObject = require("../agent/tools/node_invoke.cjs");
-(0, external_vitest_namespaceObject.describe)("node tools", ()=>{
-    (0, external_vitest_namespaceObject.it)("exposes node tools in available tool names", ()=>{
-        const tools = (0, toolRegistry_cjs_namespaceObject.getAvailableTools)();
-        (0, external_vitest_namespaceObject.expect)(tools).toContain("node_notify");
-        (0, external_vitest_namespaceObject.expect)(tools).toContain("node_run");
-    });
-    (0, external_vitest_namespaceObject.it)("routes node_notify through the injected node invoker", async ()=>{
-        const nodeInvoker = external_vitest_namespaceObject.vi.fn(async ()=>({
-                nodeId: "node-123",
-                payload: {
-                    delivered: true
-                }
-            }));
-        const tool = (0, node_invoke_cjs_namespaceObject.createNodeNotifyTool)({
-            nodeInvoker,
-            defaultTargetClientId: "desktop-abc"
-        });
-        const result = await tool.invoke({
-            body: "Build finished"
-        });
-        (0, external_vitest_namespaceObject.expect)(result.ok).toBe(true);
-        (0, external_vitest_namespaceObject.expect)(result.nodeId).toBe("node-123");
-        (0, external_vitest_namespaceObject.expect)(result.delivered).toBe(true);
-        (0, external_vitest_namespaceObject.expect)(nodeInvoker).toHaveBeenCalledWith(external_vitest_namespaceObject.expect.objectContaining({
-            tool: "system.notify",
-            targetClientId: "desktop-abc"
-        }));
-    });
-    (0, external_vitest_namespaceObject.it)("returns command result fields from node_run", async ()=>{
-        const nodeInvoker = external_vitest_namespaceObject.vi.fn(async ()=>({
-                nodeId: "node-789",
-                payload: {
-                    exitCode: 0,
-                    stdout: "ok",
-                    stderr: ""
-                }
-            }));
-        const tool = (0, node_invoke_cjs_namespaceObject.createNodeRunTool)({
-            nodeInvoker
-        });
-        const result = await tool.invoke({
-            command: "/bin/echo",
-            args: [
-                "hello"
-            ],
-            target: {
-                nodeId: "node-789"
-            }
-        });
-        (0, external_vitest_namespaceObject.expect)(result.ok).toBe(true);
-        (0, external_vitest_namespaceObject.expect)(result.nodeId).toBe("node-789");
-        (0, external_vitest_namespaceObject.expect)(result.exitCode).toBe(0);
-        (0, external_vitest_namespaceObject.expect)(result.stdout).toBe("ok");
-        (0, external_vitest_namespaceObject.expect)(result.stderr).toBe("");
-        (0, external_vitest_namespaceObject.expect)(nodeInvoker).toHaveBeenCalledWith(external_vitest_namespaceObject.expect.objectContaining({
-            tool: "system.run",
-            targetNodeId: "node-789"
-        }));
-    });
-    (0, external_vitest_namespaceObject.it)("returns an availability error outside gateway runtime", async ()=>{
-        const tool = (0, node_invoke_cjs_namespaceObject.createNodeRunTool)();
-        const result = await tool.invoke({
-            command: "pwd"
-        });
-        (0, external_vitest_namespaceObject.expect)(result.ok).toBe(false);
-        (0, external_vitest_namespaceObject.expect)(result.error).toContain("only available");
-    });
-});
-for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
-Object.defineProperty(exports, '__esModule', {
-    value: true
-});

package/dist/tests/node-tools.test.d.ts

@@ -1 +0,0 @@
-export {};