@oomol-lab/open-connector 1.6.2 → 1.6.3

package/src/providers/polygon_io/expanded-actions.js

@@ -0,0 +1,375 @@
+import { jsonSchema as s } from "../../core/json-schema.js";
+import { defineProviderAction } from "../../core/provider-definition.js";
+const service = "polygon_io";
+const ticker = s.nonEmptyString("The case-sensitive Massive ticker symbol, for example AAPL.");
+const text = (description) => s.nonEmptyString(description);
+const order = s.stringEnum("The order used when sorting returned results.", ["asc", "desc"]);
+const limit = s.integer("The maximum number of results to return.", { minimum: 1, maximum: 50000 });
+const snapshotLimit = s.integer("The maximum number of snapshot results to return.", {
+    minimum: 1,
+    maximum: 250,
+});
+const cursor = text("The pagination cursor from a previous response nextCursor value.");
+const date = (description) => s.date(description);
+const tickerArray = (description) => s.array(description, s.nonWhitespaceString("A Massive ticker symbol."), {
+    minItems: 1,
+    maxItems: 250,
+    uniqueItems: true,
+});
+const meta = s.object("Common response metadata returned by Massive.", {
+    status: s.nullable(s.string("The response status returned by Massive.")),
+    requestId: s.nullable(s.string("The request identifier assigned by Massive.")),
+    count: s.nullable(s.integer("The response count when Massive reports one.")),
+});
+const page = s.object("Cursor pagination information returned by Massive.", {
+    nextUrl: s.nullable(s.string("The next page URL when present.")),
+    nextCursor: s.nullable(s.string("The cursor extracted from nextUrl when present.")),
+});
+const rawRecord = s.looseObject("An unmodified result record returned by Massive.");
+const listOutput = (description) => s.object(description, {
+    meta,
+    results: s.array("The result records returned by Massive.", rawRecord),
+    page,
+});
+const resultOutput = (description) => s.object(description, { meta, result: s.unknown("The result payload returned by Massive.") });
+const pagedResultOutput = (description) => s.object(description, {
+    meta,
+    result: s.unknown("The result payload returned by Massive."),
+    page,
+});
+function input(description, properties, optional = []) {
+    return s.object(description, properties, { optional });
+}
+function readAction(config) {
+    return defineProviderAction(service, { operationType: "read", ...config });
+}
+const paging = { order, limit, sort: text("The upstream field used to sort results."), cursor };
+const pagingOptional = ["order", "limit", "sort", "cursor"];
+const dateRange = {
+    date: date("Filter results to this date."),
+    dateGte: date("Return results on or after this date."),
+    dateLte: date("Return results on or before this date."),
+};
+export const expandedPolygonIoActions = [
+    readAction({
+        name: "list_related_tickers",
+        description: "List companies related to a Massive stock ticker.",
+        inputSchema: input("Input parameters for listing related tickers.", { ticker }),
+        outputSchema: listOutput("The related tickers returned by Massive."),
+    }),
+    readAction({
+        name: "get_daily_open_close",
+        description: "Get a stock ticker's open, close, and extended-hours prices for one date.",
+        inputSchema: input("Input parameters for retrieving a daily open and close summary.", {
+            ticker,
+            date: date("The trading date to retrieve."),
+            adjusted: s.boolean("Whether prices should be adjusted for splits."),
+        }, ["adjusted"]),
+        outputSchema: resultOutput("The daily open and close summary returned by Massive."),
+    }),
+    readAction({
+        name: "get_stock_snapshot",
+        description: "Get the latest trade, quote, minute, day, and previous-day data for one stock.",
+        inputSchema: input("Input parameters for retrieving a stock snapshot.", { ticker }),
+        outputSchema: resultOutput("The stock snapshot returned by Massive."),
+    }),
+    readAction({
+        name: "get_unified_snapshot",
+        description: "Get current snapshots for an explicit list of Massive tickers across asset classes.",
+        inputSchema: input("Input parameters for retrieving unified snapshots.", {
+            tickers: tickerArray("The ticker symbols to retrieve."),
+            assetType: s.stringEnum("The optional asset type filter.", ["stocks", "options", "fx", "crypto", "indices"]),
+            ...paging,
+            limit: snapshotLimit,
+        }, ["assetType", ...pagingOptional]),
+        outputSchema: listOutput("The unified snapshots returned by Massive."),
+    }),
+    readAction({
+        name: "get_stock_movers",
+        description: "Get the current top gaining or losing U.S. stocks.",
+        inputSchema: input("Input parameters for retrieving stock market movers.", {
+            direction: s.stringEnum("Whether to return gainers or losers.", ["gainers", "losers"]),
+        }),
+        outputSchema: listOutput("The stock market movers returned by Massive."),
+    }),
+    readAction({
+        name: "list_trades",
+        description: "List historical trades for a stock or options ticker.",
+        inputSchema: input("Input parameters for listing historical trades.", {
+            ticker,
+            timestamp: text("Filter by an exact date, nanosecond timestamp, or RFC 3339 timestamp."),
+            timestampGte: text("Return trades at or after this date or timestamp."),
+            timestampLte: text("Return trades at or before this date or timestamp."),
+            ...paging,
+        }, ["timestamp", "timestampGte", "timestampLte", ...pagingOptional]),
+        outputSchema: listOutput("The historical trades returned by Massive."),
+    }),
+    readAction({
+        name: "get_last_stock_trade",
+        description: "Get the latest available trade for a stock ticker.",
+        inputSchema: input("Input parameters for retrieving the latest stock trade.", { ticker }),
+        outputSchema: resultOutput("The latest stock trade returned by Massive."),
+    }),
+    readAction({
+        name: "list_quotes",
+        description: "List historical quotes for a stock or options ticker.",
+        inputSchema: input("Input parameters for listing historical quotes.", {
+            ticker,
+            timestamp: text("Filter by an exact date, nanosecond timestamp, or RFC 3339 timestamp."),
+            timestampGte: text("Return quotes at or after this date or timestamp."),
+            timestampLte: text("Return quotes at or before this date or timestamp."),
+            ...paging,
+        }, ["timestamp", "timestampGte", "timestampLte", ...pagingOptional]),
+        outputSchema: listOutput("The historical quotes returned by Massive."),
+    }),
+    readAction({
+        name: "get_last_stock_quote",
+        description: "Get the latest national best bid and offer for a stock ticker.",
+        inputSchema: input("Input parameters for retrieving the latest stock quote.", { ticker }),
+        outputSchema: resultOutput("The latest stock quote returned by Massive."),
+    }),
+    readAction({
+        name: "list_market_holidays",
+        description: "List upcoming market holidays and their trading hours.",
+        inputSchema: input("The input payload for listing upcoming market holidays.", {}),
+        outputSchema: listOutput("The upcoming market holidays returned by Massive."),
+    }),
+    readAction({
+        name: "list_condition_codes",
+        description: "List trade and quote condition codes known by Massive.",
+        inputSchema: input("Input parameters for listing condition codes.", {
+            assetClass: text("Filter by asset class, such as stocks or options."),
+            dataType: s.stringEnum("Filter conditions by market data type.", ["trade", "quote"]),
+            id: s.integer("Filter by the Massive condition identifier."),
+            sipMapping: text("Filter by a Securities Information Processor mapping."),
+        }, ["assetClass", "dataType", "id", "sipMapping"]),
+        outputSchema: listOutput("The condition codes returned by Massive."),
+    }),
+    readAction({
+        name: "list_ticker_news",
+        description: "List recent financial news and sentiment associated with tickers.",
+        inputSchema: input("Input parameters for listing ticker news.", {
+            ticker,
+            publishedUtcGte: text("Return articles published at or after this RFC 3339 timestamp."),
+            publishedUtcLte: text("Return articles published at or before this RFC 3339 timestamp."),
+            ...paging,
+        }, ["ticker", "publishedUtcGte", "publishedUtcLte", ...pagingOptional]),
+        outputSchema: listOutput("The news articles returned by Massive."),
+    }),
+    readAction({
+        name: "list_dividends",
+        description: "List current-version stock dividend events and adjustment factors.",
+        inputSchema: input("Input parameters for listing stock dividends.", {
+            ticker,
+            exDividendDate: date("Filter by an exact ex-dividend date."),
+            exDividendDateGte: date("Return dividends with an ex-dividend date on or after this date."),
+            exDividendDateLte: date("Return dividends with an ex-dividend date on or before this date."),
+            ...paging,
+        }, ["ticker", "exDividendDate", "exDividendDateGte", "exDividendDateLte", ...pagingOptional]),
+        outputSchema: listOutput("The stock dividend events returned by Massive."),
+    }),
+    readAction({
+        name: "list_splits",
+        description: "List current-version stock split events and adjustment factors.",
+        inputSchema: input("Input parameters for listing stock splits.", {
+            ticker,
+            executionDate: date("Filter by an exact split execution date."),
+            executionDateGte: date("Return splits executed on or after this date."),
+            executionDateLte: date("Return splits executed on or before this date."),
+            ...paging,
+        }, ["ticker", "executionDate", "executionDateGte", "executionDateLte", ...pagingOptional]),
+        outputSchema: listOutput("The stock split events returned by Massive."),
+    }),
+    ...["balance_sheets", "income_statements", "cash_flow_statements", "financial_ratios"].map((name) => readAction({
+        name: `list_${name}`,
+        description: `List company ${name.split("_").join(" ")} from Massive.`,
+        inputSchema: input(`Input parameters for listing company ${name.split("_").join(" ")}.`, {
+            tickers: tickerArray("Filter by one or more stock tickers."),
+            cik: text("Filter by Central Index Key."),
+            timeframe: s.stringEnum("Filter by reporting timeframe.", ["quarterly", "annual", "trailing_twelve_months"]),
+            fiscalYear: s.integer("Filter by fiscal year."),
+            fiscalQuarter: s.integer("Filter by fiscal quarter.", { minimum: 1, maximum: 4 }),
+            periodEnd: date("Filter by an exact reporting period end date."),
+            periodEndGte: date("Return periods ending on or after this date."),
+            periodEndLte: date("Return periods ending on or before this date."),
+            filingDateGte: date("Return statements filed on or after this date."),
+            filingDateLte: date("Return statements filed on or before this date."),
+            ...paging,
+        }, [
+            "tickers",
+            "cik",
+            "timeframe",
+            "fiscalYear",
+            "fiscalQuarter",
+            "periodEnd",
+            "periodEndGte",
+            "periodEndLte",
+            "filingDateGte",
+            "filingDateLte",
+            ...pagingOptional,
+        ]),
+        outputSchema: listOutput(`The company ${name.split("_").join(" ")} returned by Massive.`),
+    })),
+    readAction({
+        name: "list_short_interest",
+        description: "List reported short interest for U.S. stocks.",
+        inputSchema: input("Input parameters for listing short interest.", {
+            ticker,
+            settlementDate: date("Filter by settlement date."),
+            settlementDateGte: date("Return records settled on or after this date."),
+            settlementDateLte: date("Return records settled on or before this date."),
+            ...paging,
+        }, ["ticker", "settlementDate", "settlementDateGte", "settlementDateLte", ...pagingOptional]),
+        outputSchema: listOutput("The short-interest records returned by Massive."),
+    }),
+    readAction({
+        name: "list_short_volume",
+        description: "List daily short-sale volume for U.S. stocks.",
+        inputSchema: input("Input parameters for listing short volume.", { ticker, ...dateRange, ...paging }, [
+            "ticker",
+            "date",
+            "dateGte",
+            "dateLte",
+            ...pagingOptional,
+        ]),
+        outputSchema: listOutput("The short-volume records returned by Massive."),
+    }),
+    readAction({
+        name: "list_option_contracts",
+        description: "List Massive options contracts with contract-specific filters.",
+        inputSchema: input("Input parameters for listing options contracts.", {
+            underlyingTicker: ticker,
+            contractType: s.stringEnum("Filter by options contract type.", ["call", "put"]),
+            expirationDate: date("Filter by an exact expiration date."),
+            expirationDateGte: date("Return contracts expiring on or after this date."),
+            expirationDateLte: date("Return contracts expiring on or before this date."),
+            strikePrice: s.number("Filter by an exact strike price."),
+            expired: s.boolean("Whether to include expired contracts."),
+            asOf: date("Return contracts valid as of this date."),
+            ...paging,
+        }, [
+            "underlyingTicker",
+            "contractType",
+            "expirationDate",
+            "expirationDateGte",
+            "expirationDateLte",
+            "strikePrice",
+            "expired",
+            "asOf",
+            ...pagingOptional,
+        ]),
+        outputSchema: listOutput("The options contracts returned by Massive."),
+    }),
+    readAction({
+        name: "get_option_contract",
+        description: "Get reference details for one Massive options contract.",
+        inputSchema: input("Input parameters for retrieving an options contract.", {
+            optionsTicker: text("The case-sensitive Massive options contract ticker."),
+            asOf: date("Return the contract definition valid as of this date."),
+        }, ["asOf"]),
+        outputSchema: resultOutput("The options contract details returned by Massive."),
+    }),
+    readAction({
+        name: "get_option_chain_snapshot",
+        description: "Get an options chain with prices, Greeks, implied volatility, and open interest.",
+        inputSchema: input("Input parameters for retrieving an options chain snapshot.", {
+            underlyingTicker: ticker,
+            contractType: s.stringEnum("Filter by options contract type.", ["call", "put"]),
+            expirationDate: date("Filter by an exact expiration date."),
+            expirationDateGte: date("Return contracts expiring on or after this date."),
+            expirationDateLte: date("Return contracts expiring on or before this date."),
+            strikePrice: s.number("Filter by an exact strike price."),
+            strikePriceGte: s.number("Return contracts at or above this strike price."),
+            strikePriceLte: s.number("Return contracts at or below this strike price."),
+            ...paging,
+        }, [
+            "contractType",
+            "expirationDate",
+            "expirationDateGte",
+            "expirationDateLte",
+            "strikePrice",
+            "strikePriceGte",
+            "strikePriceLte",
+            ...pagingOptional,
+        ]),
+        outputSchema: listOutput("The options chain snapshots returned by Massive."),
+    }),
+    readAction({
+        name: "get_option_contract_snapshot",
+        description: "Get prices, Greeks, implied volatility, and open interest for one options contract.",
+        inputSchema: input("Input parameters for retrieving an options contract snapshot.", {
+            underlyingTicker: ticker,
+            optionsTicker: text("The case-sensitive Massive options contract ticker."),
+        }),
+        outputSchema: resultOutput("The options contract snapshot returned by Massive."),
+    }),
+    ...["treasury_yields", "inflation", "inflation_expectations", "labor_market", "funding_conditions"].map((name) => readAction({
+        name: `list_${name}`,
+        description: `List U.S. ${name.split("_").join(" ")} observations from Massive.`,
+        inputSchema: input(`Input parameters for listing ${name.split("_").join(" ")} observations.`, { ...dateRange, ...paging }, ["date", "dateGte", "dateLte", ...pagingOptional]),
+        outputSchema: listOutput(`The ${name.split("_").join(" ")} observations returned by Massive.`),
+    })),
+    ...["sma", "ema", "rsi"].map((name) => readAction({
+        name: `get_${name}`,
+        description: `Get the ${name.toUpperCase()} technical indicator for a Massive ticker.`,
+        inputSchema: input(`Input parameters for retrieving the ${name.toUpperCase()} indicator.`, {
+            ticker,
+            timespan: text("The aggregate timespan used to calculate the indicator."),
+            window: s.positiveInteger("The number of aggregate periods in the calculation window."),
+            adjusted: s.boolean("Whether the underlying aggregates should be split adjusted."),
+            expandUnderlying: s.boolean("Whether to include the underlying aggregate bars used by the indicator."),
+            seriesType: s.stringEnum("The aggregate price series used by the indicator.", [
+                "open",
+                "high",
+                "low",
+                "close",
+            ]),
+            timestamp: text("Filter by an exact date or millisecond timestamp."),
+            timestampGte: text("Return values at or after this date or timestamp."),
+            timestampLte: text("Return values at or before this date or timestamp."),
+            ...paging,
+        }, [
+            "timespan",
+            "window",
+            "adjusted",
+            "expandUnderlying",
+            "seriesType",
+            "timestamp",
+            "timestampGte",
+            "timestampLte",
+            ...pagingOptional,
+        ]),
+        outputSchema: pagedResultOutput(`The ${name.toUpperCase()} values returned by Massive.`),
+    })),
+    readAction({
+        name: "get_macd",
+        description: "Get the MACD technical indicator for a Massive ticker.",
+        inputSchema: input("Input parameters for retrieving the MACD indicator.", {
+            ticker,
+            timespan: text("The aggregate timespan used to calculate MACD."),
+            shortWindow: s.positiveInteger("The short exponential moving-average window."),
+            longWindow: s.positiveInteger("The long exponential moving-average window."),
+            signalWindow: s.positiveInteger("The signal-line exponential moving-average window."),
+            adjusted: s.boolean("Whether the underlying aggregates should be split adjusted."),
+            expandUnderlying: s.boolean("Whether to include the underlying aggregate bars used by MACD."),
+            seriesType: s.stringEnum("The aggregate price series used by MACD.", ["open", "high", "low", "close"]),
+            timestamp: text("Filter by an exact date or millisecond timestamp."),
+            timestampGte: text("Return values at or after this date or timestamp."),
+            timestampLte: text("Return values at or before this date or timestamp."),
+            ...paging,
+        }, [
+            "timespan",
+            "shortWindow",
+            "longWindow",
+            "signalWindow",
+            "adjusted",
+            "expandUnderlying",
+            "seriesType",
+            "timestamp",
+            "timestampGte",
+            "timestampLte",
+            ...pagingOptional,
+        ]),
+        outputSchema: pagedResultOutput("The MACD values returned by Massive."),
+    }),
+];

