@wingman-ai/gateway 0.2.2 → 0.2.3

package/dist/providers/credentials.js

@@ -1,6 +1,7 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
+import { resolveCodexAuthFromFile } from "./codex.js";
 import { getProviderSpec } from "./registry.js";
 const CREDENTIALS_VERSION = 1;
 const CREDENTIALS_DIR = join(homedir(), ".wingman");
@@ -86,6 +87,13 @@ function resolveProviderToken(providerName) {
             envVar
         };
     }
+    if ("codex" === provider.name) {
+        const codexAuth = resolveCodexAuthFromFile();
+        if (codexAuth.accessToken) return {
+            token: codexAuth.accessToken,
+            source: "credentials"
+        };
+    }
     const credentials = getProviderCredentials(provider.name);
     const token = credentials?.accessToken ?? credentials?.apiKey ?? credentials?.refreshToken;
     if (token && token.trim()) return {

package/dist/providers/registry.cjs

@@ -47,6 +47,17 @@ const PROVIDERS = {
         ],
         category: "model"
     },
+    codex: {
+        name: "codex",
+        label: "OpenAI Codex",
+        type: "api-key",
+        envVars: [
+            "CODEX_ACCESS_TOKEN",
+            "CHATGPT_ACCESS_TOKEN"
+        ],
+        baseURL: "https://chatgpt.com/backend-api/codex",
+        category: "model"
+    },
     openrouter: {
         name: "openrouter",
         label: "OpenRouter",

package/dist/providers/registry.d.ts

@@ -1,6 +1,6 @@
 export type ProviderAuthType = "api-key" | "oauth";
 export type ProviderCategory = "model" | "voice";
-export type ProviderName = "anthropic" | "openai" | "openrouter" | "copilot" | "xai" | "lmstudio" | "ollama" | "elevenlabs";
+export type ProviderName = "anthropic" | "openai" | "codex" | "openrouter" | "copilot" | "xai" | "lmstudio" | "ollama" | "elevenlabs";
 export interface ProviderOAuthConfig {
     authorizationUrl: string;
     tokenUrl: string;

package/dist/providers/registry.js

@@ -17,6 +17,17 @@ const PROVIDERS = {
         ],
         category: "model"
     },
+    codex: {
+        name: "codex",
+        label: "OpenAI Codex",
+        type: "api-key",
+        envVars: [
+            "CODEX_ACCESS_TOKEN",
+            "CHATGPT_ACCESS_TOKEN"
+        ],
+        baseURL: "https://chatgpt.com/backend-api/codex",
+        category: "model"
+    },
     openrouter: {
         name: "openrouter",
         label: "OpenRouter",

package/dist/tests/agentInvokerSummarization.test.cjs

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

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

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

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