@wingman-ai/gateway 0.1.0

package/dist/providers/registry.cjs

@@ -0,0 +1,138 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    getProviderSpec: ()=>getProviderSpec,
+    listProviderSpecs: ()=>listProviderSpecs,
+    normalizeProviderName: ()=>normalizeProviderName
+});
+const PROVIDERS = {
+    anthropic: {
+        name: "anthropic",
+        label: "Anthropic",
+        type: "api-key",
+        envVars: [
+            "ANTHROPIC_API_KEY"
+        ],
+        category: "model"
+    },
+    openai: {
+        name: "openai",
+        label: "OpenAI",
+        type: "api-key",
+        envVars: [
+            "OPENAI_API_KEY"
+        ],
+        category: "model"
+    },
+    openrouter: {
+        name: "openrouter",
+        label: "OpenRouter",
+        type: "api-key",
+        envVars: [
+            "OPENROUTER_API_KEY"
+        ],
+        baseURL: "https://openrouter.ai/api/v1",
+        category: "model"
+    },
+    copilot: {
+        name: "copilot",
+        label: "GitHub Copilot",
+        type: "api-key",
+        envVars: [
+            "GITHUB_COPILOT_TOKEN",
+            "COPILOT_TOKEN",
+            "COPILOT_API_KEY"
+        ],
+        baseURL: "https://api.githubcopilot.com",
+        category: "model"
+    },
+    xai: {
+        name: "xai",
+        label: "xAI",
+        type: "api-key",
+        envVars: [
+            "XAI_API_KEY"
+        ],
+        category: "model"
+    },
+    lmstudio: {
+        name: "lmstudio",
+        label: "LM Studio",
+        type: "api-key",
+        envVars: [
+            "LMSTUDIO_API_KEY",
+            "LM_STUDIO_API_KEY"
+        ],
+        baseURL: "http://localhost:1234/v1",
+        requiresAuth: false,
+        category: "model"
+    },
+    ollama: {
+        name: "ollama",
+        label: "Ollama",
+        type: "api-key",
+        envVars: [
+            "OLLAMA_API_KEY"
+        ],
+        baseURL: "http://localhost:11434/v1",
+        requiresAuth: false,
+        category: "model"
+    },
+    elevenlabs: {
+        name: "elevenlabs",
+        label: "ElevenLabs",
+        type: "api-key",
+        envVars: [
+            "ELEVENLABS_API_KEY",
+            "XI_API_KEY"
+        ],
+        category: "voice"
+    }
+};
+function normalizeProviderName(provider) {
+    const key = provider.trim().toLowerCase();
+    return PROVIDERS[key] ? key : void 0;
+}
+function getProviderSpec(provider) {
+    const normalized = normalizeProviderName(provider);
+    return normalized ? PROVIDERS[normalized] : void 0;
+}
+function listProviderSpecs(category) {
+    const providers = Object.values(PROVIDERS);
+    if (!category) return providers;
+    return providers.filter((provider)=>provider.category === category);
+}
+exports.getProviderSpec = __webpack_exports__.getProviderSpec;
+exports.listProviderSpecs = __webpack_exports__.listProviderSpecs;
+exports.normalizeProviderName = __webpack_exports__.normalizeProviderName;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "getProviderSpec",
+    "listProviderSpecs",
+    "normalizeProviderName"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/providers/registry.d.ts

@@ -0,0 +1,32 @@
+export type ProviderAuthType = "api-key" | "oauth";
+export type ProviderCategory = "model" | "voice";
+export type ProviderName = "anthropic" | "openai" | "openrouter" | "copilot" | "xai" | "lmstudio" | "ollama" | "elevenlabs";
+export interface ProviderOAuthConfig {
+    authorizationUrl: string;
+    tokenUrl: string;
+    scopes?: string[];
+    clientIdEnv: string[];
+    clientSecretEnv?: string[];
+    defaultClientId?: string;
+    defaultClientSecret?: string;
+    scopeSeparator?: string;
+    redirectPath?: string;
+    tokenResponseType?: "json" | "form";
+    usePkce?: boolean;
+    authorizationParams?: Record<string, string>;
+    tokenParams?: Record<string, string>;
+    tokenHeaders?: Record<string, string>;
+}
+export interface ProviderSpec {
+    name: ProviderName;
+    label: string;
+    type: ProviderAuthType;
+    envVars: string[];
+    category: ProviderCategory;
+    baseURL?: string;
+    oauth?: ProviderOAuthConfig;
+    requiresAuth?: boolean;
+}
+export declare function normalizeProviderName(provider: string): ProviderName | undefined;
+export declare function getProviderSpec(provider: string): ProviderSpec | undefined;
+export declare function listProviderSpecs(category?: ProviderCategory): ProviderSpec[];

