fmp-ai-tools/dist/providers/openai/index.js

AI tools for FMP Node API - compatible with Vercel AI SDK, Langchain, OpenAI, and more

'use strict';

var zod = require('zod');
var agents = require('@openai/agents');
var fmpNodeApi = require('fmp-node-api');

// src/providers/openai/company.ts
function createOpenAITool(config) {
  const { name, description, inputSchema, execute } = config;
  const properties = {};
  const required = [];
  if (inputSchema instanceof zod.z.ZodObject) {
    const shape = inputSchema.shape;
    Object.entries(shape).forEach(([key, schema]) => {
      let isRequired = true;
      let actualSchema = schema;
      let fieldDescription = "";
      if (schema && typeof schema === "object" && "description" in schema) {
        const desc = schema.description;
        if (typeof desc === "string") {
          fieldDescription = desc;
        }
      }
      if (schema instanceof zod.z.ZodOptional) {
        isRequired = false;
        actualSchema = schema.unwrap();
        if (!fieldDescription && actualSchema.description) {
          fieldDescription = actualSchema.description;
        }
      }
      if (schema instanceof zod.z.ZodDefault) {
        isRequired = false;
        actualSchema = schema.removeDefault();
        if (!fieldDescription && actualSchema.description) {
          fieldDescription = actualSchema.description;
        }
      }
      if (actualSchema instanceof zod.z.ZodString) {
        properties[key] = {
          type: "string",
          description: fieldDescription || `${key} parameter`
        };
      } else if (actualSchema instanceof zod.z.ZodEnum) {
        properties[key] = {
          type: "string",
          enum: actualSchema._def.values,
          description: fieldDescription || `${key} parameter`
        };
      } else if (actualSchema instanceof zod.z.ZodNumber) {
        properties[key] = {
          type: "number",
          description: fieldDescription || `${key} parameter`
        };
      } else if (actualSchema instanceof zod.z.ZodBoolean) {
        properties[key] = {
          type: "boolean",
          description: fieldDescription || `${key} parameter`
        };
      } else if (actualSchema instanceof zod.z.ZodArray) {
        properties[key] = {
          type: "array",
          items: { type: "string" },
          // Default to string array, can be enhanced
          description: fieldDescription || `${key} parameter`
        };
      } else {
        properties[key] = {
          type: "string",
          description: fieldDescription || `${key} parameter`
        };
      }
      if (isRequired) {
        required.push(key);
      }
    });
  }
  return agents.tool({
    name,
    description,
    parameters: {
      type: "object",
      properties,
      required,
      additionalProperties: false
    },
    strict: false,
    execute: async (input) => {
      try {
        const validatedInput = inputSchema.parse(input);
        return await execute(validatedInput);
      } catch (error) {
        if (error instanceof zod.z.ZodError) {
          return `Invalid input: ${error.errors.map((e) => e.message).join(", ")}`;
        }
        return `Error executing ${name}: ${error instanceof Error ? error.message : String(error)}`;
      }
    }
  });
}
function getFMPClient() {
  return new fmpNodeApi.FMP();
}

