fmp-ai-tools 0.0.4 → 0.0.6

package/dist/providers/openai/index.js

@@ -0,0 +1,739 @@
+'use strict';
+
+var zod = require('zod');
+var agents = require('@openai/agents');
+var fmpNodeApi = require('fmp-node-api');
+
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/utils/version-check.ts
+function checkOpenAIAgentsVersion() {
+  try {
+    const { tool: tool2 } = __require("@openai/agents");
+    tool2({
+      name: "test",
+      description: "test",
+      parameters: { type: "object", properties: {} },
+      strict: true,
+      execute: async () => "test"
+    });
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    throw new Error(
+      `Incompatible @openai/agents version detected. This package requires version ^0.0.17 or higher due to breaking changes in the API. Please upgrade with: npm install @openai/agents@latest
+
+Error details: ${errorMessage}`
+    );
+  }
+}
+
+// src/utils/logger.ts
+function isApiLoggingEnabled() {
+  return process.env.FMP_TOOLS_LOG_API_RESULTS === "true";
+}
+function isDataOnlyLoggingEnabled() {
+  return process.env.FMP_TOOLS_LOG_DATA_ONLY === "true";
+}
+function estimateTokenCount(text) {
+  try {
+    const parsed = JSON.parse(text);
+    return estimateTokenCountForData(parsed);
+  } catch {
+    return estimateTokenCountForText(text);
+  }
+}
+function estimateTokenCountForData(data) {
+  if (data === null || data === void 0) {
+    return 1;
+  }
+  if (typeof data === "string") {
+    return Math.ceil(data.length / 3);
+  }
+  if (typeof data === "number") {
+    return data.toString().length > 10 ? 2 : 1;
+  }
+  if (typeof data === "boolean") {
+    return 1;
+  }
+  if (Array.isArray(data)) {
+    let tokens = 2;
+    for (const item of data) {
+      tokens += estimateTokenCountForData(item);
+      if (data.indexOf(item) < data.length - 1) {
+        tokens += 1;
+      }
+    }
+    return tokens;
+  }
+  if (typeof data === "object") {
+    let tokens = 2;
+    const keys = Object.keys(data);
+    for (let i = 0; i < keys.length; i++) {
+      const key = keys[i];
+      const value = data[key];
+      tokens += Math.ceil(key.length / 3);
+      tokens += 2;
+      tokens += 1;
+      tokens += estimateTokenCountForData(value);
+      if (i < keys.length - 1) {
+        tokens += 1;
+      }
+    }
+    return tokens;
+  }
+  return 1;
+}
+function estimateTokenCountForText(text) {
+  const words = text.split(/\s+/).filter((word) => word.length > 0);
+  let tokens = 0;
+  for (const word of words) {
+    if (/^\d+$/.test(word)) {
+      tokens += word.length > 8 ? 2 : 1;
+    } else if (/^[A-Z]+$/.test(word)) {
+      tokens += 1;
+    } else if (/^\$[\d,]+\.?\d*$/.test(word)) {
+      tokens += 3;
+    } else {
+      tokens += Math.ceil(word.length / 3.5);
+    }
+  }
+  return tokens;
+}
+function getResultInfo(result) {
+  if (result === null || result === void 0) {
+    return "null/undefined";
+  }
+  if (typeof result === "string") {
+    const tokenCount = estimateTokenCount(result);
+    try {
+      const parsed = JSON.parse(result);
+      if (Array.isArray(parsed)) {
+        return `JSON string (array of ${parsed.length} items, ~${tokenCount} tokens)`;
+      }
+    } catch {
+    }
+    return `string (${result.length} chars, ~${tokenCount} tokens)`;
+  }
+  if (Array.isArray(result)) {
+    const jsonStr = JSON.stringify(result);
+    const tokenCount = estimateTokenCount(jsonStr);
+    return `array (${result.length} items, ~${tokenCount} tokens)`;
+  }
+  if (typeof result === "object") {
+    const jsonStr = JSON.stringify(result);
+    const tokenCount = estimateTokenCount(jsonStr);
+    return `object (~${tokenCount} tokens)`;
+  }
+  return typeof result;
+}
+function logApiExecution(options) {
+  if (!isApiLoggingEnabled()) {
+    return;
+  }
+  const { toolName, input, result, executionTime } = options;
+  console.log("\n" + "=".repeat(80));
+  console.log(`\u{1F527} FMP Tool Execution: ${toolName}`);
+  console.log("=".repeat(80));
+  console.log("\n\u{1F4E5} Input:");
+  console.log(JSON.stringify(input, null, 2));
+  const resultInfo = getResultInfo(result);
+  console.log(`\u{1F527} ${toolName}: ${resultInfo}`);
+  if (executionTime !== void 0) {
+    console.log(`
+\u23F1\uFE0F  Execution Time: ${executionTime}ms`);
+  }
+  console.log("=".repeat(80) + "\n");
+}
+function logDataOnly(options) {
+  if (!isDataOnlyLoggingEnabled()) {
+    return;
+  }
+  const { result } = options;
+  console.log("\n\u{1F4E4} Result:");
+  if (typeof result === "string") {
+    try {
+      const parsed = JSON.parse(result);
+      console.log(JSON.stringify(parsed, null, 2));
+    } catch {
+      console.log(result);
+    }
+  } else {
+    console.log(JSON.stringify(result, null, 2));
+  }
+  console.log("=".repeat(80) + "\n");
+}
+async function logApiExecutionWithTiming(toolName, input, executeFn) {
+  const startTime = Date.now();
+  try {
+    const result = await executeFn();
+    const executionTime = Date.now() - startTime;
+    logApiExecution({
+      toolName,
+      input,
+      result,
+      executionTime
+    });
+    logDataOnly({
+      toolName,
+      input,
+      result,
+      executionTime
+    });
+    return result;
+  } catch (error) {
+    const executionTime = Date.now() - startTime;
+    if (isApiLoggingEnabled()) {
+      console.log("\n" + "=".repeat(80));
+      console.log(`\u274C FMP Tool Execution Error: ${toolName}`);
+      console.log("=".repeat(80));
+      console.log("\n\u{1F4E5} Input:");
+      console.log(JSON.stringify(input, null, 2));
+      console.log("\n\u274C Error:");
+      console.log(error instanceof Error ? error.message : String(error));
+      console.log(`
+\u23F1\uFE0F  Execution Time: ${executionTime}ms`);
+      console.log("=".repeat(80) + "\n");
+    }
+    throw error;
+  }
+}
+
+// src/utils/openai-tool-wrapper.ts
+function createOpenAITool(config) {
+  const { name, description, inputSchema, execute } = config;
+  if (inputSchema instanceof zod.z.ZodObject) {
+    const shape = inputSchema.shape;
+    Object.entries(shape).forEach(([key, schema]) => {
+      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) {
+        actualSchema = schema.unwrap();
+        if (!fieldDescription && actualSchema.description) {
+          fieldDescription = actualSchema.description;
+        }
+      }
+      if (schema instanceof zod.z.ZodDefault) {
+        actualSchema = schema.removeDefault();
+        if (!fieldDescription && actualSchema.description) {
+          fieldDescription = actualSchema.description;
+        }
+      }
+      if (actualSchema instanceof zod.z.ZodString) ; else if (actualSchema instanceof zod.z.ZodEnum) {
+        ({
+          type: "string",
+          enum: actualSchema._def.values,
+          description: fieldDescription || `${key} parameter`
+        });
+      } else if (actualSchema instanceof zod.z.ZodNumber) ; else if (actualSchema instanceof zod.z.ZodBoolean) ; else if (actualSchema instanceof zod.z.ZodArray) ; else ;
+    });
+  }
+  return agents.tool({
+    name,
+    description,
+    parameters: inputSchema,
+    strict: true,
+    execute: async (input) => {
+      try {
+        const validatedInput = inputSchema.parse(input);
+        return await logApiExecutionWithTiming(name, validatedInput, () => 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().nullable().describe("Start date in YYYY-MM-DD format (optional)"),
+  to: zod.z.string().optional().nullable().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: from ?? void 0,
+      to: to ?? void 0
+    });
+    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: from ?? void 0,
+      to: to ?? void 0
+    });
+    return JSON.stringify(economicCalendar.data, null, 2);
+  }
+});
+var treasuryRatesInputSchema = zod.z.object({
+  from: zod.z.string().optional().nullable().describe("Start date in YYYY-MM-DD format (optional)"),
+  to: zod.z.string().optional().nullable().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().nullable().describe("Start date in YYYY-MM-DD format (optional)"),
+  to: zod.z.string().optional().nullable().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: from ?? void 0,
+      to: to ?? void 0
+    });
+    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: from ?? void 0,
+      to: to ?? void 0
+    });
+    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().nullable().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
+];
+checkOpenAIAgentsVersion();
+
+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