package/dist/providers/registry.js

@@ -0,0 +1,98 @@
+const PROVIDERS = {
+    anthropic: {
+        name: "anthropic",
+        label: "Anthropic",
+        type: "api-key",
+        envVars: [
+            "ANTHROPIC_API_KEY"
+        ],
+        category: "model"
+    },
+    openai: {
+        name: "openai",
+        label: "OpenAI",
+        type: "api-key",
+        envVars: [
+            "OPENAI_API_KEY"
+        ],
+        category: "model"
+    },
+    openrouter: {
+        name: "openrouter",
+        label: "OpenRouter",
+        type: "api-key",
+        envVars: [
+            "OPENROUTER_API_KEY"
+        ],
+        baseURL: "https://openrouter.ai/api/v1",
+        category: "model"
+    },
+    copilot: {
+        name: "copilot",
+        label: "GitHub Copilot",
+        type: "api-key",
+        envVars: [
+            "GITHUB_COPILOT_TOKEN",
+            "COPILOT_TOKEN",
+            "COPILOT_API_KEY"
+        ],
+        baseURL: "https://api.githubcopilot.com",
+        category: "model"
+    },
+    xai: {
+        name: "xai",
+        label: "xAI",
+        type: "api-key",
+        envVars: [
+            "XAI_API_KEY"
+        ],
+        category: "model"
+    },
+    lmstudio: {
+        name: "lmstudio",
+        label: "LM Studio",
+        type: "api-key",
+        envVars: [
+            "LMSTUDIO_API_KEY",
+            "LM_STUDIO_API_KEY"
+        ],
+        baseURL: "http://localhost:1234/v1",
+        requiresAuth: false,
+        category: "model"
+    },
+    ollama: {
+        name: "ollama",
+        label: "Ollama",
+        type: "api-key",
+        envVars: [
+            "OLLAMA_API_KEY"
+        ],
+        baseURL: "http://localhost:11434/v1",
+        requiresAuth: false,
+        category: "model"
+    },
+    elevenlabs: {
+        name: "elevenlabs",
+        label: "ElevenLabs",
+        type: "api-key",
+        envVars: [
+            "ELEVENLABS_API_KEY",
+            "XI_API_KEY"
+        ],
+        category: "voice"
+    }
+};
+function normalizeProviderName(provider) {
+    const key = provider.trim().toLowerCase();
+    return PROVIDERS[key] ? key : void 0;
+}
+function getProviderSpec(provider) {
+    const normalized = normalizeProviderName(provider);
+    return normalized ? PROVIDERS[normalized] : void 0;
+}
+function listProviderSpecs(category) {
+    const providers = Object.values(PROVIDERS);
+    if (!category) return providers;
+    return providers.filter((provider)=>provider.category === category);
+}
+export { getProviderSpec, listProviderSpecs, normalizeProviderName };

package/dist/tests/additionalMessageMiddleware.test.cjs