// src/providers/openai/company.ts
var getCompanyProfile = createOpenAITool({
  name: "getCompanyProfile",
  description: "Get the company profile for a company",
  inputSchema: zod.z.object({
    symbol: zod.z.string().min(1, "Stock symbol is required").describe("The stock symbol (e.g., AAPL, MSFT, GOOGL)")
  }),
  execute: async ({ symbol }) => {
    const fmp = getFMPClient();
    const companyProfile = await fmp.company.getCompanyProfile(symbol);
    return JSON.stringify(companyProfile.data, null, 2);
  }
});
var calendarInputSchema = zod.z.object({
  from: zod.z.string().optional().describe("Start date in YYYY-MM-DD format (optional)"),
  to: zod.z.string().optional().describe("End date in YYYY-MM-DD format (optional)")
});
var getEarningsCalendar = createOpenAITool({
  name: "getEarningsCalendar",
  description: "Get earnings calendar showing upcoming and recent earnings announcements",
  inputSchema: calendarInputSchema,
  execute: async ({ from, to }) => {
    const fmp = getFMPClient();
    const earningsCalendar = await fmp.calendar.getEarningsCalendar({ from, to });
    return JSON.stringify(earningsCalendar.data, null, 2);
  }
});
var getEconomicCalendar = createOpenAITool({
  name: "getEconomicCalendar",
  description: "Get economic calendar showing upcoming and recent economic events and indicators",
  inputSchema: calendarInputSchema,
  execute: async ({ from, to }) => {
    const fmp = getFMPClient();
    const economicCalendar = await fmp.calendar.getEconomicsCalendar({ from, to });
    return JSON.stringify(economicCalendar.data, null, 2);
  }
});
var treasuryRatesInputSchema = zod.z.object({
  from: zod.z.string().optional().describe("Start date in YYYY-MM-DD format (optional)"),
  to: zod.z.string().optional().describe("End date in YYYY-MM-DD format (optional)")
});
var economicIndicatorNames = [
  "GDP",
  "realGDP",
  "nominalPotentialGDP",
  "realGDPPerCapita",
  "federalFunds",
  "CPI",
  "inflationRate",
  "inflation",
  "retailSales",
  "consumerSentiment",
  "durableGoods",
  "unemploymentRate",
  "totalNonfarmPayroll",
  "initialClaims",
  "industrialProductionTotalIndex",
  "newPrivatelyOwnedHousingUnitsStartedTotalUnits",
  "totalVehicleSales",
  "retailMoneyFunds",
  "smoothedUSRecessionProbabilities",
  "3MonthOr90DayRatesAndYieldsCertificatesOfDeposit",
  "commercialBankInterestRateOnCreditCardPlansAllAccounts",
  "30YearFixedRateMortgageAverage",
  "15YearFixedRateMortgageAverage"
];
var economicIndicatorsInputSchema = zod.z.object({
  name: zod.z.enum(economicIndicatorNames).describe("The name of the economic indicator"),
  from: zod.z.string().optional().describe("Start date in YYYY-MM-DD format (optional)"),
  to: zod.z.string().optional().describe("End date in YYYY-MM-DD format (optional)")
});
var getTreasuryRates = createOpenAITool({
  name: "getTreasuryRates",
  description: "Get treasury rates for different maturities over time",
  inputSchema: treasuryRatesInputSchema,
  execute: async ({ from, to }) => {
    const fmp = getFMPClient();
    const treasuryRates = await fmp.economic.getTreasuryRates({ from, to });
    return JSON.stringify(treasuryRates.data, null, 2);
  }
});
var getEconomicIndicators = createOpenAITool({
  name: "getEconomicIndicators",
  description: "Get economic indicators like GDP, unemployment rate, inflation, etc.",
  inputSchema: economicIndicatorsInputSchema,
  execute: async ({ name, from, to }) => {
    const fmp = getFMPClient();
    const economicIndicators = await fmp.economic.getEconomicIndicators({ name, from, to });
    return JSON.stringify(economicIndicators.data, null, 2);
  }
});
var etfHoldingsInputSchema = zod.z.object({
  symbol: zod.z.string().min(1, "ETF symbol is required").describe("ETF symbol (e.g., SPY, QQQ, VTI)"),
  date: zod.z.string().optional().describe("Date for holdings in YYYY-MM-DD format (optional)")
});
var etfProfileInputSchema = zod.z.object({
  symbol: zod.z.string().min(1, "ETF symbol is required").describe("ETF symbol (e.g., SPY, QQQ, VTI)")
});
var getETFHoldings = createOpenAITool({
  name: "getETFHoldings",
  description: "Get ETF holdings for a specific ETF symbol, showing the underlying assets and their weights",
  inputSchema: etfHoldingsInputSchema,
  execute: async ({ symbol, date }) => {
    const fmp = getFMPClient();
    const params = { symbol };
    if (date) {
      params.date = date;
    }
    const etfHoldings = await fmp.etf.getHoldings(params);
    return JSON.stringify(etfHoldings.data, null, 2);
  }
});
var getETFProfile = createOpenAITool({
  name: "getETFProfile",
  description: "Get ETF profile information including fund details, expense ratio, and key metrics",
  inputSchema: etfProfileInputSchema,
  execute: async ({ symbol }) => {
    const fmp = getFMPClient();
    const etfProfile = await fmp.etf.getProfile(symbol);
    return JSON.stringify(etfProfile.data, null, 2);
  }
});
var financialStatementInputSchema = zod.z.object({
  symbol: zod.z.string().min(1, "Stock symbol is required").describe("The stock symbol (e.g., AAPL, MSFT, GOOGL)"),
  period: zod.z.enum(["annual", "quarter"]).default("annual").describe("The period type (annual or quarter)")
});
var getBalanceSheet = createOpenAITool({
  name: "getBalanceSheet",
  description: "Get balance sheet for a company showing assets, liabilities, and equity",
  inputSchema: financialStatementInputSchema,
  execute: async ({ symbol, period }) => {
    const fmp = getFMPClient();
    const balanceSheet = await fmp.financial.getBalanceSheet({ symbol, period });
    return JSON.stringify(balanceSheet.data, null, 2);
  }
});
var getIncomeStatement = createOpenAITool({
  name: "getIncomeStatement",
  description: "Get income statement for a company showing revenue, expenses, and profit",
  inputSchema: financialStatementInputSchema,
  execute: async ({ symbol, period }) => {
    const fmp = getFMPClient();
    const incomeStatement = await fmp.financial.getIncomeStatement({ symbol, period });
    return JSON.stringify(incomeStatement.data, null, 2);
  }
});
var getCashFlowStatement = createOpenAITool({
  name: "getCashFlowStatement",
  description: "Get cash flow statement for a company showing operating, investing, and financing cash flows",
  inputSchema: financialStatementInputSchema,
  execute: async ({ symbol, period }) => {
    const fmp = getFMPClient();
    const cashFlowStatement = await fmp.financial.getCashFlowStatement({ symbol, period });
    return JSON.stringify(cashFlowStatement.data, null, 2);
  }
});
var getFinancialRatios = createOpenAITool({
  name: "getFinancialRatios",
  description: "Get financial ratios for a company including profitability, liquidity, and efficiency metrics",
  inputSchema: financialStatementInputSchema,
  execute: async ({ symbol, period }) => {
    const fmp = getFMPClient();
    const financialRatios = await fmp.financial.getFinancialRatios({ symbol, period });
    return JSON.stringify(financialRatios.data, null, 2);
  }
});
var insiderTradingInputSchema = zod.z.object({
  symbol: zod.z.string().min(1, "Stock symbol is required").describe("Stock symbol (e.g., AAPL, MSFT, GOOGL)"),
  page: zod.z.number().int().min(0).default(0).describe("Page number for pagination (optional, defaults to 0)")
});
var getInsiderTrading = createOpenAITool({
  name: "getInsiderTrading",
  description: "Get insider trading data for a specific stock symbol showing buy/sell transactions by company insiders",
  inputSchema: insiderTradingInputSchema,
  execute: async ({ symbol, page }) => {
    const fmp = getFMPClient();
    const insiderTrading = await fmp.insider.getInsiderTradesBySymbol(symbol, page);
    return JSON.stringify(insiderTrading.data, null, 2);
  }
});
var institutionalHoldersInputSchema = zod.z.object({
  symbol: zod.z.string().min(1, "Stock symbol is required").describe("Stock symbol (e.g., AAPL, MSFT, GOOGL)")
});
var getInstitutionalHolders = createOpenAITool({
  name: "getInstitutionalHolders",
  description: "Get institutional holders for a specific stock symbol showing which institutions own shares and their holdings",
  inputSchema: institutionalHoldersInputSchema,
  execute: async ({ symbol }) => {
    const fmp = getFMPClient();
    const institutionalHolders = await fmp.institutional.getInstitutionalHolders({ symbol });
    return JSON.stringify(institutionalHolders.data, null, 2);
  }
});
var emptyInputSchema = zod.z.object({});
var getMarketPerformance = createOpenAITool({
  name: "getMarketPerformance",
  description: "Get overall market performance data including major indices performance",
  inputSchema: emptyInputSchema,
  execute: async () => {
    const fmp = getFMPClient();
    const marketPerformance = await fmp.market.getMarketPerformance();
    return JSON.stringify(marketPerformance.data, null, 2);
  }
});
var getSectorPerformance = createOpenAITool({
  name: "getSectorPerformance",
  description: "Get sector performance data showing how different market sectors are performing",
  inputSchema: emptyInputSchema,
  execute: async () => {
    const fmp = getFMPClient();
    const sectorPerformance = await fmp.market.getSectorPerformance();
    return JSON.stringify(sectorPerformance.data, null, 2);
  }
});
var getGainers = createOpenAITool({
  name: "getGainers",
  description: "Get top gaining stocks showing the best performing stocks of the day",
  inputSchema: emptyInputSchema,
  execute: async () => {
    const fmp = getFMPClient();
    const gainers = await fmp.market.getGainers();
    return JSON.stringify(gainers.data, null, 2);
  }
});
var getLosers = createOpenAITool({
  name: "getLosers",
  description: "Get top losing stocks showing the worst performing stocks of the day",
  inputSchema: emptyInputSchema,
  execute: async () => {
    const fmp = getFMPClient();
    const losers = await fmp.market.getLosers();
    return JSON.stringify(losers.data, null, 2);
  }
});
var getMostActive = createOpenAITool({
  name: "getMostActive",
  description: "Get most active stocks showing stocks with the highest trading volume",
  inputSchema: emptyInputSchema,
  execute: async () => {
    const fmp = getFMPClient();
    const mostActive = await fmp.market.getMostActive();
    return JSON.stringify(mostActive.data, null, 2);
  }
});
var stockQuoteInputSchema = zod.z.object({
  symbol: zod.z.string().min(1, "Stock symbol is required").describe("The symbol of the company to get the stock quote for")
});
var getStockQuote = createOpenAITool({
  name: "getStockQuote",
  description: "Get the real-time stock quote for a company including price, volume, and market data",
  inputSchema: stockQuoteInputSchema,
  execute: async ({ symbol }) => {
    const fmp = getFMPClient();
    const stockQuote = await fmp.quote.getQuote(symbol);
    return JSON.stringify(stockQuote.data, null, 2);
  }
});
var symbolInputSchema = zod.z.object({
  symbol: zod.z.string().min(1, "Stock symbol is required").describe("Stock symbol (e.g., AAPL, MSFT, GOOGL)")
});
var nameInputSchema = zod.z.object({
  name: zod.z.string().min(1, "Name is required").describe("The name of the senator or representative")
});
var rssFeedInputSchema = zod.z.object({
  page: zod.z.number().int().min(0).default(0).describe("Page number for pagination (optional, defaults to 0)")
});
var getSenateTrading = createOpenAITool({
  name: "getSenateTrading",
  description: "Get senate trading data for a specific stock symbol showing senator transactions",
  inputSchema: symbolInputSchema,
  execute: async ({ symbol }) => {
    const fmp = getFMPClient();
    const senateTrading = await fmp.senateHouse.getSenateTrading({ symbol });
    return JSON.stringify(senateTrading.data, null, 2);
  }
});
var getHouseTrading = createOpenAITool({
  name: "getHouseTrading",
  description: "Get house trading data for a specific stock symbol showing representative transactions",
  inputSchema: symbolInputSchema,
  execute: async ({ symbol }) => {
    const fmp = getFMPClient();
    const houseTrading = await fmp.senateHouse.getHouseTrading({ symbol });
    return JSON.stringify(houseTrading.data, null, 2);
  }
});
var getSenateTradingByName = createOpenAITool({
  name: "getSenateTradingByName",
  description: "Get senate trading data for a specific senator by name showing their trading activity",
  inputSchema: nameInputSchema,
  execute: async ({ name }) => {
    const fmp = getFMPClient();
    const senateTradingByName = await fmp.senateHouse.getSenateTradingByName({ name });
    return JSON.stringify(senateTradingByName.data, null, 2);
  }
});
var getHouseTradingByName = createOpenAITool({
  name: "getHouseTradingByName",
  description: "Get house trading data for a specific representative by name showing their trading activity",
  inputSchema: nameInputSchema,
  execute: async ({ name }) => {
    const fmp = getFMPClient();
    const houseTradingByName = await fmp.senateHouse.getHouseTradingByName({ name });
    return JSON.stringify(houseTradingByName.data, null, 2);
  }
});
var getSenateTradingRSSFeed = createOpenAITool({
  name: "getSenateTradingRSSFeed",
  description: "Get senate trading data through RSS feed with pagination showing recent senate transactions",
  inputSchema: rssFeedInputSchema,
  execute: async ({ page }) => {
    const fmp = getFMPClient();
    const senateTradingRSSFeed = await fmp.senateHouse.getSenateTradingRSSFeed({ page });
    return JSON.stringify(senateTradingRSSFeed.data, null, 2);
  }
});
var getHouseTradingRSSFeed = createOpenAITool({
  name: "getHouseTradingRSSFeed",
  description: "Get house trading data through RSS feed with pagination showing recent house transactions",
  inputSchema: rssFeedInputSchema,
  execute: async ({ page }) => {
    const fmp = getFMPClient();
    const houseTradingRSSFeed = await fmp.senateHouse.getHouseTradingRSSFeed({ page });
    return JSON.stringify(houseTradingRSSFeed.data, null, 2);
  }
});
var symbolInputSchema2 = zod.z.object({
  symbol: zod.z.string().min(1, "Stock symbol is required").describe("The stock symbol (e.g., AAPL, MSFT, GOOGL)")
});
var getMarketCap = createOpenAITool({
  name: "getMarketCap",
  description: "Get market capitalization for a company showing current market value",
  inputSchema: symbolInputSchema2,
  execute: async ({ symbol }) => {
    const fmp = getFMPClient();
    const marketCap = await fmp.stock.getMarketCap(symbol);
    return JSON.stringify(marketCap.data, null, 2);
  }
});
var getStockSplits = createOpenAITool({
  name: "getStockSplits",
  description: "Get stock splits history for a company showing all historical stock split events",
  inputSchema: symbolInputSchema2,
  execute: async ({ symbol }) => {
    const fmp = getFMPClient();
    const stockSplits = await fmp.stock.getStockSplits(symbol);
    return JSON.stringify(stockSplits.data, null, 2);
  }
});
var getDividendHistory = createOpenAITool({
  name: "getDividendHistory",
  description: "Get dividend history for a company showing all historical dividend payments",
  inputSchema: symbolInputSchema2,
  execute: async ({ symbol }) => {
    const fmp = getFMPClient();
    const dividendHistory = await fmp.stock.getDividendHistory(symbol);
    return JSON.stringify(dividendHistory.data, null, 2);
  }
});

