@wingman-ai/gateway 0.2.2 → 0.2.3

package/dist/tests/cli-config-loader.test.cjs

@@ -33,6 +33,33 @@ const external_os_namespaceObject = require("os");
             (0, external_vitest_namespaceObject.expect)(config).toEqual({
                 logLevel: "info",
                 recursionLimit: 5000,
+                summarization: {
+                    enabled: true,
+                    maxTokensBeforeSummary: 12000,
+                    messagesToKeep: 8
+                },
+                modelRetry: {
+                    enabled: true,
+                    maxRetries: 2,
+                    backoffFactor: 2,
+                    initialDelayMs: 1000,
+                    maxDelayMs: 60000,
+                    jitter: true,
+                    onFailure: "continue"
+                },
+                toolRetry: {
+                    enabled: false,
+                    maxRetries: 2,
+                    backoffFactor: 2,
+                    initialDelayMs: 1000,
+                    maxDelayMs: 60000,
+                    jitter: true,
+                    onFailure: "continue"
+                },
+                humanInTheLoop: {
+                    enabled: false,
+                    interruptOn: {}
+                },
                 search: {
                     provider: "duckduckgo",
                     maxResults: 5
@@ -111,6 +138,11 @@ const external_os_namespaceObject = require("os");
                 logLevel: "debug",
                 defaultAgent: "coder",
                 recursionLimit: 5,
+                summarization: {
+                    enabled: true,
+                    maxTokensBeforeSummary: 18000,
+                    messagesToKeep: 10
+                },
                 search: {
                     provider: "perplexity",
                     maxResults: 10
@@ -130,6 +162,62 @@ const external_os_namespaceObject = require("os");
             const config = loader.loadConfig();
             (0, external_vitest_namespaceObject.expect)(config).toMatchObject(configData);
         });
+        (0, external_vitest_namespaceObject.it)("should allow disabling summarization middleware", ()=>{
+            const configData = {
+                summarization: {
+                    enabled: false
+                }
+            };
+            (0, external_fs_namespaceObject.writeFileSync)((0, external_path_namespaceObject.join)(configDir, "wingman.config.json"), JSON.stringify(configData));
+            const loader = new loader_cjs_namespaceObject.WingmanConfigLoader(".wingman", testDir);
+            const config = loader.loadConfig();
+            (0, external_vitest_namespaceObject.expect)(config.summarization).toEqual({
+                enabled: false,
+                maxTokensBeforeSummary: 12000,
+                messagesToKeep: 8
+            });
+        });
+        (0, external_vitest_namespaceObject.it)("should load retry and HITL middleware config", ()=>{
+            const configData = {
+                modelRetry: {
+                    enabled: true,
+                    maxRetries: 3,
+                    backoffFactor: 1.5,
+                    initialDelayMs: 250,
+                    maxDelayMs: 4000,
+                    jitter: false,
+                    onFailure: "error"
+                },
+                toolRetry: {
+                    enabled: true,
+                    maxRetries: 4,
+                    backoffFactor: 2,
+                    initialDelayMs: 500,
+                    maxDelayMs: 8000,
+                    jitter: true,
+                    onFailure: "continue",
+                    tools: [
+                        "internet_search",
+                        "web_crawler"
+                    ]
+                },
+                humanInTheLoop: {
+                    enabled: true,
+                    interruptOn: {
+                        command_execute: {
+                            allowedDecisions: [
+                                "approve",
+                                "reject"
+                            ]
+                        }
+                    }
+                }
+            };
+            (0, external_fs_namespaceObject.writeFileSync)((0, external_path_namespaceObject.join)(configDir, "wingman.config.json"), JSON.stringify(configData));
+            const loader = new loader_cjs_namespaceObject.WingmanConfigLoader(".wingman", testDir);
+            const config = loader.loadConfig();
+            (0, external_vitest_namespaceObject.expect)(config).toMatchObject(configData);
+        });
         (0, external_vitest_namespaceObject.it)("should handle all valid log levels", ()=>{
             const levels = [
                 "debug",

package/dist/tests/cli-config-loader.test.js

@@ -31,6 +31,33 @@ describe("CLI Config Loader", ()=>{
             expect(config).toEqual({
                 logLevel: "info",
                 recursionLimit: 5000,
+                summarization: {
+                    enabled: true,
+                    maxTokensBeforeSummary: 12000,
+                    messagesToKeep: 8
+                },
+                modelRetry: {
+                    enabled: true,
+                    maxRetries: 2,
+                    backoffFactor: 2,
+                    initialDelayMs: 1000,
+                    maxDelayMs: 60000,
+                    jitter: true,
+                    onFailure: "continue"
+                },
+                toolRetry: {
+                    enabled: false,
+                    maxRetries: 2,
+                    backoffFactor: 2,
+                    initialDelayMs: 1000,
+                    maxDelayMs: 60000,
+                    jitter: true,
+                    onFailure: "continue"
+                },
+                humanInTheLoop: {
+                    enabled: false,
+                    interruptOn: {}
+                },
                 search: {
                     provider: "duckduckgo",
                     maxResults: 5
@@ -109,6 +136,11 @@ describe("CLI Config Loader", ()=>{
                 logLevel: "debug",
                 defaultAgent: "coder",
                 recursionLimit: 5,
+                summarization: {
+                    enabled: true,
+                    maxTokensBeforeSummary: 18000,
+                    messagesToKeep: 10
+                },
                 search: {
                     provider: "perplexity",
                     maxResults: 10
@@ -128,6 +160,62 @@ describe("CLI Config Loader", ()=>{
             const config = loader.loadConfig();
             expect(config).toMatchObject(configData);
         });
+        it("should allow disabling summarization middleware", ()=>{
+            const configData = {
+                summarization: {
+                    enabled: false
+                }
+            };
+            writeFileSync(join(configDir, "wingman.config.json"), JSON.stringify(configData));
+            const loader = new WingmanConfigLoader(".wingman", testDir);
+            const config = loader.loadConfig();
+            expect(config.summarization).toEqual({
+                enabled: false,
+                maxTokensBeforeSummary: 12000,
+                messagesToKeep: 8
+            });
+        });
+        it("should load retry and HITL middleware config", ()=>{
+            const configData = {
+                modelRetry: {
+                    enabled: true,
+                    maxRetries: 3,
+                    backoffFactor: 1.5,
+                    initialDelayMs: 250,
+                    maxDelayMs: 4000,
+                    jitter: false,
+                    onFailure: "error"
+                },
+                toolRetry: {
+                    enabled: true,
+                    maxRetries: 4,
+                    backoffFactor: 2,
+                    initialDelayMs: 500,
+                    maxDelayMs: 8000,
+                    jitter: true,
+                    onFailure: "continue",
+                    tools: [
+                        "internet_search",
+                        "web_crawler"
+                    ]
+                },
+                humanInTheLoop: {
+                    enabled: true,
+                    interruptOn: {
+                        command_execute: {
+                            allowedDecisions: [
+                                "approve",
+                                "reject"
+                            ]
+                        }
+                    }
+                }
+            };
+            writeFileSync(join(configDir, "wingman.config.json"), JSON.stringify(configData));
+            const loader = new WingmanConfigLoader(".wingman", testDir);
+            const config = loader.loadConfig();
+            expect(config).toMatchObject(configData);
+        });
         it("should handle all valid log levels", ()=>{
             const levels = [
                 "debug",

package/dist/tests/codex-credentials-precedence.test.cjs

@@ -0,0 +1,94 @@
+"use strict";
+var __webpack_exports__ = {};
+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 external_vitest_namespaceObject = require("vitest");
+(0, external_vitest_namespaceObject.describe)("codex credential precedence", ()=>{
+    let homeDir;
+    let codexHome;
+    const originalHome = process.env.HOME;
+    const originalCodexHome = process.env.CODEX_HOME;
+    const originalCodexAccessToken = process.env.CODEX_ACCESS_TOKEN;
+    const originalChatGptAccessToken = process.env.CHATGPT_ACCESS_TOKEN;
+    (0, external_vitest_namespaceObject.beforeEach)(()=>{
+        homeDir = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-home-"));
+        codexHome = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-codex-home-"));
+        process.env.HOME = homeDir;
+        process.env.CODEX_HOME = codexHome;
+        delete process.env.CODEX_ACCESS_TOKEN;
+        delete process.env.CHATGPT_ACCESS_TOKEN;
+    });
+    (0, external_vitest_namespaceObject.afterEach)(()=>{
+        if (void 0 === originalHome) delete process.env.HOME;
+        else process.env.HOME = originalHome;
+        if (void 0 === originalCodexHome) delete process.env.CODEX_HOME;
+        else process.env.CODEX_HOME = originalCodexHome;
+        if (void 0 === originalCodexAccessToken) delete process.env.CODEX_ACCESS_TOKEN;
+        else process.env.CODEX_ACCESS_TOKEN = originalCodexAccessToken;
+        if (void 0 === originalChatGptAccessToken) delete process.env.CHATGPT_ACCESS_TOKEN;
+        else process.env.CHATGPT_ACCESS_TOKEN = originalChatGptAccessToken;
+        if ((0, external_node_fs_namespaceObject.existsSync)(homeDir)) (0, external_node_fs_namespaceObject.rmSync)(homeDir, {
+            recursive: true,
+            force: true
+        });
+        if ((0, external_node_fs_namespaceObject.existsSync)(codexHome)) (0, external_node_fs_namespaceObject.rmSync)(codexHome, {
+            recursive: true,
+            force: true
+        });
+    });
+    (0, external_vitest_namespaceObject.it)("prefers Codex auth file over stored Wingman credentials for codex", async ()=>{
+        external_vitest_namespaceObject.vi.resetModules();
+        const credentials = await import("../providers/credentials.cjs");
+        const codex = await import("../providers/codex.cjs");
+        const credsPath = credentials.getCredentialsPath();
+        (0, external_node_fs_namespaceObject.mkdirSync)((0, external_node_path_namespaceObject.dirname)(credsPath), {
+            recursive: true
+        });
+        (0, external_node_fs_namespaceObject.writeFileSync)(credsPath, JSON.stringify({
+            version: 1,
+            updatedAt: new Date().toISOString(),
+            providers: {
+                codex: {
+                    apiKey: "stale-wingman-token"
+                }
+            }
+        }, null, 2));
+        const authPath = codex.getCodexAuthPath();
+        (0, external_node_fs_namespaceObject.mkdirSync)((0, external_node_path_namespaceObject.dirname)(authPath), {
+            recursive: true
+        });
+        (0, external_node_fs_namespaceObject.writeFileSync)(authPath, JSON.stringify({
+            tokens: {
+                access_token: "codex-file-token",
+                account_id: "acct_123"
+            }
+        }, null, 2));
+        const resolved = credentials.resolveProviderToken("codex");
+        (0, external_vitest_namespaceObject.expect)(resolved.token).toBe("codex-file-token");
+        (0, external_vitest_namespaceObject.expect)(resolved.source).toBe("credentials");
+    });
+    (0, external_vitest_namespaceObject.it)("still prefers env vars over Codex auth file", async ()=>{
+        process.env.CODEX_ACCESS_TOKEN = "env-token";
+        external_vitest_namespaceObject.vi.resetModules();
+        const credentials = await import("../providers/credentials.cjs");
+        const codex = await import("../providers/codex.cjs");
+        const authPath = codex.getCodexAuthPath();
+        (0, external_node_fs_namespaceObject.mkdirSync)((0, external_node_path_namespaceObject.dirname)(authPath), {
+            recursive: true
+        });
+        (0, external_node_fs_namespaceObject.writeFileSync)(authPath, JSON.stringify({
+            tokens: {
+                access_token: "codex-file-token"
+            }
+        }, null, 2));
+        const resolved = credentials.resolveProviderToken("codex");
+        (0, external_vitest_namespaceObject.expect)(resolved.token).toBe("env-token");
+        (0, external_vitest_namespaceObject.expect)(resolved.source).toBe("env");
+        (0, external_vitest_namespaceObject.expect)((0, external_node_fs_namespaceObject.readFileSync)(authPath, "utf-8")).toContain("codex-file-token");
+    });
+});
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/tests/codex-credentials-precedence.test.d.ts

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

package/dist/tests/codex-credentials-precedence.test.js

@@ -0,0 +1,88 @@
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+describe("codex credential precedence", ()=>{
+    let homeDir;
+    let codexHome;
+    const originalHome = process.env.HOME;
+    const originalCodexHome = process.env.CODEX_HOME;
+    const originalCodexAccessToken = process.env.CODEX_ACCESS_TOKEN;
+    const originalChatGptAccessToken = process.env.CHATGPT_ACCESS_TOKEN;
+    beforeEach(()=>{
+        homeDir = mkdtempSync(join(tmpdir(), "wingman-home-"));
+        codexHome = mkdtempSync(join(tmpdir(), "wingman-codex-home-"));
+        process.env.HOME = homeDir;
+        process.env.CODEX_HOME = codexHome;
+        delete process.env.CODEX_ACCESS_TOKEN;
+        delete process.env.CHATGPT_ACCESS_TOKEN;
+    });
+    afterEach(()=>{
+        if (void 0 === originalHome) delete process.env.HOME;
+        else process.env.HOME = originalHome;
+        if (void 0 === originalCodexHome) delete process.env.CODEX_HOME;
+        else process.env.CODEX_HOME = originalCodexHome;
+        if (void 0 === originalCodexAccessToken) delete process.env.CODEX_ACCESS_TOKEN;
+        else process.env.CODEX_ACCESS_TOKEN = originalCodexAccessToken;
+        if (void 0 === originalChatGptAccessToken) delete process.env.CHATGPT_ACCESS_TOKEN;
+        else process.env.CHATGPT_ACCESS_TOKEN = originalChatGptAccessToken;
+        if (existsSync(homeDir)) rmSync(homeDir, {
+            recursive: true,
+            force: true
+        });
+        if (existsSync(codexHome)) rmSync(codexHome, {
+            recursive: true,
+            force: true
+        });
+    });
+    it("prefers Codex auth file over stored Wingman credentials for codex", async ()=>{
+        vi.resetModules();
+        const credentials = await import("../providers/credentials.js");
+        const codex = await import("../providers/codex.js");
+        const credsPath = credentials.getCredentialsPath();
+        mkdirSync(dirname(credsPath), {
+            recursive: true
+        });
+        writeFileSync(credsPath, JSON.stringify({
+            version: 1,
+            updatedAt: new Date().toISOString(),
+            providers: {
+                codex: {
+                    apiKey: "stale-wingman-token"
+                }
+            }
+        }, null, 2));
+        const authPath = codex.getCodexAuthPath();
+        mkdirSync(dirname(authPath), {
+            recursive: true
+        });
+        writeFileSync(authPath, JSON.stringify({
+            tokens: {
+                access_token: "codex-file-token",
+                account_id: "acct_123"
+            }
+        }, null, 2));
+        const resolved = credentials.resolveProviderToken("codex");
+        expect(resolved.token).toBe("codex-file-token");
+        expect(resolved.source).toBe("credentials");
+    });
+    it("still prefers env vars over Codex auth file", async ()=>{
+        process.env.CODEX_ACCESS_TOKEN = "env-token";
+        vi.resetModules();
+        const credentials = await import("../providers/credentials.js");
+        const codex = await import("../providers/codex.js");
+        const authPath = codex.getCodexAuthPath();
+        mkdirSync(dirname(authPath), {
+            recursive: true
+        });
+        writeFileSync(authPath, JSON.stringify({
+            tokens: {
+                access_token: "codex-file-token"
+            }
+        }, null, 2));
+        const resolved = credentials.resolveProviderToken("codex");
+        expect(resolved.token).toBe("env-token");
+        expect(resolved.source).toBe("env");
+        expect(readFileSync(authPath, "utf-8")).toContain("codex-file-token");
+    });
+});

package/dist/tests/codex-provider.test.cjs

@@ -0,0 +1,186 @@
+"use strict";
+var __webpack_exports__ = {};
+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 external_vitest_namespaceObject = require("vitest");
+const codex_cjs_namespaceObject = require("../providers/codex.cjs");
+(0, external_vitest_namespaceObject.describe)("codex provider", ()=>{
+    let codexHome;
+    const originalCodexHome = process.env.CODEX_HOME;
+    (0, external_vitest_namespaceObject.beforeEach)(()=>{
+        codexHome = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-codex-"));
+        process.env.CODEX_HOME = codexHome;
+        delete process.env.CODEX_ACCESS_TOKEN;
+        delete process.env.CHATGPT_ACCESS_TOKEN;
+    });
+    (0, external_vitest_namespaceObject.afterEach)(()=>{
+        if (void 0 === originalCodexHome) delete process.env.CODEX_HOME;
+        else process.env.CODEX_HOME = originalCodexHome;
+        if ((0, external_node_fs_namespaceObject.existsSync)(codexHome)) (0, external_node_fs_namespaceObject.rmSync)(codexHome, {
+            recursive: true,
+            force: true
+        });
+    });
+    (0, external_vitest_namespaceObject.it)("reads access token and account id from codex auth file", ()=>{
+        writeCodexAuth({
+            tokens: {
+                access_token: "codex-access-token",
+                account_id: "acct_123"
+            }
+        });
+        const resolved = (0, codex_cjs_namespaceObject.resolveCodexAuthFromFile)();
+        (0, external_vitest_namespaceObject.expect)(resolved.accessToken).toBe("codex-access-token");
+        (0, external_vitest_namespaceObject.expect)(resolved.accountId).toBe("acct_123");
+        (0, external_vitest_namespaceObject.expect)(resolved.authPath).toBe((0, external_node_path_namespaceObject.join)(codexHome, "auth.json"));
+    });
+    (0, external_vitest_namespaceObject.it)("applies codex auth headers and forces store=false", async ()=>{
+        writeCodexAuth({
+            tokens: {
+                access_token: "file-token",
+                account_id: "acct_file"
+            }
+        });
+        const baseFetch = external_vitest_namespaceObject.vi.fn(async (_input, _init)=>new Response("{}", {
+                status: 200
+            }));
+        const codexFetch = (0, codex_cjs_namespaceObject.createCodexFetch)({
+            baseFetch
+        });
+        await codexFetch("https://chatgpt.com/backend-api/codex/responses", {
+            method: "POST",
+            headers: {
+                "x-api-key": "placeholder"
+            },
+            body: JSON.stringify({
+                model: "codex-mini-latest",
+                input: "hello",
+                temperature: 1
+            })
+        });
+        (0, external_vitest_namespaceObject.expect)(baseFetch).toHaveBeenCalledTimes(1);
+        const requestInit = baseFetch.mock.calls[0]?.[1];
+        (0, external_vitest_namespaceObject.expect)(requestInit).toBeDefined();
+        const headers = new Headers(requestInit?.headers);
+        const payload = JSON.parse(String(requestInit?.body));
+        (0, external_vitest_namespaceObject.expect)(headers.get("authorization")).toBe("Bearer file-token");
+        (0, external_vitest_namespaceObject.expect)(headers.get("chatgpt-account-id")).toBe("acct_file");
+        (0, external_vitest_namespaceObject.expect)(headers.get("x-api-key")).toBeNull();
+        (0, external_vitest_namespaceObject.expect)(payload.store).toBe(false);
+        (0, external_vitest_namespaceObject.expect)(payload.temperature).toBeUndefined();
+        (0, external_vitest_namespaceObject.expect)(typeof payload.instructions).toBe("string");
+        (0, external_vitest_namespaceObject.expect)(payload.instructions.length).toBeGreaterThan(0);
+    });
+    (0, external_vitest_namespaceObject.it)("derives instructions from system/developer input when missing", async ()=>{
+        writeCodexAuth({
+            tokens: {
+                access_token: "file-token"
+            }
+        });
+        const baseFetch = external_vitest_namespaceObject.vi.fn(async (_input, _init)=>new Response("{}", {
+                status: 200
+            }));
+        const codexFetch = (0, codex_cjs_namespaceObject.createCodexFetch)({
+            baseFetch
+        });
+        await codexFetch("https://chatgpt.com/backend-api/codex/responses", {
+            method: "POST",
+            body: JSON.stringify({
+                model: "gpt-5.3-codex",
+                input: [
+                    {
+                        role: "developer",
+                        content: [
+                            {
+                                type: "input_text",
+                                text: "Always run tests first."
+                            }
+                        ]
+                    },
+                    {
+                        role: "user",
+                        content: [
+                            {
+                                type: "input_text",
+                                text: "Fix the bug."
+                            }
+                        ]
+                    }
+                ]
+            })
+        });
+        const requestInit = baseFetch.mock.calls[0]?.[1];
+        const payload = JSON.parse(String(requestInit?.body));
+        (0, external_vitest_namespaceObject.expect)(payload.instructions).toBe("Always run tests first.");
+    });
+    (0, external_vitest_namespaceObject.it)("preserves explicit instructions when provided", async ()=>{
+        writeCodexAuth({
+            tokens: {
+                access_token: "file-token"
+            }
+        });
+        const baseFetch = external_vitest_namespaceObject.vi.fn(async (_input, _init)=>new Response("{}", {
+                status: 200
+            }));
+        const codexFetch = (0, codex_cjs_namespaceObject.createCodexFetch)({
+            baseFetch
+        });
+        await codexFetch("https://chatgpt.com/backend-api/codex/responses", {
+            method: "POST",
+            body: JSON.stringify({
+                model: "gpt-5.3-codex",
+                instructions: "Use concise answers.",
+                input: "hello"
+            })
+        });
+        const requestInit = baseFetch.mock.calls[0]?.[1];
+        const payload = JSON.parse(String(requestInit?.body));
+        (0, external_vitest_namespaceObject.expect)(payload.instructions).toBe("Use concise answers.");
+    });
+    (0, external_vitest_namespaceObject.it)("uses fallback token when codex auth file is unavailable", async ()=>{
+        const baseFetch = external_vitest_namespaceObject.vi.fn(async (_input, _init)=>new Response("{}", {
+                status: 200
+            }));
+        const codexFetch = (0, codex_cjs_namespaceObject.createCodexFetch)({
+            baseFetch,
+            fallbackToken: "fallback-token"
+        });
+        await codexFetch("https://chatgpt.com/backend-api/codex/responses", {
+            method: "POST",
+            body: JSON.stringify({
+                model: "codex-mini-latest",
+                input: "hello"
+            })
+        });
+        const requestInit = baseFetch.mock.calls[0]?.[1];
+        (0, external_vitest_namespaceObject.expect)(requestInit).toBeDefined();
+        const headers = new Headers(requestInit?.headers);
+        (0, external_vitest_namespaceObject.expect)(headers.get("authorization")).toBe("Bearer fallback-token");
+    });
+    (0, external_vitest_namespaceObject.it)("throws when no codex token is available", async ()=>{
+        const baseFetch = external_vitest_namespaceObject.vi.fn(async (_input, _init)=>new Response("{}", {
+                status: 200
+            }));
+        const codexFetch = (0, codex_cjs_namespaceObject.createCodexFetch)({
+            baseFetch
+        });
+        await (0, external_vitest_namespaceObject.expect)(codexFetch("https://chatgpt.com/backend-api/codex/responses", {
+            method: "POST",
+            body: JSON.stringify({
+                model: "codex-mini-latest",
+                input: "hello"
+            })
+        })).rejects.toThrow(/Codex credentials missing/);
+    });
+});
+function writeCodexAuth(payload) {
+    const authPath = (0, codex_cjs_namespaceObject.getCodexAuthPath)();
+    (0, external_node_fs_namespaceObject.mkdirSync)((0, external_node_path_namespaceObject.dirname)(authPath), {
+        recursive: true
+    });
+    (0, external_node_fs_namespaceObject.writeFileSync)(authPath, JSON.stringify(payload, null, 2));
+}
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/tests/codex-provider.test.d.ts

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