@@ -0,0 +1,45 @@
+"use strict";
+var __webpack_exports__ = {};
+const external_vitest_namespaceObject = require("vitest");
+const external_langchain_namespaceObject = require("langchain");
+const additional_messages_cjs_namespaceObject = require("../agent/middleware/additional-messages.cjs");
+(0, external_vitest_namespaceObject.describe)("additionalMessageMiddleware", ()=>{
+    (0, external_vitest_namespaceObject.it)("injects the additional message when missing", async ()=>{
+        const middleware = (0, additional_messages_cjs_namespaceObject.additionalMessageMiddleware)();
+        const input = {
+            messages: [
+                new external_langchain_namespaceObject.HumanMessage("Hello")
+            ]
+        };
+        const beforeAgent = "function" == typeof middleware.beforeAgent ? middleware.beforeAgent : middleware.beforeAgent?.hook;
+        if (!beforeAgent) throw new Error("beforeAgent hook not configured");
+        const result = await beforeAgent(input, {});
+        (0, external_vitest_namespaceObject.expect)(result.messages).toHaveLength(2);
+        const injected = result.messages[0];
+        (0, external_vitest_namespaceObject.expect)(injected.additional_kwargs?.source).toBe("additional-message-middleware");
+    });
+    (0, external_vitest_namespaceObject.it)("does not inject the additional message twice", async ()=>{
+        const middleware = (0, additional_messages_cjs_namespaceObject.additionalMessageMiddleware)();
+        const input = {
+            messages: [
+                new external_langchain_namespaceObject.HumanMessage("Hello")
+            ]
+        };
+        const beforeAgent = "function" == typeof middleware.beforeAgent ? middleware.beforeAgent : middleware.beforeAgent?.hook;
+        if (!beforeAgent) throw new Error("beforeAgent hook not configured");
+        const first = await beforeAgent(input, {});
+        const second = await beforeAgent({
+            messages: first.messages
+        }, {});
+        const messages = second.messages;
+        const injectedCount = messages.filter((message)=>{
+            const source = message.additional_kwargs?.source;
+            return "additional-message-middleware" === source;
+        }).length;
+        (0, external_vitest_namespaceObject.expect)(injectedCount).toBe(1);
+    });
+});
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

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

package/dist/tests/additionalMessageMiddleware.test.js

@@ -0,0 +1,39 @@
+import { describe, expect, it } from "vitest";
+import { HumanMessage } from "langchain";
+import { additionalMessageMiddleware } from "../agent/middleware/additional-messages.js";
+describe("additionalMessageMiddleware", ()=>{
+    it("injects the additional message when missing", async ()=>{
+        const middleware = additionalMessageMiddleware();
+        const input = {
+            messages: [
+                new HumanMessage("Hello")
+            ]
+        };
+        const beforeAgent = "function" == typeof middleware.beforeAgent ? middleware.beforeAgent : middleware.beforeAgent?.hook;
+        if (!beforeAgent) throw new Error("beforeAgent hook not configured");
+        const result = await beforeAgent(input, {});
+        expect(result.messages).toHaveLength(2);
+        const injected = result.messages[0];
+        expect(injected.additional_kwargs?.source).toBe("additional-message-middleware");
+    });
+    it("does not inject the additional message twice", async ()=>{
+        const middleware = additionalMessageMiddleware();
+        const input = {
+            messages: [
+                new HumanMessage("Hello")
+            ]
+        };
+        const beforeAgent = "function" == typeof middleware.beforeAgent ? middleware.beforeAgent : middleware.beforeAgent?.hook;
+        if (!beforeAgent) throw new Error("beforeAgent hook not configured");
+        const first = await beforeAgent(input, {});
+        const second = await beforeAgent({
+            messages: first.messages
+        }, {});
+        const messages = second.messages;
+        const injectedCount = messages.filter((message)=>{
+            const source = message.additional_kwargs?.source;
+            return "additional-message-middleware" === source;
+        }).length;
+        expect(injectedCount).toBe(1);
+    });
+});

package/dist/tests/agent-config-voice.test.cjs

@@ -0,0 +1,25 @@
+"use strict";
+var __webpack_exports__ = {};
+const external_vitest_namespaceObject = require("vitest");
+const agentConfig_cjs_namespaceObject = require("../agent/config/agentConfig.cjs");
+(0, external_vitest_namespaceObject.describe)("Agent config voice settings", ()=>{
+    (0, external_vitest_namespaceObject.it)("accepts voice configuration in agent config", ()=>{
+        const result = (0, agentConfig_cjs_namespaceObject.validateAgentConfig)({
+            name: "voice-agent",
+            description: "Tests voice settings.",
+            systemPrompt: "Respond clearly.",
+            voice: {
+                provider: "elevenlabs",
+                elevenlabs: {
+                    voiceId: "voice-123",
+                    stability: 0.4
+                }
+            }
+        });
+        (0, external_vitest_namespaceObject.expect)(result.success).toBe(true);
+    });
+});
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/tests/agent-config-voice.test.d.ts

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