// src/providers/openai/index.ts
var companyTools = [getCompanyProfile];
var calendarTools = [getEarningsCalendar, getEconomicCalendar];
var economicTools = [getTreasuryRates, getEconomicIndicators];
var etfTools = [getETFHoldings, getETFProfile];
var financialTools = [
  getBalanceSheet,
  getIncomeStatement,
  getCashFlowStatement,
  getFinancialRatios
];
var insiderTools = [getInsiderTrading];
var institutionalTools = [getInstitutionalHolders];
var marketTools = [
  getMarketPerformance,
  getSectorPerformance,
  getGainers,
  getLosers,
  getMostActive
];
var quoteTools = [getStockQuote];
var senateHouseTools = [
  getSenateTrading,
  getHouseTrading,
  getSenateTradingByName,
  getHouseTradingByName,
  getSenateTradingRSSFeed,
  getHouseTradingRSSFeed
];
var stockTools = [getMarketCap, getStockSplits, getDividendHistory];
var fmpTools = [
  getCompanyProfile,
  getEarningsCalendar,
  getEconomicCalendar,
  getTreasuryRates,
  getEconomicIndicators,
  getETFHoldings,
  getETFProfile,
  getBalanceSheet,
  getIncomeStatement,
  getCashFlowStatement,
  getFinancialRatios,
  getInsiderTrading,
  getInstitutionalHolders,
  getMarketPerformance,
  getSectorPerformance,
  getGainers,
  getLosers,
  getMostActive,
  getStockQuote,
  getSenateTrading,
  getHouseTrading,
  getSenateTradingByName,
  getHouseTradingByName,
  getSenateTradingRSSFeed,
  getHouseTradingRSSFeed,
  getMarketCap,
  getStockSplits,
  getDividendHistory
];

