@wingman-ai/gateway 0.1.0

package/dist/logger.js

@@ -0,0 +1,215 @@
+import { appendFileSync, existsSync, mkdirSync, renameSync, statSync, unlinkSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { homedir } from "node:os";
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+const DEFAULT_LOG_FILE_NAME = "wingman.log";
+const DEFAULT_LOG_DIR = join(homedir(), ".wingman", "logs");
+const DEFAULT_MAX_BYTES = parsePositiveInt(process.env.WINGMAN_LOG_MAX_BYTES, 5242880);
+const DEFAULT_MAX_FILES = parsePositiveInt(process.env.WINGMAN_LOG_MAX_FILES, 5);
+function serializeLogArg(arg) {
+    const isError = "function" == typeof Error.isError ? Error.isError(arg) : arg instanceof Error;
+    if (isError) return {
+        name: arg.name,
+        message: arg.message,
+        stack: arg.stack
+    };
+    return arg;
+}
+function parsePositiveInt(value, fallback) {
+    if (!value) return fallback;
+    const parsed = Number.parseInt(value, 10);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+function resolveDefaultLogFileName() {
+    const isoDate = new Date().toISOString().slice(0, 10);
+    return `wingman-${isoDate}.log`;
+}
+function resolveLogFilePath() {
+    const explicitFile = process.env.WINGMAN_LOG_FILE;
+    if (explicitFile && explicitFile.trim().length > 0) return explicitFile;
+    const logDir = process.env.WINGMAN_LOG_DIR?.trim() || DEFAULT_LOG_DIR;
+    return join(logDir, resolveDefaultLogFileName() || DEFAULT_LOG_FILE_NAME);
+}
+function getLogFilePath() {
+    return resolveLogFilePath();
+}
+function writeToLogFile(chunk) {
+    const text = "string" == typeof chunk ? chunk : chunk.toString("utf-8");
+    getSharedFileWriter().write(text);
+}
+class RollingFileWriter {
+    write(chunk) {
+        try {
+            this.ensureInitialized();
+            const bytes = Buffer.byteLength(chunk);
+            if (this.currentSize + bytes > this.maxBytes) {
+                this.rotate();
+                this.currentSize = 0;
+            }
+            appendFileSync(this.filePath, chunk);
+            this.currentSize += bytes;
+        } catch  {}
+    }
+    ensureInitialized() {
+        if (this.initialized) return;
+        this.initialized = true;
+        mkdirSync(dirname(this.filePath), {
+            recursive: true
+        });
+        if (existsSync(this.filePath)) this.currentSize = statSync(this.filePath).size;
+    }
+    rotate() {
+        try {
+            const oldest = `${this.filePath}.${this.maxFiles}`;
+            if (existsSync(oldest)) unlinkSync(oldest);
+            for(let i = this.maxFiles - 1; i >= 1; i--){
+                const source = `${this.filePath}.${i}`;
+                if (existsSync(source)) renameSync(source, `${this.filePath}.${i + 1}`);
+            }
+            if (existsSync(this.filePath)) renameSync(this.filePath, `${this.filePath}.1`);
+        } catch  {}
+    }
+    constructor(filePath, maxBytes, maxFiles){
+        _define_property(this, "currentSize", 0);
+        _define_property(this, "initialized", false);
+        _define_property(this, "filePath", void 0);
+        _define_property(this, "maxBytes", void 0);
+        _define_property(this, "maxFiles", void 0);
+        this.filePath = filePath;
+        this.maxBytes = Math.max(1, maxBytes);
+        this.maxFiles = Math.max(1, maxFiles);
+    }
+}
+let sharedFileWriter = null;
+function getSharedFileWriter() {
+    if (!sharedFileWriter) sharedFileWriter = new RollingFileWriter(resolveLogFilePath(), DEFAULT_MAX_BYTES, DEFAULT_MAX_FILES);
+    return sharedFileWriter;
+}
+class WingmanLogger {
+    shouldLog(level) {
+        const levels = [
+            "debug",
+            "info",
+            "warn",
+            "error",
+            "silent"
+        ];
+        const currentIndex = levels.indexOf(this.level);
+        const messageIndex = levels.indexOf(level);
+        return "silent" !== this.level && messageIndex >= currentIndex;
+    }
+    log(level, message, ...args) {
+        if (!this.shouldLog(level)) return;
+        const timestamp = new Date().toISOString();
+        const prefix = `[${timestamp}] [${level.toUpperCase()}]`;
+        this.output.write(`${prefix} ${message}\n`);
+        if (args.length > 0) {
+            const serialized = args.map((arg)=>serializeLogArg(arg));
+            this.output.write(`${JSON.stringify(serialized, null, 2)}\n`);
+        }
+    }
+    debug(message, ...args) {
+        this.log("debug", message, ...args);
+    }
+    info(message, ...args) {
+        this.log("info", message, ...args);
+    }
+    warn(message, ...args) {
+        this.log("warn", message, ...args);
+    }
+    error(message, ...args) {
+        this.log("error", message, ...args);
+    }
+    constructor(level = "info", output = getSharedFileWriter()){
+        _define_property(this, "level", void 0);
+        _define_property(this, "output", void 0);
+        this.level = level;
+        this.output = output;
+    }
+}
+class SilentLogger {
+    debug() {}
+    info() {}
+    warn() {}
+    error() {}
+}
+function createLogger(level = process.env.WINGMAN_LOG_LEVEL || "info") {
+    if ("silent" === level) return new SilentLogger();
+    return new WingmanLogger(level);
+}
+function createLoggerFromConfig(config) {
+    return createLogger(config.level);
+}
+class EventLogger {
+    shouldLog(level) {
+        const levels = [
+            "debug",
+            "info",
+            "warn",
+            "error",
+            "silent"
+        ];
+        const currentIndex = levels.indexOf(this.level);
+        const messageIndex = levels.indexOf(level);
+        return "silent" !== this.level && messageIndex >= currentIndex;
+    }
+    log(level, message, ...args) {
+        if (!this.shouldLog(level)) return;
+        this.callback({
+            level,
+            message,
+            timestamp: new Date().toISOString(),
+            args: args.length > 0 ? args : void 0
+        });
+        if (!this.secondaryLogger) return;
+        switch(level){
+            case "debug":
+                this.secondaryLogger.debug(message, ...args);
+                break;
+            case "info":
+                this.secondaryLogger.info(message, ...args);
+                break;
+            case "warn":
+                this.secondaryLogger.warn(message, ...args);
+                break;
+            case "error":
+                this.secondaryLogger.error(message, ...args);
+                break;
+            case "silent":
+                break;
+        }
+    }
+    debug(message, ...args) {
+        this.log("debug", message, ...args);
+    }
+    info(message, ...args) {
+        this.log("info", message, ...args);
+    }
+    warn(message, ...args) {
+        this.log("warn", message, ...args);
+    }
+    error(message, ...args) {
+        this.log("error", message, ...args);
+    }
+    constructor(callback, level = "info", secondaryLogger){
+        _define_property(this, "callback", void 0);
+        _define_property(this, "level", void 0);
+        _define_property(this, "secondaryLogger", void 0);
+        this.callback = callback;
+        this.level = level;
+        this.secondaryLogger = secondaryLogger;
+    }
+}
+function createEventLogger(callback, level = "info") {
+    return new EventLogger(callback, level, createLogger(level));
+}
+export { EventLogger, SilentLogger, WingmanLogger, createEventLogger, createLogger, createLoggerFromConfig, getLogFilePath, writeToLogFile };

package/dist/providers/copilot.cjs

@@ -0,0 +1,148 @@
+"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__, {
+    createCopilotFetch: ()=>createCopilotFetch
+});
+const external_credentials_cjs_namespaceObject = require("./credentials.cjs");
+const external_registry_cjs_namespaceObject = require("./registry.cjs");
+const COPILOT_HEADERS = {
+    "User-Agent": "GitHubCopilotChat/0.35.0",
+    "Editor-Version": "vscode/1.107.0",
+    "Editor-Plugin-Version": "copilot-chat/0.35.0",
+    "Copilot-Integration-Id": "vscode-chat"
+};
+const RESPONSES_API_ALTERNATE_INPUT_TYPES = new Set([
+    "file_search_call",
+    "computer_call",
+    "computer_call_output",
+    "web_search_call",
+    "function_call",
+    "function_call_output",
+    "image_generation_call",
+    "code_interpreter_call",
+    "local_shell_call",
+    "local_shell_call_output",
+    "mcp_list_tools",
+    "mcp_approval_request",
+    "mcp_approval_response",
+    "mcp_call",
+    "reasoning"
+]);
+const REFRESH_BUFFER_MS = 300000;
+function createCopilotFetch() {
+    const baseFetch = globalThis.fetch.bind(globalThis);
+    return async (input, init)=>{
+        const accessToken = await resolveCopilotAccessToken(baseFetch);
+        const { isAgentCall, isVisionRequest } = inspectRequest(init?.body);
+        const headers = new Headers(init?.headers || {});
+        headers.delete("authorization");
+        headers.delete("x-api-key");
+        for (const [key, value] of Object.entries(COPILOT_HEADERS))headers.set(key, value);
+        headers.set("Authorization", `Bearer ${accessToken}`);
+        headers.set("Openai-Intent", "conversation-edits");
+        headers.set("X-Initiator", isAgentCall ? "agent" : "user");
+        if (isVisionRequest) headers.set("Copilot-Vision-Request", "true");
+        return baseFetch(input, {
+            ...init,
+            headers
+        });
+    };
+}
+async function resolveCopilotAccessToken(baseFetch) {
+    const provider = (0, external_registry_cjs_namespaceObject.getProviderSpec)("copilot");
+    const credentials = (0, external_credentials_cjs_namespaceObject.getProviderCredentials)("copilot");
+    const envToken = (0, external_credentials_cjs_namespaceObject.resolveProviderToken)("copilot").token;
+    const refreshToken = credentials?.refreshToken || credentials?.accessToken || credentials?.apiKey || envToken;
+    if (!refreshToken) throw new Error("Copilot credentials missing. Run `wingman provider login copilot`.");
+    const expiresAt = credentials?.expiresAt ? Date.parse(credentials.expiresAt) : void 0;
+    const hasValidAccessToken = Boolean(credentials?.accessToken) && (!expiresAt || expiresAt > Date.now() + REFRESH_BUFFER_MS);
+    if (hasValidAccessToken && credentials?.accessToken) return credentials.accessToken;
+    const tokenUrl = buildCopilotTokenUrl(provider?.baseURL);
+    const response = await baseFetch(tokenUrl, {
+        headers: {
+            Accept: "application/json",
+            Authorization: `Bearer ${refreshToken}`,
+            ...COPILOT_HEADERS
+        }
+    });
+    if (!response.ok) throw new Error(`Copilot token refresh failed: ${response.status}`);
+    const tokenData = await response.json();
+    if (!tokenData.token) throw new Error("Copilot token refresh failed: missing token.");
+    const expiresAtIso = computeExpiry(tokenData);
+    (0, external_credentials_cjs_namespaceObject.setProviderCredentials)("copilot", {
+        accessToken: tokenData.token,
+        expiresAt: expiresAtIso
+    });
+    return tokenData.token;
+}
+function buildCopilotTokenUrl(baseURL) {
+    const fallback = "https://api.githubcopilot.com";
+    const root = baseURL || fallback;
+    return new URL("/copilot_internal/v2/token", root).toString();
+}
+function computeExpiry(tokenData) {
+    if (tokenData.expires_at) return new Date(1000 * tokenData.expires_at - REFRESH_BUFFER_MS).toISOString();
+    if (tokenData.expires_in) return new Date(Date.now() + 1000 * tokenData.expires_in - REFRESH_BUFFER_MS).toISOString();
+}
+function inspectRequest(body) {
+    let isAgentCall = false;
+    let isVisionRequest = false;
+    if (!body || "string" != typeof body) return {
+        isAgentCall,
+        isVisionRequest
+    };
+    try {
+        const parsed = JSON.parse(body);
+        if (parsed?.messages) {
+            if (parsed.messages.length > 0) {
+                const lastMessage = parsed.messages[parsed.messages.length - 1];
+                isAgentCall = lastMessage?.role && [
+                    "tool",
+                    "assistant"
+                ].includes(lastMessage.role);
+            }
+            isVisionRequest = parsed.messages.some((message)=>Array.isArray(message?.content) && message.content.some((part)=>part?.type === "image_url"));
+        }
+        if (parsed?.input) {
+            const lastInput = parsed.input[parsed.input.length - 1];
+            const isAssistant = lastInput?.role === "assistant";
+            const hasAgentType = lastInput?.type ? RESPONSES_API_ALTERNATE_INPUT_TYPES.has(lastInput.type) : false;
+            isAgentCall = isAssistant || hasAgentType;
+            isVisionRequest = Array.isArray(lastInput?.content) && lastInput.content.some((part)=>part?.type === "input_image");
+        }
+    } catch  {}
+    return {
+        isAgentCall,
+        isVisionRequest
+    };
+}
+exports.createCopilotFetch = __webpack_exports__.createCopilotFetch;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createCopilotFetch"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/providers/copilot.d.ts