package/dist/tests/agent-config-voice.test.js

@@ -0,0 +1,19 @@
+import { describe, expect, it } from "vitest";
+import { validateAgentConfig } from "../agent/config/agentConfig.js";
+describe("Agent config voice settings", ()=>{
+    it("accepts voice configuration in agent config", ()=>{
+        const result = validateAgentConfig({
+            name: "voice-agent",
+            description: "Tests voice settings.",
+            systemPrompt: "Respond clearly.",
+            voice: {
+                provider: "elevenlabs",
+                elevenlabs: {
+                    voiceId: "voice-123",
+                    stability: 0.4
+                }
+            }
+        });
+        expect(result.success).toBe(true);
+    });
+});

package/dist/tests/agentInvokerAttachments.test.cjs

@@ -0,0 +1,67 @@
+"use strict";
+var __webpack_exports__ = {};
+const external_vitest_namespaceObject = require("vitest");
+const agentInvoker_cjs_namespaceObject = require("../cli/core/agentInvoker.cjs");
+(0, external_vitest_namespaceObject.describe)("buildUserContent", ()=>{
+    (0, external_vitest_namespaceObject.it)("returns text when no attachments are provided", ()=>{
+        (0, external_vitest_namespaceObject.expect)((0, agentInvoker_cjs_namespaceObject.buildUserContent)("Hello", void 0)).toBe("Hello");
+    });
+    (0, external_vitest_namespaceObject.it)("builds mixed text and image parts", ()=>{
+        const result = (0, agentInvoker_cjs_namespaceObject.buildUserContent)("Chart please", [
+            {
+                dataUrl: "data:image/png;base64,abc"
+            }
+        ]);
+        (0, external_vitest_namespaceObject.expect)(Array.isArray(result)).toBe(true);
+        (0, external_vitest_namespaceObject.expect)(result).toEqual([
+            {
+                type: "text",
+                text: "Chart please"
+            },
+            {
+                type: "image_url",
+                image_url: {
+                    url: "data:image/png;base64,abc"
+                }
+            }
+        ]);
+    });
+    (0, external_vitest_namespaceObject.it)("builds image-only parts when text is empty", ()=>{
+        const result = (0, agentInvoker_cjs_namespaceObject.buildUserContent)("", [
+            {
+                dataUrl: "data:image/png;base64,xyz"
+            }
+        ]);
+        (0, external_vitest_namespaceObject.expect)(Array.isArray(result)).toBe(true);
+        (0, external_vitest_namespaceObject.expect)(result).toEqual([
+            {
+                type: "image_url",
+                image_url: {
+                    url: "data:image/png;base64,xyz"
+                }
+            }
+        ]);
+    });
+    (0, external_vitest_namespaceObject.it)("builds audio parts when audio attachments are provided", ()=>{
+        const result = (0, agentInvoker_cjs_namespaceObject.buildUserContent)("", [
+            {
+                kind: "audio",
+                dataUrl: "data:audio/wav;base64,abc",
+                mimeType: "audio/wav"
+            }
+        ]);
+        (0, external_vitest_namespaceObject.expect)(Array.isArray(result)).toBe(true);
+        (0, external_vitest_namespaceObject.expect)(result).toEqual([
+            {
+                type: "audio",
+                source_type: "base64",
+                data: "abc",
+                mime_type: "audio/wav"
+            }
+        ]);
+    });
+});
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

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

package/dist/tests/agentInvokerAttachments.test.js

