fundamentalData_splits

Retrieve historical stock split data for any company symbol to analyze corporate actions and adjust historical price calculations.

Instructions

Fetches historical stock split data for a symbol.

Input Schema

TableJSON Schema

Name	Required	Description	Default
`symbol`	Yes	The stock symbol (e.g., "IBM").

Implementation Reference

src/index.ts:828-834 (handler)
The execute handler specific to the fundamentalData_splits tool. It invokes the shared executeAvantageTool helper, passing the tool name, arguments, context, and a callback that calls the AlphaVantage library's fundamentalData.splits method with the symbol parameter.
```
execute: (
  args,
  context // Let type be inferred
) =>
  executeAvantageTool("fundamentalData_splits", args, context, (av, params) =>
    av.fundamentalData.splits(params.symbol)
  ),
```

src/index.ts:824-835 (registration)

Registration of the fundamentalData_splits tool on the MCP server, including name, description, schema reference, and inline handler.

server.addTool({
  name: "fundamentalData_splits",
  description: "Fetches historical stock split data for a symbol.",
  parameters: schemas.FundamentalDataSymbolParamsSchema,
  execute: (
    args,
    context // Let type be inferred
  ) =>
    executeAvantageTool("fundamentalData_splits", args, context, (av, params) =>
      av.fundamentalData.splits(params.symbol)
    ),
});

src/schemas.ts:172-174 (schema)

Zod validation schema for the tool's input parameters, requiring a single 'symbol' string.

export const FundamentalDataSymbolParamsSchema = z.object({
  symbol: z.string().describe('The stock symbol (e.g., "IBM").'),
}).describe('Parameter schema requiring only a stock symbol.')

src/index.ts:38-115 (helper)

Core helper function used by all tools (including this one) to manage authentication, create/reuse AVantage client instances via ResourceManager, execute the specific library method, handle responses/errors, and return stringified data.

async function executeAvantageTool<TArgs, TResult>(
  toolName: string,
  args: TArgs,
  context: Context<Record<string, unknown> | undefined>, // Use the imported Context type directly
  avantageMethod: (
    av: AVantage,
    args: TArgs
  ) => Promise<{ error?: boolean; reason?: string; data?: TResult }>
): Promise<string> {
  logger.info(`Executing '${toolName}' tool for request ID: ${context}`);
  logger.debug(`Args for ${toolName}: ${JSON.stringify(args)}`);

  // --- Authentication & Resource Management ---
  // Access extraArgs safely - it might be null or undefined
  const extraArgsApiKey = context.extraArgs?.apiKey as string | undefined;
  const apiKey = extraArgsApiKey || config.apiKey;

  if (!apiKey) {
    logger.error(`'${toolName}' failed: Alpha Vantage API key missing.`);
    throw new UserError(apiKeyErrorMessage);
  }
  logger.debug(
    `Using AV API key (source: ${extraArgsApiKey ? "extraArgs" : "environment"}) for ${toolName}`
  );

  try {
    // Get or create AVantage instance managed by ResourceManager
    const av = await resourceManager.getResource<AVantage>(
      apiKey, // Cache key is the resolved API key
      "avantage_client", // Type identifier for logging
      async (key) => {
        // Factory Function
        logger.info(
          `Creating new AVantage instance for key ending ...${key.slice(-4)}`
        );
        // AVantage library reads AV_PREMIUM from process.env internally
        return new AVantage(key);
      },
      async (avInstance) => {
        // Cleanup Function (no-op needed for AVantage)
        logger.debug(`Destroying AVantage instance (no-op)`);
      }
    );

    // --- Library Call ---
    const result = await avantageMethod(av, args);

    // --- Response Handling ---
    if (result.error) {
      logger.warn(
        `'${toolName}' failed. Reason from avantage: ${result.reason}`
      );
      throw new UserError(result.reason || `Tool '${toolName}' failed.`);
    }

    if (result.data === undefined || result.data === null) {
      logger.warn(`'${toolName}' completed successfully but returned no data.`);
      return "null"; // Return string "null" for empty data
    }

    logger.info(`'${toolName}' completed successfully.`);
    // Stringify the data part of the response
    return JSON.stringify(result.data);
  } catch (error: any) {
    logger.error(
      `Error during execution of '${toolName}': ${error.message}`,
      error
    );
    // If it's already a UserError, rethrow it
    if (error instanceof UserError) {
      throw error;
    }
    // Otherwise, wrap it in a UserError
    throw new UserError(
      `An unexpected error occurred while executing tool '${toolName}': ${error.message}`
    );
  }
}

MCP Avantage