@wingman-ai/gateway 0.2.1 → 0.2.3

package/dist/tests/agentInvokerSummarization.test.js

@@ -0,0 +1,290 @@
+import { describe, expect, it } from "vitest";
+import { validateConfig } from "../cli/config/schema.js";
+import { chunkHasAssistantText, configureDeepAgentSummarizationMiddleware, detectToolEventContext, resolveHumanInTheLoopSettings, resolveModelRetryMiddlewareSettings, resolveSummarizationMiddlewareSettings, resolveToolRetryMiddlewareSettings, selectStreamingFallbackText } from "../cli/core/agentInvoker.js";
+const parseConfig = (input)=>{
+    const result = validateConfig(input);
+    if (!result.success || !result.data) throw new Error(result.error || "Expected config validation to succeed");
+    return result.data;
+};
+describe("resolveSummarizationMiddlewareSettings", ()=>{
+    it("returns default summarization settings from config defaults", ()=>{
+        const config = parseConfig({});
+        expect(resolveSummarizationMiddlewareSettings(config)).toEqual({
+            maxTokensBeforeSummary: 12000,
+            messagesToKeep: 8
+        });
+    });
+    it("returns null when summarization is disabled", ()=>{
+        const config = parseConfig({
+            summarization: {
+                enabled: false
+            }
+        });
+        expect(resolveSummarizationMiddlewareSettings(config)).toBeNull();
+    });
+    it("returns custom summarization settings when configured", ()=>{
+        const config = parseConfig({
+            summarization: {
+                enabled: true,
+                maxTokensBeforeSummary: 20000,
+                messagesToKeep: 10
+            }
+        });
+        expect(resolveSummarizationMiddlewareSettings(config)).toEqual({
+            maxTokensBeforeSummary: 20000,
+            messagesToKeep: 10
+        });
+    });
+});
+describe("configureDeepAgentSummarizationMiddleware", ()=>{
+    it("replaces built-in summarization middleware with configured settings", ()=>{
+        const agent = {
+            options: {
+                middleware: [
+                    {
+                        name: "todoListMiddleware"
+                    },
+                    {
+                        name: "SummarizationMiddleware",
+                        marker: "old"
+                    }
+                ]
+            }
+        };
+        configureDeepAgentSummarizationMiddleware(agent, {
+            maxTokensBeforeSummary: 9000,
+            messagesToKeep: 5
+        }, "openai:gpt-4o-mini");
+        expect(agent.options.middleware).toHaveLength(2);
+        expect(agent.options.middleware[1]?.name).toBe("SummarizationMiddleware");
+        expect(agent.options.middleware[1]?.marker).toBeUndefined();
+    });
+    it("removes built-in summarization middleware when disabled", ()=>{
+        const agent = {
+            options: {
+                middleware: [
+                    {
+                        name: "todoListMiddleware"
+                    },
+                    {
+                        name: "SummarizationMiddleware"
+                    },
+                    {
+                        name: "patchToolCallsMiddleware"
+                    }
+                ]
+            }
+        };
+        configureDeepAgentSummarizationMiddleware(agent, null);
+        expect(agent.options.middleware.map((m)=>m.name)).toEqual([
+            "todoListMiddleware",
+            "patchToolCallsMiddleware"
+        ]);
+    });
+});
+describe("resolveModelRetryMiddlewareSettings", ()=>{
+    it("returns default retry settings when config defaults are used", ()=>{
+        const config = parseConfig({});
+        expect(resolveModelRetryMiddlewareSettings(config)).toEqual({
+            maxRetries: 2,
+            backoffFactor: 2,
+            initialDelayMs: 1000,
+            maxDelayMs: 60000,
+            jitter: true,
+            onFailure: "continue"
+        });
+    });
+    it("returns configured retry settings when enabled", ()=>{
+        const config = parseConfig({
+            modelRetry: {
+                enabled: true,
+                maxRetries: 3,
+                backoffFactor: 1.5,
+                initialDelayMs: 250,
+                maxDelayMs: 5000,
+                jitter: false,
+                onFailure: "error"
+            }
+        });
+        expect(resolveModelRetryMiddlewareSettings(config)).toEqual({
+            maxRetries: 3,
+            backoffFactor: 1.5,
+            initialDelayMs: 250,
+            maxDelayMs: 5000,
+            jitter: false,
+            onFailure: "error"
+        });
+    });
+});
+describe("resolveToolRetryMiddlewareSettings", ()=>{
+    it("returns null by default", ()=>{
+        const config = parseConfig({});
+        expect(resolveToolRetryMiddlewareSettings(config)).toBeNull();
+    });
+    it("returns configured retry settings and tool filter when enabled", ()=>{
+        const config = parseConfig({
+            toolRetry: {
+                enabled: true,
+                maxRetries: 4,
+                backoffFactor: 2,
+                initialDelayMs: 500,
+                maxDelayMs: 10000,
+                jitter: true,
+                onFailure: "continue",
+                tools: [
+                    "internet_search",
+                    "web_crawler"
+                ]
+            }
+        });
+        expect(resolveToolRetryMiddlewareSettings(config)).toEqual({
+            maxRetries: 4,
+            backoffFactor: 2,
+            initialDelayMs: 500,
+            maxDelayMs: 10000,
+            jitter: true,
+            onFailure: "continue",
+            tools: [
+                "internet_search",
+                "web_crawler"
+            ]
+        });
+    });
+});
+describe("resolveHumanInTheLoopSettings", ()=>{
+    it("returns null by default", ()=>{
+        const config = parseConfig({});
+        expect(resolveHumanInTheLoopSettings(config)).toBeNull();
+    });
+    it("returns null when enabled but no tool policy is defined", ()=>{
+        const config = parseConfig({
+            humanInTheLoop: {
+                enabled: true,
+                interruptOn: {}
+            }
+        });
+        expect(resolveHumanInTheLoopSettings(config)).toBeNull();
+    });
+    it("returns interrupt map when enabled with tool policies", ()=>{
+        const config = parseConfig({
+            humanInTheLoop: {
+                enabled: true,
+                interruptOn: {
+                    command_execute: {
+                        allowedDecisions: [
+                            "approve",
+                            "reject"
+                        ],
+                        description: "Command execution requires approval"
+                    },
+                    internet_search: false
+                }
+            }
+        });
+        expect(resolveHumanInTheLoopSettings(config)).toEqual({
+            interruptOn: {
+                command_execute: {
+                    allowedDecisions: [
+                        "approve",
+                        "reject"
+                    ],
+                    description: "Command execution requires approval"
+                },
+                internet_search: false
+            }
+        });
+    });
+});
+describe("detectToolEventContext", ()=>{
+    it("extracts tool context for tool start events", ()=>{
+        const detected = detectToolEventContext({
+            event: "on_tool_start",
+            name: "glob"
+        });
+        expect(detected).toEqual({
+            event: "on_tool_start",
+            toolName: "glob"
+        });
+    });
+    it("returns null for non-tool events", ()=>{
+        const detected = detectToolEventContext({
+            event: "on_chat_model_stream",
+            data: {
+                chunk: {
+                    text: "hello"
+                }
+            }
+        });
+        expect(detected).toBeNull();
+    });
+});
+describe("chunkHasAssistantText", ()=>{
+    it("detects text in on_chat_model_stream chunks", ()=>{
+        expect(chunkHasAssistantText({
+            event: "on_chat_model_stream",
+            data: {
+                chunk: {
+                    content: [
+                        {
+                            type: "text",
+                            text: "hello"
+                        }
+                    ]
+                }
+            }
+        })).toBe(true);
+    });
+    it("detects text in on_llm_stream chunks", ()=>{
+        expect(chunkHasAssistantText({
+            event: "on_llm_stream",
+            data: {
+                chunk: {
+                    text: "delta"
+                }
+            }
+        })).toBe(true);
+    });
+    it("returns false when chunk has no assistant text", ()=>{
+        expect(chunkHasAssistantText({
+            event: "on_tool_start",
+            name: "glob"
+        })).toBe(false);
+    });
+});
+describe("selectStreamingFallbackText", ()=>{
+    it("returns the most recent assistant message in the same invocation window", ()=>{
+        const selected = selectStreamingFallbackText([
+            {
+                role: "assistant",
+                createdAt: 1000,
+                content: "stale message"
+            },
+            {
+                role: "assistant",
+                createdAt: 4500,
+                content: "fresh fallback"
+            }
+        ], 4000);
+        expect(selected).toBe("fresh fallback");
+    });
+    it("ignores stale, user-role, and empty-content messages", ()=>{
+        const selected = selectStreamingFallbackText([
+            {
+                role: "assistant",
+                createdAt: 1000,
+                content: "too old"
+            },
+            {
+                role: "user",
+                createdAt: 4900,
+                content: "not assistant"
+            },
+            {
+                role: "assistant",
+                createdAt: 5000,
+                content: "   "
+            }
+        ], 5000);
+        expect(selected).toBeUndefined();
+    });
+});

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");
+    });
+});