@@ -0,0 +1,61 @@
+import { describe, expect, it } from "vitest";
+import { buildUserContent } from "../cli/core/agentInvoker.js";
+describe("buildUserContent", ()=>{
+    it("returns text when no attachments are provided", ()=>{
+        expect(buildUserContent("Hello", void 0)).toBe("Hello");
+    });
+    it("builds mixed text and image parts", ()=>{
+        const result = buildUserContent("Chart please", [
+            {
+                dataUrl: "data:image/png;base64,abc"
+            }
+        ]);
+        expect(Array.isArray(result)).toBe(true);
+        expect(result).toEqual([
+            {
+                type: "text",
+                text: "Chart please"
+            },
+            {
+                type: "image_url",
+                image_url: {
+                    url: "data:image/png;base64,abc"
+                }
+            }
+        ]);
+    });
+    it("builds image-only parts when text is empty", ()=>{
+        const result = buildUserContent("", [
+            {
+                dataUrl: "data:image/png;base64,xyz"
+            }
+        ]);
+        expect(Array.isArray(result)).toBe(true);
+        expect(result).toEqual([
+            {
+                type: "image_url",
+                image_url: {
+                    url: "data:image/png;base64,xyz"
+                }
+            }
+        ]);
+    });
+    it("builds audio parts when audio attachments are provided", ()=>{
+        const result = buildUserContent("", [
+            {
+                kind: "audio",
+                dataUrl: "data:audio/wav;base64,abc",
+                mimeType: "audio/wav"
+            }
+        ]);
+        expect(Array.isArray(result)).toBe(true);
+        expect(result).toEqual([
+            {
+                type: "audio",
+                source_type: "base64",
+                data: "abc",
+                mime_type: "audio/wav"
+            }
+        ]);
+    });
+});

package/dist/tests/attachments-utils.test.cjs

@@ -0,0 +1,46 @@
+"use strict";
+var __webpack_exports__ = {};
+const external_vitest_namespaceObject = require("vitest");
+const attachments_cjs_namespaceObject = require("../utils/attachments.cjs");
+(0, external_vitest_namespaceObject.describe)("extractImageFiles", ()=>{
+    (0, external_vitest_namespaceObject.it)("returns only image files from clipboard items", ()=>{
+        const image = new File([
+            "data"
+        ], "chart.png", {
+            type: "image/png"
+        });
+        const text = new File([
+            "notes"
+        ], "notes.txt", {
+            type: "text/plain"
+        });
+        const items = [
+            {
+                kind: "file",
+                type: "image/png",
+                getAsFile: ()=>image
+            },
+            {
+                kind: "file",
+                type: "text/plain",
+                getAsFile: ()=>text
+            },
+            {
+                kind: "string",
+                type: "text/plain",
+                getAsFile: ()=>null
+            }
+        ];
+        const result = (0, attachments_cjs_namespaceObject.extractImageFiles)(items);
+        (0, external_vitest_namespaceObject.expect)(result).toEqual([
+            image
+        ]);
+    });
+    (0, external_vitest_namespaceObject.it)("handles missing items", ()=>{
+        (0, external_vitest_namespaceObject.expect)((0, attachments_cjs_namespaceObject.extractImageFiles)(null)).toEqual([]);
+    });
+});
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/tests/attachments-utils.test.d.ts

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

package/dist/tests/attachments-utils.test.js

@@ -0,0 +1,40 @@
+import { describe, expect, it } from "vitest";
+import { extractImageFiles } from "../utils/attachments.js";
+describe("extractImageFiles", ()=>{
+    it("returns only image files from clipboard items", ()=>{
+        const image = new File([
+            "data"
+        ], "chart.png", {
+            type: "image/png"
+        });
+        const text = new File([
+            "notes"
+        ], "notes.txt", {
+            type: "text/plain"
+        });
+        const items = [
+            {
+                kind: "file",
+                type: "image/png",
+                getAsFile: ()=>image
+            },
+            {
+                kind: "file",
+                type: "text/plain",
+                getAsFile: ()=>text
+            },
+            {
+                kind: "string",
+                type: "text/plain",
+                getAsFile: ()=>null
+            }
+        ];
+        const result = extractImageFiles(items);
+        expect(result).toEqual([
+            image
+        ]);
+    });
+    it("handles missing items", ()=>{
+        expect(extractImageFiles(null)).toEqual([]);
+    });
+});