@wingman-ai/gateway 0.2.2 → 0.2.4

package/dist/providers/codex.cjs

@@ -0,0 +1,167 @@
+"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__, {
+    createCodexFetch: ()=>createCodexFetch,
+    getCodexAuthPath: ()=>getCodexAuthPath,
+    resolveCodexAuthFromFile: ()=>resolveCodexAuthFromFile
+});
+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_logger_cjs_namespaceObject = require("../logger.cjs");
+const CODEX_HOME_ENV = "CODEX_HOME";
+const CODEX_AUTH_FILE = "auth.json";
+const DEFAULT_CODEX_INSTRUCTIONS = "You are Wingman, a coding assistant. Follow the user's request exactly and keep tool usage focused.";
+const logger = (0, external_logger_cjs_namespaceObject.createLogger)();
+function getCodexAuthPath() {
+    const codexHome = process.env[CODEX_HOME_ENV]?.trim();
+    if (codexHome) return (0, external_node_path_namespaceObject.join)(codexHome, CODEX_AUTH_FILE);
+    return (0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.homedir)(), ".codex", CODEX_AUTH_FILE);
+}
+function resolveCodexAuthFromFile() {
+    const authPath = getCodexAuthPath();
+    if (!(0, external_node_fs_namespaceObject.existsSync)(authPath)) return {
+        authPath
+    };
+    try {
+        const parsed = JSON.parse((0, external_node_fs_namespaceObject.readFileSync)(authPath, "utf-8"));
+        if (!parsed || "object" != typeof parsed) return {
+            authPath
+        };
+        const root = parsed;
+        const tokens = root.tokens && "object" == typeof root.tokens ? root.tokens : void 0;
+        const accessToken = firstNonEmptyString([
+            tokens?.access_token,
+            root.access_token
+        ]);
+        const accountId = firstNonEmptyString([
+            tokens?.account_id,
+            root.account_id
+        ]);
+        return {
+            accessToken,
+            accountId,
+            authPath
+        };
+    } catch  {
+        return {
+            authPath
+        };
+    }
+}
+function createCodexFetch(options = {}) {
+    const baseFetch = options.baseFetch || globalThis.fetch.bind(globalThis);
+    return async (input, init)=>{
+        const codexAuth = resolveCodexAuthFromFile();
+        const accessToken = codexAuth.accessToken || options.fallbackToken;
+        const accountId = codexAuth.accountId || options.fallbackAccountId;
+        if (!accessToken) throw new Error("Codex credentials missing. Run `codex login` or set CODEX_ACCESS_TOKEN.");
+        const headers = new Headers(init?.headers || {});
+        headers.delete("authorization");
+        headers.delete("x-api-key");
+        headers.set("Authorization", `Bearer ${accessToken}`);
+        if (accountId) headers.set("ChatGPT-Account-ID", accountId);
+        const body = withCodexRequestDefaults(init?.body);
+        const response = await baseFetch(input, {
+            ...init,
+            headers,
+            body
+        });
+        if (!response.ok) {
+            let responseBody = "";
+            try {
+                responseBody = await response.clone().text();
+            } catch  {}
+            const preview = responseBody.trim().slice(0, 1200);
+            logger.warn(`Codex request failed (${response.status} ${response.statusText || ""})`, {
+                url: "string" == typeof input ? input : input instanceof URL ? input.toString() : input.url,
+                bodyPresent: preview.length > 0,
+                bodyPreview: preview || null
+            });
+        }
+        return response;
+    };
+}
+function withCodexRequestDefaults(body) {
+    if ("string" != typeof body || !body.trim()) return body;
+    try {
+        const parsed = JSON.parse(body);
+        if (!parsed || "object" != typeof parsed || Array.isArray(parsed)) return body;
+        const root = stripUnsupportedCodexParams(parsed);
+        const instructions = "string" == typeof root.instructions && root.instructions.trim() ? root.instructions.trim() : extractInstructionsFromInput(root.input) || DEFAULT_CODEX_INSTRUCTIONS;
+        return JSON.stringify({
+            ...root,
+            store: false,
+            instructions
+        });
+    } catch  {
+        return body;
+    }
+}
+function stripUnsupportedCodexParams(payload) {
+    const next = {
+        ...payload
+    };
+    delete next.temperature;
+    return next;
+}
+function extractInstructionsFromInput(input) {
+    if (!Array.isArray(input)) return;
+    for (const item of input){
+        if (!item || "object" != typeof item || Array.isArray(item)) continue;
+        const message = item;
+        const role = "string" == typeof message.role ? message.role : "";
+        if ("system" !== role && "developer" !== role) continue;
+        const text = extractTextContent(message.content);
+        if (text) return text;
+    }
+}
+function extractTextContent(content) {
+    if ("string" == typeof content && content.trim()) return content.trim();
+    if (!Array.isArray(content)) return;
+    for (const part of content){
+        if (!part || "object" != typeof part || Array.isArray(part)) continue;
+        const block = part;
+        const text = "string" == typeof block.text ? block.text : "string" == typeof block.content ? block.content : void 0;
+        if (!text || !text.trim()) continue;
+        const type = "string" == typeof block.type ? block.type : "";
+        if (!type || type.includes("text")) return text.trim();
+    }
+}
+function firstNonEmptyString(values) {
+    for (const value of values)if ("string" == typeof value && value.trim()) return value.trim();
+}
+exports.createCodexFetch = __webpack_exports__.createCodexFetch;
+exports.getCodexAuthPath = __webpack_exports__.getCodexAuthPath;
+exports.resolveCodexAuthFromFile = __webpack_exports__.resolveCodexAuthFromFile;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createCodexFetch",
+    "getCodexAuthPath",
+    "resolveCodexAuthFromFile"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/providers/codex.d.ts