package/src/providers/polygon_io/expanded-runtime.d.ts

@@ -0,0 +1,16 @@
+type RequestMassiveJson = (input: {
+    path: string;
+    apiKey: string;
+    query: Record<string, string | number | boolean | undefined>;
+    fetcher: typeof fetch;
+    phase: "execute";
+}) => Promise<unknown>;
+export declare const expandedPolygonIoActionNames: ReadonlySet<string>;
+export declare function executeExpandedPolygonIoAction(input: {
+    actionName: string;
+    input: Record<string, unknown>;
+    fetcher: typeof fetch;
+    apiKey: string;
+    requestJson: RequestMassiveJson;
+}): Promise<unknown>;
+export {};

package/src/providers/polygon_io/expanded-runtime.js

@@ -0,0 +1,277 @@
+import { compactObject, optionalBoolean, optionalInteger, optionalNumber, optionalRecord, optionalString, optionalStringArray, } from "../../core/cast.js";
+import { providerInputError, requiredInputString } from "../provider-runtime.js";
+import { expandedPolygonIoActions } from "./expanded-actions.js";
+export const expandedPolygonIoActionNames = new Set(expandedPolygonIoActions.map((action) => action.name));
+export async function executeExpandedPolygonIoAction(input) {
+    const request = resolveRequest(input.actionName, input.input);
+    const payload = await input.requestJson({
+        ...request,
+        apiKey: input.apiKey,
+        fetcher: input.fetcher,
+        phase: "execute",
+    });
+    if (request.mode === "list") {
+        return normalizeList(payload);
+    }
+    if (request.mode === "pagedResult") {
+        return { ...normalizeResult(payload), page: normalizePage(optionalRecord(payload)) };
+    }
+    return normalizeResult(payload);
+}
+function resolveRequest(actionName, input) {
+    const ticker = () => encodeURIComponent(requiredInputString(input.ticker, "ticker"));
+    const underlyingTicker = () => encodeURIComponent(requiredInputString(input.underlyingTicker, "underlyingTicker"));
+    const optionsTicker = () => encodeURIComponent(requiredInputString(input.optionsTicker, "optionsTicker"));
+    const list = (path, query = {}) => ({
+        path,
+        query,
+        mode: "list",
+    });
+    const result = (path, query = {}) => ({
+        path,
+        query,
+        mode: "result",
+    });
+    const pagedResult = (path, query = {}) => ({
+        path,
+        query,
+        mode: "pagedResult",
+    });
+    switch (actionName) {
+        case "list_related_tickers":
+            return list(`/v1/related-companies/${ticker()}`);
+        case "get_daily_open_close":
+            return result(`/v1/open-close/${ticker()}/${encodeURIComponent(requiredInputString(input.date, "date"))}`, {
+                adjusted: optionalBoolean(input.adjusted),
+            });
+        case "get_stock_snapshot":
+            return result(`/v2/snapshot/locale/us/markets/stocks/tickers/${ticker()}`);
+        case "get_unified_snapshot":
+            return list("/v3/snapshot", {
+                "ticker.any_of": readStringArray(input.tickers)?.join(","),
+                type: readText(input.assetType),
+                ...pagingQuery(input),
+            });
+        case "get_stock_movers":
+            return list(`/v2/snapshot/locale/us/markets/stocks/${encodeURIComponent(requiredInputString(input.direction, "direction"))}`);
+        case "list_trades":
+            return list(`/v3/trades/${ticker()}`, timestampQuery(input));
+        case "get_last_stock_trade":
+            return result(`/v2/last/trade/${ticker()}`);
+        case "list_quotes":
+            return list(`/v3/quotes/${ticker()}`, timestampQuery(input));
+        case "get_last_stock_quote":
+            return result(`/v2/last/nbbo/${ticker()}`);
+        case "list_market_holidays":
+            return list("/v1/marketstatus/upcoming");
+        case "list_condition_codes":
+            return list("/v3/reference/conditions", compactObject({
+                asset_class: readText(input.assetClass),
+                data_type: readText(input.dataType),
+                id: readIntegerString(input.id),
+                sip_mapping: readText(input.sipMapping),
+            }));
+        case "list_ticker_news":
+            return list("/v2/reference/news", compactObject({
+                ticker: readText(input.ticker),
+                "published_utc.gte": readText(input.publishedUtcGte),
+                "published_utc.lte": readText(input.publishedUtcLte),
+                ...pagingQuery(input),
+            }));
+        case "list_dividends":
+            return list("/stocks/v1/dividends", compactObject({
+                ticker: readText(input.ticker),
+                ex_dividend_date: readText(input.exDividendDate),
+                "ex_dividend_date.gte": readText(input.exDividendDateGte),
+                "ex_dividend_date.lte": readText(input.exDividendDateLte),
+                ...pagingQuery(input),
+            }));
+        case "list_splits":
+            return list("/stocks/v1/splits", compactObject({
+                ticker: readText(input.ticker),
+                execution_date: readText(input.executionDate),
+                "execution_date.gte": readText(input.executionDateGte),
+                "execution_date.lte": readText(input.executionDateLte),
+                ...pagingQuery(input),
+            }));
+        case "list_balance_sheets":
+            return list("/stocks/financials/v1/balance-sheets", financialsQuery(input));
+        case "list_income_statements":
+            return list("/stocks/financials/v1/income-statements", financialsQuery(input));
+        case "list_cash_flow_statements":
+            return list("/stocks/financials/v1/cash-flow-statements", financialsQuery(input));
+        case "list_financial_ratios":
+            return list("/stocks/financials/v1/ratios", financialsQuery(input));
+        case "list_short_interest":
+            return list("/stocks/v1/short-interest", compactObject({
+                ticker: readText(input.ticker),
+                settlement_date: readText(input.settlementDate),
+                "settlement_date.gte": readText(input.settlementDateGte),
+                "settlement_date.lte": readText(input.settlementDateLte),
+                ...pagingQuery(input),
+            }));
+        case "list_short_volume":
+            return list("/stocks/v1/short-volume", datedListQuery(input));
+        case "list_option_contracts":
+            return list("/v3/reference/options/contracts", optionFilters(input));
+        case "get_option_contract":
+            return result(`/v3/reference/options/contracts/${optionsTicker()}`, {
+                as_of: readText(input.asOf),
+            });
+        case "get_option_chain_snapshot":
+            return list(`/v3/snapshot/options/${underlyingTicker()}`, optionFilters(input));
+        case "get_option_contract_snapshot":
+            return result(`/v3/snapshot/options/${underlyingTicker()}/${optionsTicker()}`);
+        case "list_treasury_yields":
+            return list("/fed/v1/treasury-yields", datedListQuery(input));
+        case "list_inflation":
+            return list("/fed/v1/inflation", datedListQuery(input));
+        case "list_inflation_expectations":
+            return list("/fed/v1/inflation-expectations", datedListQuery(input));
+        case "list_labor_market":
+            return list("/fed/v1/labor-market", datedListQuery(input));
+        case "list_funding_conditions":
+            return list("/fed/v1/funding-conditions", datedListQuery(input));
+        case "get_sma":
+            return pagedResult(`/v1/indicators/sma/${ticker()}`, indicatorQuery(input));
+        case "get_ema":
+            return pagedResult(`/v1/indicators/ema/${ticker()}`, indicatorQuery(input));
+        case "get_rsi":
+            return pagedResult(`/v1/indicators/rsi/${ticker()}`, indicatorQuery(input));
+        case "get_macd":
+            return pagedResult(`/v1/indicators/macd/${ticker()}`, compactObject({
+                ...indicatorQuery(input),
+                short_window: readIntegerString(input.shortWindow),
+                long_window: readIntegerString(input.longWindow),
+                signal_window: readIntegerString(input.signalWindow),
+            }));
+    }
+    throw providerInputError(`Unknown polygon_io action: ${actionName}`);
+}
+function pagingQuery(input) {
+    return compactObject({
+        order: readText(input.order),
+        limit: readIntegerString(input.limit),
+        sort: readText(input.sort),
+        cursor: readText(input.cursor),
+    });
+}
+function timestampQuery(input) {
+    return compactObject({
+        timestamp: readText(input.timestamp),
+        "timestamp.gte": readText(input.timestampGte),
+        "timestamp.lte": readText(input.timestampLte),
+        ...pagingQuery(input),
+    });
+}
+function datedListQuery(input) {
+    return compactObject({
+        ticker: readText(input.ticker),
+        date: readText(input.date),
+        "date.gte": readText(input.dateGte),
+        "date.lte": readText(input.dateLte),
+        ...pagingQuery(input),
+    });
+}
+function financialsQuery(input) {
+    return compactObject({
+        tickers: readStringArray(input.tickers)?.join(","),
+        cik: readText(input.cik),
+        timeframe: readText(input.timeframe),
+        fiscal_year: readIntegerString(input.fiscalYear),
+        fiscal_quarter: readIntegerString(input.fiscalQuarter),
+        period_end: readText(input.periodEnd),
+        "period_end.gte": readText(input.periodEndGte),
+        "period_end.lte": readText(input.periodEndLte),
+        "filing_date.gte": readText(input.filingDateGte),
+        "filing_date.lte": readText(input.filingDateLte),
+        ...pagingQuery(input),
+    });
+}
+function optionFilters(input) {
+    return compactObject({
+        underlying_ticker: readText(input.underlyingTicker),
+        contract_type: readText(input.contractType),
+        expiration_date: readText(input.expirationDate),
+        "expiration_date.gte": readText(input.expirationDateGte),
+        "expiration_date.lte": readText(input.expirationDateLte),
+        strike_price: readNumberString(input.strikePrice),
+        "strike_price.gte": readNumberString(input.strikePriceGte),
+        "strike_price.lte": readNumberString(input.strikePriceLte),
+        expired: optionalBoolean(input.expired),
+        as_of: readText(input.asOf),
+        ...pagingQuery(input),
+    });
+}
+function indicatorQuery(input) {
+    return compactObject({
+        timespan: readText(input.timespan),
+        window: readIntegerString(input.window),
+        adjusted: optionalBoolean(input.adjusted),
+        expand_underlying: optionalBoolean(input.expandUnderlying),
+        series_type: readText(input.seriesType),
+        timestamp: readText(input.timestamp),
+        "timestamp.gte": readText(input.timestampGte),
+        "timestamp.lte": readText(input.timestampLte),
+        ...pagingQuery(input),
+    });
+}
+function normalizeList(payload) {
+    const response = optionalRecord(payload);
+    const results = Array.isArray(payload)
+        ? payload
+        : Array.isArray(response?.results)
+            ? response.results
+            : Array.isArray(response?.tickers)
+                ? response.tickers
+                : [];
+    return {
+        meta: normalizeMeta(response),
+        results: results
+            .map((item) => optionalRecord(item))
+            .filter((item) => item !== undefined),
+        page: normalizePage(response),
+    };
+}
+function normalizeResult(payload) {
+    const response = optionalRecord(payload);
+    return {
+        meta: normalizeMeta(response),
+        result: response?.results ?? payload,
+    };
+}
+function normalizeMeta(response) {
+    return {
+        status: optionalString(response?.status) ?? null,
+        requestId: optionalString(response?.request_id) ?? null,
+        count: optionalInteger(response?.count) ?? null,
+    };
+}
+function normalizePage(response) {
+    const nextUrl = optionalString(response?.next_url) ?? null;
+    return { nextUrl, nextCursor: nextUrl ? readCursor(nextUrl) : null };
+}
+function readCursor(nextUrl) {
+    try {
+        return new URL(nextUrl).searchParams.get("cursor");
+    }
+    catch {
+        return null;
+    }
+}
+function readText(value) {
+    return optionalString(value);
+}
+function readIntegerString(value) {
+    const number = optionalInteger(value);
+    return number === undefined ? undefined : String(number);
+}
+function readNumberString(value) {
+    const number = optionalNumber(value);
+    return number === undefined ? undefined : String(number);
+}
+function readStringArray(value) {
+    return optionalStringArray(value)
+        ?.map((item) => item.trim())
+        .filter(Boolean);
+}