@wingman-ai/gateway 0.2.2 → 0.2.3

package/dist/gateway/server.js

@@ -1,28 +1,28 @@
-import { NodeManager } from "./node.js";
-import { BroadcastGroupManager } from "./broadcast.js";
-import { GatewayAuth } from "./auth.js";
-import { validateGatewayMessage } from "./validation.js";
-import { getGatewayTokenFromEnv } from "./env.js";
-import { MDNSDiscoveryService, TailscaleDiscoveryService } from "./discovery/index.js";
-import { createLogger } from "../logger.js";
+import { existsSync, mkdirSync, statSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, isAbsolute, join, normalize, sep } from "node:path";
+import { fileURLToPath } from "node:url";
 import { WingmanConfigLoader } from "../cli/config/loader.js";
-import { GatewayRouter } from "./router.js";
-import { OutputManager } from "../cli/core/outputManager.js";
 import { AgentInvoker } from "../cli/core/agentInvoker.js";
+import { OutputManager } from "../cli/core/outputManager.js";
 import { SessionManager } from "../cli/core/sessionManager.js";
+import { createLogger } from "../logger.js";
+import { DiscordGatewayAdapter } from "./adapters/discord.js";
+import { GatewayAuth } from "./auth.js";
+import { BroadcastGroupManager } from "./broadcast.js";
+import { MDNSDiscoveryService, TailscaleDiscoveryService } from "./discovery/index.js";
+import { getGatewayTokenFromEnv } from "./env.js";
+import { InternalHookRegistry } from "./hooks/registry.js";
 import { handleAgentsApi } from "./http/agents.js";
 import { handleFsApi } from "./http/fs.js";
 import { handleProvidersApi } from "./http/providers.js";
-import { handleVoiceApi } from "./http/voice.js";
+import { createRoutineStore, handleRoutinesApi } from "./http/routines.js";
 import { handleSessionsApi } from "./http/sessions.js";
+import { handleVoiceApi } from "./http/voice.js";
 import { createWebhookStore, handleWebhookInvoke, handleWebhooksApi } from "./http/webhooks.js";