@@ -0,0 +1,15 @@
+type FetchLike = (input: Parameters<typeof fetch>[0], init?: Parameters<typeof fetch>[1]) => ReturnType<typeof fetch>;
+export interface CodexAuthState {
+    accessToken?: string;
+    accountId?: string;
+    authPath: string;
+}
+export interface CodexFetchOptions {
+    baseFetch?: FetchLike;
+    fallbackToken?: string;
+    fallbackAccountId?: string;
+}
+export declare function getCodexAuthPath(): string;
+export declare function resolveCodexAuthFromFile(): CodexAuthState;
+export declare function createCodexFetch(options?: CodexFetchOptions): FetchLike;
+export {};

package/dist/providers/codex.js

@@ -0,0 +1,127 @@
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { createLogger } from "../logger.js";
+const CODEX_HOME_ENV = "CODEX_HOME";
+const CODEX_AUTH_FILE = "auth.json";
+const DEFAULT_CODEX_INSTRUCTIONS = "You are Wingman, a coding assistant. Follow the user's request exactly and keep tool usage focused.";
+const logger = createLogger();
+function getCodexAuthPath() {
+    const codexHome = process.env[CODEX_HOME_ENV]?.trim();
+    if (codexHome) return join(codexHome, CODEX_AUTH_FILE);
+    return join(homedir(), ".codex", CODEX_AUTH_FILE);
+}
+function resolveCodexAuthFromFile() {
+    const authPath = getCodexAuthPath();
+    if (!existsSync(authPath)) return {
+        authPath
+    };
+    try {
+        const parsed = JSON.parse(readFileSync(authPath, "utf-8"));
+        if (!parsed || "object" != typeof parsed) return {
+            authPath
+        };
+        const root = parsed;
+        const tokens = root.tokens && "object" == typeof root.tokens ? root.tokens : void 0;
+        const accessToken = firstNonEmptyString([
+            tokens?.access_token,
+            root.access_token
+        ]);
+        const accountId = firstNonEmptyString([
+            tokens?.account_id,
+            root.account_id
+        ]);
+        return {
+            accessToken,
+            accountId,
+            authPath
+        };
+    } catch  {
+        return {
+            authPath
+        };
+    }
+}
+function createCodexFetch(options = {}) {
+    const baseFetch = options.baseFetch || globalThis.fetch.bind(globalThis);
+    return async (input, init)=>{
+        const codexAuth = resolveCodexAuthFromFile();
+        const accessToken = codexAuth.accessToken || options.fallbackToken;
+        const accountId = codexAuth.accountId || options.fallbackAccountId;
+        if (!accessToken) throw new Error("Codex credentials missing. Run `codex login` or set CODEX_ACCESS_TOKEN.");
+        const headers = new Headers(init?.headers || {});
+        headers.delete("authorization");
+        headers.delete("x-api-key");
+        headers.set("Authorization", `Bearer ${accessToken}`);
+        if (accountId) headers.set("ChatGPT-Account-ID", accountId);
+        const body = withCodexRequestDefaults(init?.body);
+        const response = await baseFetch(input, {
+            ...init,
+            headers,
+            body
+        });
+        if (!response.ok) {
+            let responseBody = "";
+            try {
+                responseBody = await response.clone().text();
+            } catch  {}
+            const preview = responseBody.trim().slice(0, 1200);
+            logger.warn(`Codex request failed (${response.status} ${response.statusText || ""})`, {
+                url: "string" == typeof input ? input : input instanceof URL ? input.toString() : input.url,
+                bodyPresent: preview.length > 0,
+                bodyPreview: preview || null
+            });
+        }
+        return response;
+    };
+}
+function withCodexRequestDefaults(body) {
+    if ("string" != typeof body || !body.trim()) return body;
+    try {
+        const parsed = JSON.parse(body);
+        if (!parsed || "object" != typeof parsed || Array.isArray(parsed)) return body;
+        const root = stripUnsupportedCodexParams(parsed);
+        const instructions = "string" == typeof root.instructions && root.instructions.trim() ? root.instructions.trim() : extractInstructionsFromInput(root.input) || DEFAULT_CODEX_INSTRUCTIONS;
+        return JSON.stringify({
+            ...root,
+            store: false,
+            instructions
+        });
+    } catch  {
+        return body;
+    }
+}
+function stripUnsupportedCodexParams(payload) {
+    const next = {
+        ...payload
+    };
+    delete next.temperature;
+    return next;
+}
+function extractInstructionsFromInput(input) {
+    if (!Array.isArray(input)) return;
+    for (const item of input){
+        if (!item || "object" != typeof item || Array.isArray(item)) continue;
+        const message = item;
+        const role = "string" == typeof message.role ? message.role : "";
+        if ("system" !== role && "developer" !== role) continue;
+        const text = extractTextContent(message.content);
+        if (text) return text;
+    }
+}
+function extractTextContent(content) {
+    if ("string" == typeof content && content.trim()) return content.trim();
+    if (!Array.isArray(content)) return;
+    for (const part of content){
+        if (!part || "object" != typeof part || Array.isArray(part)) continue;
+        const block = part;
+        const text = "string" == typeof block.text ? block.text : "string" == typeof block.content ? block.content : void 0;
+        if (!text || !text.trim()) continue;
+        const type = "string" == typeof block.type ? block.type : "";
+        if (!type || type.includes("text")) return text.trim();
+    }
+}
+function firstNonEmptyString(values) {
+    for (const value of values)if ("string" == typeof value && value.trim()) return value.trim();
+}
+export { createCodexFetch, getCodexAuthPath, resolveCodexAuthFromFile };