@@ -0,0 +1,3 @@
+type FetchLike = (input: Parameters<typeof fetch>[0], init?: Parameters<typeof fetch>[1]) => ReturnType<typeof fetch>;
+export declare function createCopilotFetch(): FetchLike;
+export {};

package/dist/providers/copilot.js

@@ -0,0 +1,114 @@
+import { getProviderCredentials, resolveProviderToken, setProviderCredentials } from "./credentials.js";
+import { getProviderSpec } from "./registry.js";
+const COPILOT_HEADERS = {
+    "User-Agent": "GitHubCopilotChat/0.35.0",
+    "Editor-Version": "vscode/1.107.0",
+    "Editor-Plugin-Version": "copilot-chat/0.35.0",
+    "Copilot-Integration-Id": "vscode-chat"
+};
+const RESPONSES_API_ALTERNATE_INPUT_TYPES = new Set([
+    "file_search_call",
+    "computer_call",
+    "computer_call_output",
+    "web_search_call",
+    "function_call",
+    "function_call_output",
+    "image_generation_call",
+    "code_interpreter_call",
+    "local_shell_call",
+    "local_shell_call_output",
+    "mcp_list_tools",
+    "mcp_approval_request",
+    "mcp_approval_response",
+    "mcp_call",
+    "reasoning"
+]);
+const REFRESH_BUFFER_MS = 300000;
+function createCopilotFetch() {
+    const baseFetch = globalThis.fetch.bind(globalThis);
+    return async (input, init)=>{
+        const accessToken = await resolveCopilotAccessToken(baseFetch);
+        const { isAgentCall, isVisionRequest } = inspectRequest(init?.body);
+        const headers = new Headers(init?.headers || {});
+        headers.delete("authorization");
+        headers.delete("x-api-key");
+        for (const [key, value] of Object.entries(COPILOT_HEADERS))headers.set(key, value);
+        headers.set("Authorization", `Bearer ${accessToken}`);
+        headers.set("Openai-Intent", "conversation-edits");
+        headers.set("X-Initiator", isAgentCall ? "agent" : "user");
+        if (isVisionRequest) headers.set("Copilot-Vision-Request", "true");
+        return baseFetch(input, {
+            ...init,
+            headers
+        });
+    };
+}
+async function resolveCopilotAccessToken(baseFetch) {
+    const provider = getProviderSpec("copilot");
+    const credentials = getProviderCredentials("copilot");
+    const envToken = resolveProviderToken("copilot").token;
+    const refreshToken = credentials?.refreshToken || credentials?.accessToken || credentials?.apiKey || envToken;
+    if (!refreshToken) throw new Error("Copilot credentials missing. Run `wingman provider login copilot`.");
+    const expiresAt = credentials?.expiresAt ? Date.parse(credentials.expiresAt) : void 0;
+    const hasValidAccessToken = Boolean(credentials?.accessToken) && (!expiresAt || expiresAt > Date.now() + REFRESH_BUFFER_MS);
+    if (hasValidAccessToken && credentials?.accessToken) return credentials.accessToken;
+    const tokenUrl = buildCopilotTokenUrl(provider?.baseURL);
+    const response = await baseFetch(tokenUrl, {
+        headers: {
+            Accept: "application/json",
+            Authorization: `Bearer ${refreshToken}`,
+            ...COPILOT_HEADERS
+        }
+    });
+    if (!response.ok) throw new Error(`Copilot token refresh failed: ${response.status}`);
+    const tokenData = await response.json();
+    if (!tokenData.token) throw new Error("Copilot token refresh failed: missing token.");
+    const expiresAtIso = computeExpiry(tokenData);
+    setProviderCredentials("copilot", {
+        accessToken: tokenData.token,
+        expiresAt: expiresAtIso
+    });
+    return tokenData.token;
+}
+function buildCopilotTokenUrl(baseURL) {
+    const fallback = "https://api.githubcopilot.com";
+    const root = baseURL || fallback;
+    return new URL("/copilot_internal/v2/token", root).toString();
+}
+function computeExpiry(tokenData) {
+    if (tokenData.expires_at) return new Date(1000 * tokenData.expires_at - REFRESH_BUFFER_MS).toISOString();
+    if (tokenData.expires_in) return new Date(Date.now() + 1000 * tokenData.expires_in - REFRESH_BUFFER_MS).toISOString();
+}
+function inspectRequest(body) {
+    let isAgentCall = false;
+    let isVisionRequest = false;
+    if (!body || "string" != typeof body) return {
+        isAgentCall,
+        isVisionRequest
+    };
+    try {
+        const parsed = JSON.parse(body);
+        if (parsed?.messages) {
+            if (parsed.messages.length > 0) {
+                const lastMessage = parsed.messages[parsed.messages.length - 1];
+                isAgentCall = lastMessage?.role && [
+                    "tool",
+                    "assistant"
+                ].includes(lastMessage.role);
+            }
+            isVisionRequest = parsed.messages.some((message)=>Array.isArray(message?.content) && message.content.some((part)=>part?.type === "image_url"));
+        }
+        if (parsed?.input) {
+            const lastInput = parsed.input[parsed.input.length - 1];
+            const isAssistant = lastInput?.role === "assistant";
+            const hasAgentType = lastInput?.type ? RESPONSES_API_ALTERNATE_INPUT_TYPES.has(lastInput.type) : false;
+            isAgentCall = isAssistant || hasAgentType;
+            isVisionRequest = Array.isArray(lastInput?.content) && lastInput.content.some((part)=>part?.type === "input_image");
+        }
+    } catch  {}
+    return {
+        isAgentCall,
+        isVisionRequest
+    };
+}
+export { createCopilotFetch };

