@wingman-ai/gateway 0.1.0

package/dist/tools/mcp-finance.js

@@ -0,0 +1,631 @@
+import * as __rspack_external__finance_candleRange_js_37dcd2cb from "./finance/candleRange.js";
+import * as __rspack_external__finance_optionsAnalytics_js_b4458756 from "./finance/optionsAnalytics.js";
+import * as __rspack_external__finance_technicalIndicators_js_d909860a from "./finance/technicalIndicators.js";
+import * as __rspack_external__finance_yahooCandles_js_99c2b945 from "./finance/yahooCandles.js";
+import * as __rspack_external__modelcontextprotocol_sdk_server_mcp_js_2c42c5d0 from "@modelcontextprotocol/sdk/server/mcp.js";
+import * as __rspack_external__modelcontextprotocol_sdk_server_stdio_js_4f861174 from "@modelcontextprotocol/sdk/server/stdio.js";
+import * as __rspack_external_zod from "zod";
+var __webpack_modules__ = {
+    "./src/tools/mcp-finance.ts" (module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.a(module, async function(__rspack_load_async_deps, __rspack_async_done) {
+            try {
+                __webpack_require__.r(__webpack_exports__);
+                var _modelcontextprotocol_sdk_server_mcp_js__rspack_import_0 = __webpack_require__("@modelcontextprotocol/sdk/server/mcp.js");
+                var _modelcontextprotocol_sdk_server_stdio_js__rspack_import_1 = __webpack_require__("@modelcontextprotocol/sdk/server/stdio.js");
+                var zod__rspack_import_2 = __webpack_require__("zod");
+                var _finance_technicalIndicators_js__rspack_import_3 = __webpack_require__("./finance/technicalIndicators.js");
+                var _finance_optionsAnalytics_js__rspack_import_4 = __webpack_require__("./finance/optionsAnalytics.js");
+                var _finance_candleRange_js__rspack_import_5 = __webpack_require__("./finance/candleRange.js");
+                var _finance_yahooCandles_js__rspack_import_6 = __webpack_require__("./finance/yahooCandles.js");
+                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_RATE_LIMIT_PER_MIN = 60;
+                const DEFAULT_WINDOW_MS = 60000;
+                const DEFAULT_MAX_RETRIES = 4;
+                const DEFAULT_BACKOFF_BASE_MS = 500;
+                const DEFAULT_BACKOFF_MAX_MS = 8000;
+                const FINNHUB_BASE_URL = process.env.FINNHUB_BASE_URL?.trim() || "https://finnhub.io/api/v1";
+                const YAHOO_FINANCE_BASE_URL = process.env.YAHOO_FINANCE_BASE_URL?.trim() || "https://query1.finance.yahoo.com";
+                const FINNHUB_API_KEY = process.env.FINNHUB_API_KEY?.trim();
+                const candleProvider = process.env.FINNHUB_CANDLES_PROVIDER?.trim().toLowerCase() || "yahoo";
+                const yahooIncludePrePost = process.env.YAHOO_INCLUDE_PREPOST?.trim() === "1";
+                if (!FINNHUB_API_KEY) {
+                    console.error("FINNHUB_API_KEY is required to run the MCP finance server.");
+                    process.exit(1);
+                }
+                const tier = process.env.FINNHUB_TIER?.trim().toLowerCase();
+                const tierOverridesRaw = process.env.FINNHUB_TIER_LIMITS;
+                let tierOverrides = {};
+                if (tierOverridesRaw) try {
+                    const parsed = JSON.parse(tierOverridesRaw);
+                    if (parsed && "object" == typeof parsed) tierOverrides = parsed;
+                } catch  {
+                    console.error("Invalid FINNHUB_TIER_LIMITS JSON. Expected format: {\"free\":60,\"pro\":300}");
+                }
+                const tierLimit = (()=>{
+                    if (!tier) return;
+                    const defaults = {
+                        free: 60
+                    };
+                    return tierOverrides[tier] ?? defaults[tier];
+                })();
+                const rateLimitPerMin = Number.parseInt(process.env.FINNHUB_RATE_LIMIT_PER_MIN || "", 10) || tierLimit || DEFAULT_RATE_LIMIT_PER_MIN;
+                const windowMs = Number.parseInt(process.env.FINNHUB_RATE_LIMIT_WINDOW_MS || "", 10) || DEFAULT_WINDOW_MS;
+                const maxRetries = Number.parseInt(process.env.FINNHUB_MAX_RETRIES || "", 10) || DEFAULT_MAX_RETRIES;
+                const backoffBaseMs = Number.parseInt(process.env.FINNHUB_BACKOFF_BASE_MS || "", 10) || DEFAULT_BACKOFF_BASE_MS;
+                const backoffMaxMs = Number.parseInt(process.env.FINNHUB_BACKOFF_MAX_MS || "", 10) || DEFAULT_BACKOFF_MAX_MS;
+                const parsePositiveInt = (value)=>{
+                    const parsed = Number.parseInt(value ?? "", 10);
+                    return Number.isFinite(parsed) && parsed > 0 ? parsed : void 0;
+                };
+                const maxIntradayDays = parsePositiveInt(process.env.FINNHUB_CANDLE_MAX_DAYS_INTRADAY) ?? _finance_candleRange_js__rspack_import_5.DEFAULT_CANDLE_MAX_DAYS_INTRADAY;
+                const maxDailyDays = parsePositiveInt(process.env.FINNHUB_CANDLE_MAX_DAYS_DAILY) ?? _finance_candleRange_js__rspack_import_5.DEFAULT_CANDLE_MAX_DAYS_DAILY;
+                const candleCapSummary = `Intraday capped to ${maxIntradayDays}d; daily+ capped to ${maxDailyDays}d.`;
+                const candleSourceSummary = "finnhub" === candleProvider ? "Source: Finnhub." : "auto" === candleProvider ? "Source: Finnhub with Yahoo fallback." : "Source: Yahoo Finance (best effort).";
+                const candleSessionSummary = yahooIncludePrePost ? "Includes pre/post market data." : "Regular session only.";
+                class RateLimiter {
+                    async wait() {
+                        let release;
+                        const previous = this.queue;
+                        this.queue = new Promise((resolve)=>{
+                            release = resolve;
+                        });
+                        await previous;
+                        try {
+                            await this.acquire();
+                        } finally{
+                            release();
+                        }
+                    }
+                    async acquire() {
+                        this.resetIfNeeded();
+                        if (this.tokens > 0) {
+                            this.tokens -= 1;
+                            return;
+                        }
+                        const waitMs = this.windowStart + this.windowDurationMs - Date.now();
+                        if (waitMs > 0) await sleep(waitMs);
+                        this.resetWindow();
+                        this.tokens -= 1;
+                    }
+                    resetIfNeeded() {
+                        if (Date.now() - this.windowStart >= this.windowDurationMs) this.resetWindow();
+                    }
+                    resetWindow() {
+                        this.windowStart = Date.now();
+                        this.tokens = this.limit;
+                    }
+                    constructor(limit, windowDurationMs){
+                        _define_property(this, "limit", void 0);
+                        _define_property(this, "windowDurationMs", void 0);
+                        _define_property(this, "tokens", void 0);
+                        _define_property(this, "windowStart", void 0);
+                        _define_property(this, "queue", void 0);
+                        this.limit = limit;
+                        this.windowDurationMs = windowDurationMs;
+                        this.queue = Promise.resolve();
+                        this.tokens = limit;
+                        this.windowStart = Date.now();
+                    }
+                }
+                const rateLimiter = new RateLimiter(rateLimitPerMin, windowMs);
+                const sleep = (ms)=>new Promise((resolve)=>setTimeout(resolve, ms));
+                const buildUrl = (path, params)=>{
+                    const url = new URL(`${FINNHUB_BASE_URL}${path}`);
+                    for (const [key, value] of Object.entries(params))if (null != value && "" !== value) url.searchParams.set(key, value);
+                    url.searchParams.set("token", FINNHUB_API_KEY);
+                    return url.toString();
+                };
+                const parseRetryAfter = (value)=>{
+                    if (!value) return null;
+                    const seconds = Number.parseFloat(value);
+                    if (!Number.isNaN(seconds)) return Math.max(0, 1000 * seconds);
+                    const parsed = Date.parse(value);
+                    if (!Number.isNaN(parsed)) return Math.max(0, parsed - Date.now());
+                    return null;
+                };
+                const fetchWithBackoff = async (url)=>{
+                    let attempt = 0;
+                    let delay = backoffBaseMs;
+                    for(;;){
+                        const response = await fetch(url, {
+                            headers: {
+                                "User-Agent": "wingman-mcp-finance"
+                            }
+                        });
+                        if (429 !== response.status) return response;
+                        attempt += 1;
+                        if (attempt > maxRetries) return response;
+                        const retryAfter = parseRetryAfter(response.headers.get("retry-after"));
+                        const jitter = Math.round(250 * Math.random());
+                        const waitMs = Math.min(backoffMaxMs, retryAfter ?? delay + jitter);
+                        await sleep(waitMs);
+                        delay = Math.min(backoffMaxMs, 2 * delay);
+                    }
+                };
+                const fetchFinnhub = async (path, params)=>{
+                    await rateLimiter.wait();
+                    const url = buildUrl(path, params);
+                    const response = await fetchWithBackoff(url);
+                    if (!response.ok) {
+                        const errorBody = await response.text();
+                        throw new Error(`Finnhub error ${response.status}: ${errorBody}`);
+                    }
+                    return await response.json();
+                };
+                const fetchYahooCandles = async ({ symbol, resolution, from, to })=>{
+                    const interval = (0, _finance_yahooCandles_js__rspack_import_6.mapYahooInterval)(resolution);
+                    const url = (0, _finance_yahooCandles_js__rspack_import_6.buildYahooChartUrl)({
+                        baseUrl: YAHOO_FINANCE_BASE_URL,
+                        symbol,
+                        from,
+                        to,
+                        interval,
+                        includePrePost: yahooIncludePrePost
+                    });
+                    const response = await fetchWithBackoff(url);
+                    if (!response.ok) {
+                        const errorBody = await response.text();
+                        return {
+                            s: "error",
+                            source: "yahoo",
+                            error: `Yahoo error ${response.status}: ${errorBody}`
+                        };
+                    }
+                    const payload = await response.json();
+                    return (0, _finance_yahooCandles_js__rspack_import_6.extractYahooCandles)(payload);
+                };
+                const isFinnhubForbidden = (error)=>error instanceof Error && /\b403\b/.test(error.message);
+                const fetchCandlesWithFallback = async ({ symbol, resolution, from, to })=>{
+                    if ("yahoo" === candleProvider) {
+                        const data = await fetchYahooCandles({
+                            symbol,
+                            resolution,
+                            from,
+                            to
+                        });
+                        return {
+                            data,
+                            source: "yahoo"
+                        };
+                    }
+                    if ("finnhub" === candleProvider) {
+                        const data = await fetchFinnhub("/stock/candle", {
+                            symbol,
+                            resolution: resolution || "D",
+                            from: String(from),
+                            to: String(to)
+                        });
+                        return {
+                            data,
+                            source: "finnhub"
+                        };
+                    }
+                    try {
+                        const data = await fetchFinnhub("/stock/candle", {
+                            symbol,
+                            resolution: resolution || "D",
+                            from: String(from),
+                            to: String(to)
+                        });
+                        return {
+                            data,
+                            source: "finnhub"
+                        };
+                    } catch (error) {
+                        if (!isFinnhubForbidden(error)) throw error;
+                        const data = await fetchYahooCandles({
+                            symbol,
+                            resolution,
+                            from,
+                            to
+                        });
+                        return {
+                            data,
+                            source: "yahoo"
+                        };
+                    }
+                };
+                const toResult = (data)=>({
+                        content: [
+                            {
+                                type: "text",
+                                text: JSON.stringify(data, null, 2)
+                            }
+                        ],
+                        structuredContent: {
+                            data
+                        }
+                    });
+                const server = new _modelcontextprotocol_sdk_server_mcp_js__rspack_import_0.McpServer({
+                    name: "wingman-finance",
+                    version: "0.1.0"
+                });
+                server.registerTool("finnhub.symbolSearch", {
+                    title: "Finnhub Symbol Search",
+                    description: "Search for symbols or companies by query.",
+                    inputSchema: zod__rspack_import_2.z.object({
+                        query: zod__rspack_import_2.z.string().min(1)
+                    })
+                }, async ({ query })=>{
+                    const data = await fetchFinnhub("/search", {
+                        q: query
+                    });
+                    return toResult(data);
+                });
+                server.registerTool("finnhub.quote", {
+                    title: "Finnhub Quote",
+                    description: "Get the latest quote for a symbol.",
+                    inputSchema: zod__rspack_import_2.z.object({
+                        symbol: zod__rspack_import_2.z.string().min(1)
+                    })
+                }, async ({ symbol })=>{
+                    const data = await fetchFinnhub("/quote", {
+                        symbol
+                    });
+                    return toResult(data);
+                });
+                server.registerTool("finnhub.companyProfile", {
+                    title: "Finnhub Company Profile",
+                    description: "Get company profile data for a symbol.",
+                    inputSchema: zod__rspack_import_2.z.object({
+                        symbol: zod__rspack_import_2.z.string().min(1)
+                    })
+                }, async ({ symbol })=>{
+                    const data = await fetchFinnhub("/stock/profile2", {
+                        symbol
+                    });
+                    return toResult(data);
+                });
+                server.registerTool("finnhub.financials", {
+                    title: "Finnhub Financial Metrics",
+                    description: "Get financial metrics (including P/E) for a symbol.",
+                    inputSchema: zod__rspack_import_2.z.object({
+                        symbol: zod__rspack_import_2.z.string().min(1),
+                        metric: zod__rspack_import_2.z.string().optional().default("all")
+                    })
+                }, async ({ symbol, metric })=>{
+                    const data = await fetchFinnhub("/stock/metric", {
+                        symbol,
+                        metric: metric || "all"
+                    });
+                    return toResult(data);
+                });
+                server.registerTool("finnhub.earnings", {
+                    title: "Finnhub Earnings",
+                    description: "Get earnings history for a symbol.",
+                    inputSchema: zod__rspack_import_2.z.object({
+                        symbol: zod__rspack_import_2.z.string().min(1),
+                        limit: zod__rspack_import_2.z.number().int().min(1).max(20).optional()
+                    })
+                }, async ({ symbol, limit })=>{
+                    const data = await fetchFinnhub("/stock/earnings", {
+                        symbol,
+                        ...limit ? {
+                            limit: String(limit)
+                        } : {}
+                    });
+                    return toResult(data);
+                });
+                server.registerTool("finnhub.news", {
+                    title: "Finnhub Company News",
+                    description: "Get recent company news for a symbol.",
+                    inputSchema: zod__rspack_import_2.z.object({
+                        symbol: zod__rspack_import_2.z.string().min(1),
+                        from: zod__rspack_import_2.z.string().optional(),
+                        to: zod__rspack_import_2.z.string().optional()
+                    })
+                }, async ({ symbol, from, to })=>{
+                    const toDate = to || new Date().toISOString().slice(0, 10);
+                    let fromDate = from;
+                    if (!fromDate) {
+                        const start = new Date();
+                        start.setDate(start.getDate() - 7);
+                        fromDate = start.toISOString().slice(0, 10);
+                    }
+                    const data = await fetchFinnhub("/company-news", {
+                        symbol,
+                        from: fromDate,
+                        to: toDate
+                    });
+                    return toResult(data);
+                });
+                server.registerTool("finnhub.marketNews", {
+                    title: "Finnhub Market News",
+                    description: "Get broad market news (general category) for theme detection.",
+                    inputSchema: zod__rspack_import_2.z.object({
+                        category: zod__rspack_import_2.z.string().min(1).optional().default("general")
+                    })
+                }, async ({ category })=>{
+                    const data = await fetchFinnhub("/news", {
+                        category: category || "general"
+                    });
+                    return toResult(data);
+                });
+                server.registerTool("finnhub.peers", {
+                    title: "Finnhub Stock Peers",
+                    description: "Get peer symbols for a company.",
+                    inputSchema: zod__rspack_import_2.z.object({
+                        symbol: zod__rspack_import_2.z.string().min(1)
+                    })
+                }, async ({ symbol })=>{
+                    const data = await fetchFinnhub("/stock/peers", {
+                        symbol
+                    });
+                    return toResult(data);
+                });
+                server.registerTool("finnhub.candles", {
+                    title: "Finnhub Candles",
+                    description: `Get OHLCV candles for a symbol. ${candleCapSummary} ${candleSourceSummary} ${candleSessionSummary}`,
+                    inputSchema: zod__rspack_import_2.z.object({
+                        symbol: zod__rspack_import_2.z.string().min(1),
+                        resolution: zod__rspack_import_2.z.string().optional().default("D"),
+                        from: zod__rspack_import_2.z.number().int().optional(),
+                        to: zod__rspack_import_2.z.number().int().optional(),
+                        lookbackDays: zod__rspack_import_2.z.number().int().positive().optional()
+                    })
+                }, async ({ symbol, resolution, from, to, lookbackDays })=>{
+                    const range = (0, _finance_candleRange_js__rspack_import_5.resolveCandleRange)({
+                        from,
+                        to,
+                        lookbackDays,
+                        resolution,
+                        maxIntradayDays,
+                        maxDailyDays
+                    });
+                    const { data, source } = await fetchCandlesWithFallback({
+                        symbol,
+                        resolution,
+                        from: range.from,
+                        to: range.to
+                    });
+                    const result = "yahoo" !== source || data.source ? data : {
+                        ...data,
+                        source
+                    };
+                    return toResult(result);
+                });
+                server.registerTool("finnhub.technicalSnapshot", {
+                    title: "Finnhub Technical Snapshot",
+                    description: `Fetch candles and compute RSI/EMA/ATR locally. ${candleCapSummary} ${candleSourceSummary} ${candleSessionSummary}`,
+                    inputSchema: zod__rspack_import_2.z.object({
+                        symbol: zod__rspack_import_2.z.string().min(1),
+                        resolution: zod__rspack_import_2.z.string().optional().default("D"),
+                        from: zod__rspack_import_2.z.number().int().optional(),
+                        to: zod__rspack_import_2.z.number().int().optional(),
+                        lookbackDays: zod__rspack_import_2.z.number().int().positive().optional()
+                    })
+                }, async ({ symbol, resolution, from, to, lookbackDays })=>{
+                    const range = (0, _finance_candleRange_js__rspack_import_5.resolveCandleRange)({
+                        from,
+                        to,
+                        lookbackDays,
+                        resolution,
+                        maxIntradayDays,
+                        maxDailyDays
+                    });
+                    const { data, source } = await fetchCandlesWithFallback({
+                        symbol,
+                        resolution,
+                        from: range.from,
+                        to: range.to
+                    });
+                    if (!data || "ok" !== data.s || !Array.isArray(data.c)) return toResult({
+                        symbol,
+                        source,
+                        status: data?.s ?? "no_data",
+                        error: data.error,
+                        from: range.from,
+                        to: range.to
+                    });
+                    const snapshot = (0, _finance_technicalIndicators_js__rspack_import_3.buildTechnicalSnapshot)({
+                        closes: data.c,
+                        highs: data.h ?? [],
+                        lows: data.l ?? []
+                    });
+                    return toResult({
+                        symbol,
+                        resolution: resolution || "D",
+                        from: range.from,
+                        to: range.to,
+                        source,
+                        status: data.s,
+                        points: data.c.length,
+                        lastTimestamp: data.t?.at(-1) ?? null,
+                        ...snapshot
+                    });
+                });
+                server.registerTool("finnhub.optionChain", {
+                    title: "Finnhub Option Chain",
+                    description: "Get option chain data for a symbol (date optional).",
+                    inputSchema: zod__rspack_import_2.z.object({
+                        symbol: zod__rspack_import_2.z.string().min(1),
+                        date: zod__rspack_import_2.z.string().optional()
+                    })
+                }, async ({ symbol, date })=>{
+                    const data = await fetchFinnhub("/stock/option-chain", {
+                        symbol,
+                        ...date ? {
+                            date
+                        } : {}
+                    });
+                    return toResult(data);
+                });
+                server.registerTool("options.analyze", {
+                    title: "Options Structure Analyzer",
+                    description: "Compute payoff metrics and optional Greeks for an options structure using supplied leg prices.",
+                    inputSchema: zod__rspack_import_2.z.object({
+                        underlyingPrice: zod__rspack_import_2.z.number().positive(),
+                        daysToExpiry: zod__rspack_import_2.z.number().positive().optional(),
+                        riskFreeRate: zod__rspack_import_2.z.number().optional().default(0),
+                        dividendYield: zod__rspack_import_2.z.number().optional().default(0),
+                        legs: zod__rspack_import_2.z.array(zod__rspack_import_2.z.object({
+                            type: zod__rspack_import_2.z["enum"]([
+                                "call",
+                                "put"
+                            ]),
+                            side: zod__rspack_import_2.z["enum"]([
+                                "buy",
+                                "sell"
+                            ]),
+                            strike: zod__rspack_import_2.z.number().positive(),
+                            premium: zod__rspack_import_2.z.number().nonnegative(),
+                            qty: zod__rspack_import_2.z.number().int().positive().optional(),
+                            contractMultiplier: zod__rspack_import_2.z.number().positive().optional(),
+                            impliedVol: zod__rspack_import_2.z.number().positive().optional()
+                        })).min(1)
+                    })
+                }, async (input)=>{
+                    const data = (0, _finance_optionsAnalytics_js__rspack_import_4.analyzeOptionStructure)(input);
+                    return toResult(data);
+                });
+                const transport = new _modelcontextprotocol_sdk_server_stdio_js__rspack_import_1.StdioServerTransport();
+                await server.connect(transport);
+                console.error(`wingman-mcp-finance ready | Finnhub rate limit: ${rateLimitPerMin}/min | base: ${FINNHUB_BASE_URL} | candle caps: ${candleCapSummary} | candle source: ${candleProvider} | sessions: ${candleSessionSummary}`);
+                __rspack_async_done();
+            } catch (e) {
+                __rspack_async_done(e);
+            }
+        }, 1);
+    },
+    "./finance/candleRange.js" (module) {
+        module.exports = __rspack_external__finance_candleRange_js_37dcd2cb;
+    },
+    "./finance/optionsAnalytics.js" (module) {
+        module.exports = __rspack_external__finance_optionsAnalytics_js_b4458756;
+    },
+    "./finance/technicalIndicators.js" (module) {
+        module.exports = __rspack_external__finance_technicalIndicators_js_d909860a;
+    },
+    "./finance/yahooCandles.js" (module) {
+        module.exports = __rspack_external__finance_yahooCandles_js_99c2b945;
+    },
+    "@modelcontextprotocol/sdk/server/mcp.js" (module) {
+        module.exports = __rspack_external__modelcontextprotocol_sdk_server_mcp_js_2c42c5d0;
+    },
+    "@modelcontextprotocol/sdk/server/stdio.js" (module) {
+        module.exports = __rspack_external__modelcontextprotocol_sdk_server_stdio_js_4f861174;
+    },
+    zod (module) {
+        module.exports = __rspack_external_zod;
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    var hasSymbol = "function" == typeof Symbol;
+    var rspackQueues = hasSymbol ? Symbol("rspack queues") : "__rspack_queues";
+    var rspackExports = __webpack_require__.aE = hasSymbol ? Symbol("rspack exports") : "__webpack_exports__";
+    var rspackError = hasSymbol ? Symbol("rspack error") : "__rspack_error";
+    var rspackDone = hasSymbol ? Symbol("rspack done") : "__rspack_done";
+    var rspackDefer = __webpack_require__.zS = hasSymbol ? Symbol("rspack defer") : "__rspack_defer";
+    var resolveQueue = (queue)=>{
+        if (queue && queue.d < 1) {
+            queue.d = 1;
+            queue.forEach((fn)=>fn.r--);
+            queue.forEach((fn)=>fn.r-- ? fn.r++ : fn());
+        }
+    };
+    var wrapDeps = (deps)=>deps.map((dep)=>{
+            if (null !== dep && "object" == typeof dep) {
+                if (!dep[rspackQueues] && dep[rspackDefer]) {
+                    var asyncDeps = dep[rspackDefer];
+                    var hasUnresolvedAsyncSubgraph = asyncDeps.some((id)=>{
+                        var cache = __webpack_module_cache__[id];
+                        return !cache || false === cache[rspackDone];
+                    });
+                    if (!hasUnresolvedAsyncSubgraph) return dep;
+                    var d = dep;
+                    dep = {
+                        then (callback) {
+                            Promise.all(asyncDeps.map(__webpack_require__)).then(()=>callback(d));
+                        }
+                    };
+                }
+                if (dep[rspackQueues]) return dep;
+                if (dep.then) {
+                    var queue = [];
+                    queue.d = 0;
+                    dep.then((r)=>{
+                        obj[rspackExports] = r;
+                        resolveQueue(queue);
+                    }, (e)=>{
+                        obj[rspackError] = e;
+                        resolveQueue(queue);
+                    });
+                    var obj = {};
+                    obj[rspackDefer] = false;
+                    obj[rspackQueues] = (fn)=>fn(queue);
+                    return obj;
+                }
+            }
+            var ret = {};
+            ret[rspackQueues] = ()=>{};
+            ret[rspackExports] = dep;
+            return ret;
+        });
+    __webpack_require__.a = (module, body, hasAwait)=>{
+        var queue;
+        hasAwait && ((queue = []).d = -1);
+        var depQueues = new Set();
+        var exports = module.exports;
+        var currentDeps;
+        var outerResolve;
+        var reject;
+        var promise = new Promise((resolve, rej)=>{
+            reject = rej;
+            outerResolve = resolve;
+        });
+        promise[rspackExports] = exports;
+        promise[rspackQueues] = (fn)=>{
+            queue && fn(queue), depQueues.forEach(fn), promise["catch"](()=>{});
+        };
+        module.exports = promise;
+        var handle = (deps)=>{
+            currentDeps = wrapDeps(deps);
+            var fn;
+            var getResult = ()=>currentDeps.map((d)=>{
+                    if (d[rspackDefer]) return d;
+                    if (d[rspackError]) throw d[rspackError];
+                    return d[rspackExports];
+                });
+            var promise = new Promise((resolve)=>{
+                fn = ()=>resolve(getResult);
+                fn.r = 0;
+                var fnQueue = (q)=>q !== queue && !depQueues.has(q) && (depQueues.add(q), q && !q.d && (fn.r++, q.push(fn)));
+                currentDeps.map((dep)=>dep[rspackDefer] || dep[rspackQueues](fnQueue));
+            });
+            return fn.r ? promise : getResult();
+        };
+        var done = (err)=>(err ? reject(promise[rspackError] = err) : outerResolve(exports), resolveQueue(queue), promise[rspackDone] = true);
+        body(handle, done);
+        queue && queue.d < 0 && (queue.d = 0);
+    };
+})();
+(()=>{
+    __webpack_require__.r = (exports)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports, '__esModule', {
+            value: true
+        });
+    };
+})();
+__webpack_require__("./src/tools/mcp-finance.ts");

package/dist/types/agents.cjs

@@ -0,0 +1,18 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __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__);
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/types/agents.d.ts

@@ -0,0 +1,11 @@
+import type { createDeepAgent } from "deepagents";
+import type { HooksConfig } from "./hooks.js";
+import type { MCPServersConfig } from "./mcp.js";
+import type { AgentVoiceConfig } from "./voice.js";
+export type WingmanAgent = Pick<NonNullable<Parameters<typeof createDeepAgent>[0]>, "name" | "systemPrompt" | "tools" | "skills" | "model" | "subagents"> & {
+    description?: string;
+    toolHooks?: HooksConfig;
+    mcpConfig?: MCPServersConfig;
+    mcpUseGlobal?: boolean;
+    voice?: AgentVoiceConfig;
+};