-import { createRoutineStore, handleRoutinesApi } from "./http/routines.js";
-import { DiscordGatewayAdapter } from "./adapters/discord.js";
-import { InternalHookRegistry } from "./hooks/registry.js";
-import { homedir } from "node:os";
-import { dirname, isAbsolute, join, normalize, sep } from "node:path";
-import { existsSync, mkdirSync, statSync, writeFileSync } from "node:fs";
-import { fileURLToPath } from "node:url";
+import { NodeManager } from "./node.js";
+import { GatewayRouter } from "./router.js";
+import { validateGatewayMessage } from "./validation.js";
 function _define_property(obj, key, value) {
     if (key in obj) Object.defineProperty(obj, key, {
         value: value,
@@ -319,6 +319,7 @@ class GatewayServer {
             existing?.abortController.abort();
             this.activeAgentRequests.delete(msg.id);
         }
+        this.removeQueuedRequestById(msg.id);
         const payload = msg.payload;
         const content = "string" == typeof payload?.content ? payload.content : "";
         const attachments = Array.isArray(payload?.attachments) ? payload.attachments : [];
@@ -328,6 +329,7 @@ class GatewayServer {
         const agentId = this.router.selectAgent(payload.agentId, payload.routing);
         if (!agentId) return void this.sendAgentError(ws, msg.id, "No agent matched the request");
         const sessionKey = payload.sessionKey || this.router.buildSessionKey(agentId, payload.routing);
+        const sessionQueueKey = this.buildSessionQueueKey(agentId, sessionKey);
         const sessionManager = await this.getSessionManager(agentId);
         const existingSession = sessionManager.getSession(sessionKey);
         const session = existingSession || sessionManager.getOrCreateSession(sessionKey, agentId);
@@ -378,9 +380,70 @@ class GatewayServer {
             ],
             skipSessionId: sessionKey
         });
+        const request = {
+            ws,
+            msg,
+            payload,
+            agentId,
+            sessionKey,
+            sessionQueueKey,
+            content,
+            attachments,
+            sessionManager,
+            workdir,
+            defaultOutputDir
+        };
+        this.requestSessionKeys.set(msg.id, sessionQueueKey);
+        const queueIfBusy = false !== payload.queueIfBusy;
+        const activeRequestId = this.activeSessionRequests.get(sessionQueueKey);
+        if (activeRequestId && queueIfBusy) {
+            const queued = this.queuedSessionRequests.get(sessionQueueKey) || [];
+            queued.push(request);
+            this.queuedSessionRequests.set(sessionQueueKey, queued);
+            const position = queued.length;
+            this.sendMessage(ws, {
+                type: "ack",
+                id: msg.id,
+                payload: {
+                    action: "req:agent",
+                    status: "queued",
+                    requestId: msg.id,
+                    sessionId: sessionKey,
+                    agentId,
+                    position
+                },
+                timestamp: Date.now()
+            });
+            this.sendMessage(ws, {
+                type: "event:agent",
+                id: msg.id,
+                clientId: ws.data.clientId,
+                payload: this.attachSessionContext({
+                    type: "request-queued",
+                    position
+                }, sessionKey, agentId),
+                timestamp: Date.now()
+            });
+            return;
+        }
+        if (activeRequestId && !queueIfBusy) {
+            this.requestSessionKeys.delete(msg.id);
+            this.sendAgentError(ws, msg.id, "Session already has an in-flight request. Set queueIfBusy=true to enqueue.", {
+                sessionId: sessionKey,
+                agentId
+            });
+            return;
+        }
+        this.executeAgentRequest(request);
+    }
+    async executeAgentRequest(request) {
+        const { ws, msg, agentId, sessionKey, sessionQueueKey, content, attachments, sessionManager, workdir, defaultOutputDir } = request;
+        this.activeSessionRequests.set(sessionQueueKey, msg.id);
         const outputManager = new OutputManager("interactive");
+        let emittedAgentError = false;
         const outputHandler = (event)=>{
             const payloadWithSession = this.attachSessionContext(event, sessionKey, agentId);
+            if (payloadWithSession && "object" == typeof payloadWithSession && !Array.isArray(payloadWithSession) && "agent-error" === payloadWithSession.type) emittedAgentError = true;
             const baseMessage = {
                 type: "event:agent",
                 id: msg.id,
@@ -419,41 +482,111 @@ class GatewayServer {
             });
         } catch (error) {
             this.logger.error("Agent invocation failed", error);
+            if (!emittedAgentError) {
+                const message = error instanceof Error ? error.message : String(error);
+                const stack = error instanceof Error ? error.stack : void 0;
+                this.sendAgentError(ws, msg.id, message, {
+                    sessionId: sessionKey,
+                    agentId,
+                    stack,
+                    broadcastToSession: true,
+                    exclude: ws
+                });
+            }
         } finally{
             this.activeAgentRequests.delete(msg.id);
+            this.activeSessionRequests.delete(sessionQueueKey);
+            this.requestSessionKeys.delete(msg.id);
             outputManager.off("output-event", outputHandler);
+            this.processNextQueuedAgentRequest(sessionQueueKey);
         }
     }
+    processNextQueuedAgentRequest(sessionQueueKey) {
+        if (this.activeSessionRequests.has(sessionQueueKey)) return;
+        const queue = this.queuedSessionRequests.get(sessionQueueKey);
+        if (!queue || 0 === queue.length) return void this.queuedSessionRequests.delete(sessionQueueKey);
+        const next = queue.shift();
+        if (!next) return;
+        if (0 === queue.length) this.queuedSessionRequests.delete(sessionQueueKey);
+        else this.queuedSessionRequests.set(sessionQueueKey, queue);
+        this.sendMessage(next.ws, {
+            type: "ack",
+            id: next.msg.id,
+            payload: {
+                action: "req:agent",
+                status: "dequeued",
+                requestId: next.msg.id,
+                sessionId: next.sessionKey,
+                agentId: next.agentId,
+                remaining: queue.length
+            },
+            timestamp: Date.now()
+        });
+        this.executeAgentRequest(next);
+    }
     handleAgentCancel(ws, msg) {
         if (!ws.data.authenticated) return void this.sendError(ws, "AUTH_FAILED", "Client is not authenticated");
         const payload = msg.payload;
         const requestId = "string" == typeof payload?.requestId && payload.requestId || void 0;
         if (!requestId) return void this.sendError(ws, "INVALID_REQUEST", "Missing requestId for cancellation");
         const active = this.activeAgentRequests.get(requestId);
-        if (!active) return void this.sendMessage(ws, {
-            type: "ack",
-            id: msg.id,
-            payload: {
-                action: "req:agent:cancel",
-                requestId,
-                status: "not_found"
-            },
-            timestamp: Date.now()
-        });
-        if (active.socket !== ws) return void this.sendError(ws, "FORBIDDEN", "Cannot cancel a request started by another client");
-        active.abortController.abort();
-        this.activeAgentRequests.delete(requestId);
+        if (active) {
+            if (active.socket !== ws) return void this.sendError(ws, "FORBIDDEN", "Cannot cancel a request started by another client");
+            active.abortController.abort();
+            this.activeAgentRequests.delete(requestId);
+            this.sendMessage(ws, {
+                type: "ack",
+                id: msg.id,
+                payload: {
+                    action: "req:agent:cancel",
+                    requestId,
+                    status: "cancelled"
+                },
+                timestamp: Date.now()
+            });
+            return;
+        }
+        const queued = this.removeQueuedRequestById(requestId);
+        if (queued) {
+            if (queued.ws !== ws) return void this.sendError(ws, "FORBIDDEN", "Cannot cancel a request started by another client");
+            this.sendMessage(ws, {
+                type: "ack",
+                id: msg.id,
+                payload: {
+                    action: "req:agent:cancel",
+                    requestId,
+                    status: "cancelled_queued"
+                },
+                timestamp: Date.now()
+            });
+            return;
+        }
         this.sendMessage(ws, {
             type: "ack",
             id: msg.id,
             payload: {
                 action: "req:agent:cancel",
                 requestId,
-                status: "cancelled"
+                status: "not_found"
             },
             timestamp: Date.now()
         });
     }
+    buildSessionQueueKey(agentId, sessionKey) {
+        return `${agentId}:${sessionKey}`;
+    }
+    removeQueuedRequestById(requestId) {
+        for (const [queueKey, queue] of this.queuedSessionRequests){
+            const index = queue.findIndex((item)=>item.msg.id === requestId);
+            if (-1 === index) continue;
+            const [removed] = queue.splice(index, 1);
+            if (0 === queue.length) this.queuedSessionRequests.delete(queueKey);
+            else this.queuedSessionRequests.set(queueKey, queue);
+            this.requestSessionKeys.delete(requestId);
+            return removed || null;
+        }
+        return null;
+    }
     handleRegister(ws, msg) {
         const payload = msg.payload;
         if (!this.auth.validate({
@@ -616,23 +749,39 @@ class GatewayServer {
             timestamp: Date.now()
         });
     }
-    sendAgentError(ws, requestId, message) {
-        this.sendMessage(ws, {
+    sendAgentError(ws, requestId, message, options) {
+        let payload = {
+            type: "agent-error",
+            error: message,
+            timestamp: new Date().toISOString()
+        };
+        if (options?.stack) payload.stack = options.stack;
+        if (options?.sessionId && options?.agentId) payload = this.attachSessionContext(payload, options.sessionId, options.agentId);
+        const baseMessage = {
             type: "event:agent",
             id: requestId,
-            payload: {
-                type: "agent-error",
-                error: message,
-                timestamp: new Date().toISOString()
-            },
+            payload,
             timestamp: Date.now()
+        };
+        this.sendMessage(ws, {
+            ...baseMessage,
+            clientId: ws.data.clientId
         });
+        if (options?.broadcastToSession && options.sessionId) this.broadcastSessionEvent(options.sessionId, baseMessage, options.exclude);
     }
     cancelSocketAgentRequests(ws) {
         for (const [requestId, active] of this.activeAgentRequests)if (active.socket === ws) {
             active.abortController.abort();
             this.activeAgentRequests.delete(requestId);
         }
+        for (const [queueKey, queue] of this.queuedSessionRequests){
+            const nextQueue = queue.filter((request)=>request.ws !== ws);
+            if (nextQueue.length !== queue.length) {
+                for (const request of queue)if (request.ws === ws && request.msg.id) this.requestSessionKeys.delete(request.msg.id);
+                if (0 === nextQueue.length) this.queuedSessionRequests.delete(queueKey);
+                else this.queuedSessionRequests.set(queueKey, nextQueue);
+            }
+        }
     }
     attachSessionContext(event, sessionId, agentId) {
         if (event && "object" == typeof event && !Array.isArray(event)) return {
@@ -824,9 +973,7 @@ class GatewayServer {
         ];
         for (const candidate of candidates)try {
             if (existsSync(candidate) && statSync(candidate).isDirectory() && existsSync(join(candidate, "index.html"))) return candidate;
-        } catch  {
-            continue;
-        }
+        } catch  {}
         return null;
     }
     async getSessionManager(agentId) {
@@ -1150,6 +1297,9 @@ class GatewayServer {
         _define_property(this, "socketSubscriptions", new Map());
         _define_property(this, "connectedClients", new Set());
         _define_property(this, "activeAgentRequests", new Map());
+        _define_property(this, "activeSessionRequests", new Map());
+        _define_property(this, "queuedSessionRequests", new Map());
+        _define_property(this, "requestSessionKeys", new Map());
         _define_property(this, "bridgeQueues", new Map());
         _define_property(this, "bridgePollWaiters", new Map());
         this.workspace = config.workspace || process.cwd();

package/dist/gateway/types.d.ts

@@ -60,6 +60,7 @@ export interface AgentRequestPayload {
     attachments?: MediaAttachment[];
     routing?: RoutingInfo;
     sessionKey?: string;
+    queueIfBusy?: boolean;
 }
 export interface AgentCancelPayload {
     requestId: string;

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 {