package/dist/providers/credentials.cjs

@@ -0,0 +1,154 @@
+"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__, {
+    saveProviderToken: ()=>saveProviderToken,
+    readCredentialsFile: ()=>readCredentialsFile,
+    deleteProviderCredentials: ()=>deleteProviderCredentials,
+    writeCredentialsFile: ()=>writeCredentialsFile,
+    getProviderCredentials: ()=>getProviderCredentials,
+    getCredentialsPath: ()=>getCredentialsPath,
+    setProviderCredentials: ()=>setProviderCredentials,
+    resolveProviderToken: ()=>resolveProviderToken
+});
+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_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");
+const CREDENTIALS_PATH = (0, external_node_path_namespaceObject.join)(CREDENTIALS_DIR, "credentials.json");
+function getCredentialsPath() {
+    return CREDENTIALS_PATH;
+}
+function emptyCredentials() {
+    return {
+        version: CREDENTIALS_VERSION,
+        updatedAt: new Date().toISOString(),
+        providers: {}
+    };
+}
+function readCredentialsFile() {
+    if (!(0, external_node_fs_namespaceObject.existsSync)(CREDENTIALS_PATH)) return emptyCredentials();
+    try {
+        const raw = (0, external_node_fs_namespaceObject.readFileSync)(CREDENTIALS_PATH, "utf-8");
+        const parsed = JSON.parse(raw);
+        const providers = parsed && "object" == typeof parsed.providers && parsed.providers ? parsed.providers : {};
+        return {
+            version: "number" == typeof parsed?.version ? parsed.version : CREDENTIALS_VERSION,
+            updatedAt: "string" == typeof parsed?.updatedAt ? parsed.updatedAt : new Date().toISOString(),
+            providers
+        };
+    } catch  {
+        return emptyCredentials();
+    }
+}
+function writeCredentialsFile(data) {
+    (0, external_node_fs_namespaceObject.mkdirSync)(CREDENTIALS_DIR, {
+        recursive: true
+    });
+    (0, external_node_fs_namespaceObject.writeFileSync)(CREDENTIALS_PATH, JSON.stringify(data, null, 2));
+}
+function getProviderCredentials(provider) {
+    const file = readCredentialsFile();
+    return file.providers[provider];
+}
+function setProviderCredentials(provider, credentials) {
+    const file = readCredentialsFile();
+    file.providers[provider] = {
+        ...file.providers[provider] || {},
+        ...credentials
+    };
+    file.updatedAt = new Date().toISOString();
+    writeCredentialsFile(file);
+}
+function deleteProviderCredentials(provider) {
+    const file = readCredentialsFile();
+    if (!file.providers[provider]) return false;
+    delete file.providers[provider];
+    file.updatedAt = new Date().toISOString();
+    writeCredentialsFile(file);
+    return true;
+}
+function saveProviderToken(providerName, token) {
+    const provider = (0, external_registry_cjs_namespaceObject.getProviderSpec)(providerName);
+    if (!provider) throw new Error(`Unknown provider: "${providerName}"`);
+    const normalized = token.trim();
+    if (!normalized) throw new Error("Token is required");
+    const existing = getProviderCredentials(provider.name) || {};
+    const updated = {
+        ...existing
+    };
+    if ("oauth" === provider.type) {
+        updated.accessToken = normalized;
+        updated.tokenType = "bearer";
+    } else updated.apiKey = normalized;
+    setProviderCredentials(provider.name, updated);
+    return updated;
+}
+function resolveProviderToken(providerName) {
+    const provider = (0, external_registry_cjs_namespaceObject.getProviderSpec)(providerName);
+    if (!provider) return {
+        source: "missing"
+    };
+    for (const envVar of provider.envVars){
+        const value = process.env[envVar];
+        if (value && value.trim()) return {
+            token: value.trim(),
+            source: "env",
+            envVar
+        };
+    }
+    const credentials = getProviderCredentials(provider.name);
+    const token = credentials?.accessToken ?? credentials?.apiKey ?? credentials?.refreshToken;
+    if (token && token.trim()) return {
+        token: token.trim(),
+        source: "credentials"
+    };
+    return {
+        source: "missing"
+    };
+}
+exports.deleteProviderCredentials = __webpack_exports__.deleteProviderCredentials;
+exports.getCredentialsPath = __webpack_exports__.getCredentialsPath;
+exports.getProviderCredentials = __webpack_exports__.getProviderCredentials;
+exports.readCredentialsFile = __webpack_exports__.readCredentialsFile;
+exports.resolveProviderToken = __webpack_exports__.resolveProviderToken;
+exports.saveProviderToken = __webpack_exports__.saveProviderToken;
+exports.setProviderCredentials = __webpack_exports__.setProviderCredentials;
+exports.writeCredentialsFile = __webpack_exports__.writeCredentialsFile;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "deleteProviderCredentials",
+    "getCredentialsPath",
+    "getProviderCredentials",
+    "readCredentialsFile",
+    "resolveProviderToken",
+    "saveProviderToken",
+    "setProviderCredentials",
+    "writeCredentialsFile"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/providers/credentials.d.ts

@@ -0,0 +1,26 @@
+import { type ProviderName } from "./registry.js";
+export interface ProviderCredentials {
+    apiKey?: string;
+    accessToken?: string;
+    refreshToken?: string;
+    expiresAt?: string;
+    tokenType?: string;
+}
+export interface ProviderCredentialsFile {
+    version: number;
+    updatedAt: string;
+    providers: Record<string, ProviderCredentials>;
+}
+export type ProviderAuthSource = "env" | "credentials" | "missing";
+export declare function getCredentialsPath(): string;
+export declare function readCredentialsFile(): ProviderCredentialsFile;
+export declare function writeCredentialsFile(data: ProviderCredentialsFile): void;
+export declare function getProviderCredentials(provider: ProviderName): ProviderCredentials | undefined;
+export declare function setProviderCredentials(provider: ProviderName, credentials: ProviderCredentials): void;
+export declare function deleteProviderCredentials(provider: ProviderName): boolean;
+export declare function saveProviderToken(providerName: string, token: string): ProviderCredentials;
+export declare function resolveProviderToken(providerName: string): {
+    token?: string;
+    source: ProviderAuthSource;
+    envVar?: string;
+};