@wingman-ai/gateway 0.1.0

package/dist/tests/logger.test.js

@@ -0,0 +1,347 @@
+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

@@ -0,0 +1,106 @@
+"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

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

package/dist/tests/mediaCompatibilityMiddleware.test.js

@@ -0,0 +1,100 @@
+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/routines-api.test.cjs

@@ -0,0 +1,107 @@
+"use strict";
+var __webpack_exports__ = {};
+const external_vitest_namespaceObject = require("vitest");
+const routines_cjs_namespaceObject = require("../gateway/http/routines.cjs");
+const external_node_fs_namespaceObject = require("node:fs");
+const external_node_os_namespaceObject = require("node:os");
+const external_node_path_namespaceObject = require("node:path");
+const isBunRuntime = void 0 !== globalThis.Bun;
+const describeIfBun = isBunRuntime ? external_vitest_namespaceObject.describe : external_vitest_namespaceObject.describe.skip;
+describeIfBun("routines API", ()=>{
+    let tempDir;
+    (0, external_vitest_namespaceObject.beforeEach)(()=>{
+        tempDir = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-routines-"));
+        const agentDir = (0, external_node_path_namespaceObject.join)(tempDir, "agents", "main");
+        (0, external_node_fs_namespaceObject.mkdirSync)(agentDir, {
+            recursive: true
+        });
+        (0, external_node_fs_namespaceObject.writeFileSync)((0, external_node_path_namespaceObject.join)(agentDir, "agent.json"), JSON.stringify({
+            name: "main",
+            description: "Main agent",
+            systemPrompt: "You are the main agent"
+        }, null, 2));
+    });
+    (0, external_vitest_namespaceObject.afterEach)(()=>{
+        (0, external_node_fs_namespaceObject.rmSync)(tempDir, {
+            recursive: true,
+            force: true
+        });
+    });
+    (0, external_vitest_namespaceObject.it)("creates, lists, and deletes routines", async ()=>{
+        const ctx = {
+            configDir: tempDir,
+            workspace: tempDir,
+            getWingmanConfig: ()=>({}),
+            getSessionManager: async ()=>{
+                throw new Error("SessionManager not used in this test");
+            }
+        };
+        const store = (0, routines_cjs_namespaceObject.createRoutineStore)(()=>tempDir);
+        const createReq = new Request("http://localhost/api/routines", {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+                name: "Daily Check-in",
+                agentId: "main",
+                cron: "0 9 * * *",
+                prompt: "Summarize today's tasks.",
+                enabled: true
+            })
+        });
+        const createRes = await (0, routines_cjs_namespaceObject.handleRoutinesApi)(ctx, store, createReq, new URL(createReq.url));
+        (0, external_vitest_namespaceObject.expect)(createRes).not.toBeNull();
+        (0, external_vitest_namespaceObject.expect)(createRes?.ok).toBe(true);
+        const created = await createRes.json();
+        (0, external_vitest_namespaceObject.expect)(created.id).toMatch(/^routine-/);
+        const listReq = new Request("http://localhost/api/routines", {
+            method: "GET"
+        });
+        const listRes = await (0, routines_cjs_namespaceObject.handleRoutinesApi)(ctx, store, listReq, new URL(listReq.url));
+        (0, external_vitest_namespaceObject.expect)(listRes).not.toBeNull();
+        const list = await listRes.json();
+        (0, external_vitest_namespaceObject.expect)(list).toHaveLength(1);
+        (0, external_vitest_namespaceObject.expect)(list[0].id).toBe(created.id);
+        const deleteReq = new Request(`http://localhost/api/routines/${encodeURIComponent(created.id)}`, {
+            method: "DELETE"
+        });
+        const deleteRes = await (0, routines_cjs_namespaceObject.handleRoutinesApi)(ctx, store, deleteReq, new URL(deleteReq.url));
+        (0, external_vitest_namespaceObject.expect)(deleteRes).not.toBeNull();
+        (0, external_vitest_namespaceObject.expect)(deleteRes?.ok).toBe(true);
+        const listResAfter = await (0, routines_cjs_namespaceObject.handleRoutinesApi)(ctx, store, listReq, new URL(listReq.url));
+        const listAfter = await listResAfter.json();
+        (0, external_vitest_namespaceObject.expect)(listAfter).toHaveLength(0);
+    });
+    (0, external_vitest_namespaceObject.it)("rejects invalid cron expressions", async ()=>{
+        const ctx = {
+            configDir: tempDir,
+            workspace: tempDir,
+            getWingmanConfig: ()=>({}),
+            getSessionManager: async ()=>{
+                throw new Error("SessionManager not used in this test");
+            }
+        };
+        const store = (0, routines_cjs_namespaceObject.createRoutineStore)(()=>tempDir);
+        const createReq = new Request("http://localhost/api/routines", {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+                name: "Invalid Cron",
+                agentId: "main",
+                cron: "bad cron",
+                prompt: "Hello",
+                enabled: true
+            })
+        });
+        const createRes = await (0, routines_cjs_namespaceObject.handleRoutinesApi)(ctx, store, createReq, new URL(createReq.url));
+        (0, external_vitest_namespaceObject.expect)(createRes).not.toBeNull();
+        (0, external_vitest_namespaceObject.expect)(createRes?.status).toBe(400);
+    });
+});
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/tests/routines-api.test.d.ts

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