package/dist/providers/credentials.cjs

@@ -36,6 +36,7 @@ __webpack_require__.d(__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_codex_cjs_namespaceObject = require("./codex.cjs");
 const external_registry_cjs_namespaceObject = require("./registry.cjs");
 const CREDENTIALS_VERSION = 1;
 const CREDENTIALS_DIR = (0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.homedir)(), ".wingman");
@@ -121,6 +122,13 @@ function resolveProviderToken(providerName) {
             envVar
         };
     }
+    if ("codex" === provider.name) {
+        const codexAuth = (0, external_codex_cjs_namespaceObject.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/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/additionalMessageMiddleware.test.cjs

@@ -40,6 +40,7 @@ const additional_messages_cjs_namespaceObject = require("../agent/middleware/add
         (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.expect)(injected).toBeInstanceOf(external_langchain_namespaceObject.HumanMessage);
     });
     (0, external_vitest_namespaceObject.it)("adds confidentiality guidance without exposing machine details", async ()=>{
         const workspaceRoot = external_node_path_default().resolve("repo");
@@ -59,7 +60,9 @@ const additional_messages_cjs_namespaceObject = require("../agent/middleware/add
         const injected = result.messages[0];
         const content = injected.content ?? "";
         (0, external_vitest_namespaceObject.expect)(content).toContain("Confidentiality");
+        (0, external_vitest_namespaceObject.expect)(content).toContain("inspect system/tool output internally");
         (0, external_vitest_namespaceObject.expect)(content).toContain("Do not disclose");
+        (0, external_vitest_namespaceObject.expect)(content).toContain("Do not quote internal tool call IDs");
         (0, external_vitest_namespaceObject.expect)(content).toContain("Working Directory");
         (0, external_vitest_namespaceObject.expect)(content).toContain("current working directory");
         (0, external_vitest_namespaceObject.expect)(content).toContain("Use relative paths");

package/dist/tests/additionalMessageMiddleware.test.js

@@ -16,6 +16,7 @@ describe("additionalMessageMiddleware", ()=>{
         expect(result.messages).toHaveLength(2);
         const injected = result.messages[0];
         expect(injected.additional_kwargs?.source).toBe("additional-message-middleware");
+        expect(injected).toBeInstanceOf(HumanMessage);
     });
     it("adds confidentiality guidance without exposing machine details", async ()=>{
         const workspaceRoot = node_path.resolve("repo");
@@ -35,7 +36,9 @@ describe("additionalMessageMiddleware", ()=>{
         const injected = result.messages[0];
         const content = injected.content ?? "";
         expect(content).toContain("Confidentiality");
+        expect(content).toContain("inspect system/tool output internally");
         expect(content).toContain("Do not disclose");
+        expect(content).toContain("Do not quote internal tool call IDs");
         expect(content).toContain("Working Directory");
         expect(content).toContain("current working directory");
         expect(content).toContain("Use relative paths");