exports.calendarTools = calendarTools;
exports.companyTools = companyTools;
exports.economicTools = economicTools;
exports.etfTools = etfTools;
exports.financialTools = financialTools;
exports.fmpTools = fmpTools;
exports.getBalanceSheet = getBalanceSheet;
exports.getCashFlowStatement = getCashFlowStatement;
exports.getCompanyProfile = getCompanyProfile;
exports.getDividendHistory = getDividendHistory;
exports.getETFHoldings = getETFHoldings;
exports.getETFProfile = getETFProfile;
exports.getEarningsCalendar = getEarningsCalendar;
exports.getEconomicCalendar = getEconomicCalendar;
exports.getEconomicIndicators = getEconomicIndicators;
exports.getFinancialRatios = getFinancialRatios;
exports.getGainers = getGainers;
exports.getHouseTrading = getHouseTrading;
exports.getHouseTradingByName = getHouseTradingByName;
exports.getHouseTradingRSSFeed = getHouseTradingRSSFeed;
exports.getIncomeStatement = getIncomeStatement;
exports.getInsiderTrading = getInsiderTrading;
exports.getInstitutionalHolders = getInstitutionalHolders;
exports.getLosers = getLosers;
exports.getMarketCap = getMarketCap;
exports.getMarketPerformance = getMarketPerformance;
exports.getMostActive = getMostActive;
exports.getSectorPerformance = getSectorPerformance;
exports.getSenateTrading = getSenateTrading;
exports.getSenateTradingByName = getSenateTradingByName;
exports.getSenateTradingRSSFeed = getSenateTradingRSSFeed;
exports.getStockQuote = getStockQuote;
exports.getStockSplits = getStockSplits;
exports.getTreasuryRates = getTreasuryRates;
exports.insiderTools = insiderTools;
exports.institutionalTools = institutionalTools;
exports.marketTools = marketTools;
exports.quoteTools = quoteTools;
exports.senateHouseTools = senateHouseTools;
exports.stockTools = stockTools;
//# sourceMappingURL=index.js.map
//# sourceMappingURL=index.js.map