FinceptTerminal is a modern finance application offering advanced market analytics, investment research, and economic data tools, designed for interactive exploration and data-driven decision-making in a user-friendly environment.
C++ ai-agentsalgorithmic-tradingbloomberg-terminalcppfinancefinancial-marketsfintechgood-first-issueinvestmentinvestment-researchmachine-learningopensourcepythonqtquantitative-financestock-markettrading
// SurfaceAnalyticsTools.cpp — Tools for the Surface Analytics screen.
//
// 15 tools in category "surface-analytics":
// • Discovery (3) — categories, types, capability
// • Databento (12) — connection, fetches (options/ohlcv/futures/local_vol/
// implied_dividend/liquidity/commodity_vol/crack_spread/
// stress_test/yield_curve), cache access
// All Databento fetches are signal-bridged via DatabentoService::*_ready.
#include "mcp/tools/SurfaceAnalyticsTools.h"
#include "core/logging/Logger.h"
#include "mcp/AsyncDispatch.h"
#include "mcp/ToolSchemaBuilder.h"
#include "screens/surface_analytics/SurfaceCapabilities.h"
#include "screens/surface_analytics/SurfaceTypes.h"
#include "services/databento/DatabentoService.h"
#include <QJsonArray>
#include <QJsonObject>
#include <QObject>
#include <cmath>
#include <limits>
#include <optional>
namespace fincept::mcp::tools {
namespace {
static constexpr const char* TAG = "SurfaceAnalyticsTools";
static constexpr int kDefaultTimeoutMs = 120000;
// All 35 ChartType values in declaration order — maps int <-> name.
static const std::array<std::pair<surface::ChartType, const char*>, 35> kChartTypes = {{
{surface::ChartType::Volatility, "Volatility"},
{surface::ChartType::DeltaSurface, "DeltaSurface"},
{surface::ChartType::GammaSurface, "GammaSurface"},
{surface::ChartType::VegaSurface, "VegaSurface"},
{surface::ChartType::ThetaSurface, "ThetaSurface"},
{surface::ChartType::SkewSurface, "SkewSurface"},
{surface::ChartType::LocalVolSurface, "LocalVolSurface"},
{surface::ChartType::YieldCurve, "YieldCurve"},
{surface::ChartType::SwaptionVol, "SwaptionVol"},
{surface::ChartType::CapFloorVol, "CapFloorVol"},
{surface::ChartType::BondSpread, "BondSpread"},
{surface::ChartType::OISBasis, "OISBasis"},
{surface::ChartType::RealYield, "RealYield"},
{surface::ChartType::ForwardRate, "ForwardRate"},
{surface::ChartType::FXVol, "FXVol"},
{surface::ChartType::FXForwardPoints, "FXForwardPoints"},
{surface::ChartType::CrossCurrencyBasis, "CrossCurrencyBasis"},
{surface::ChartType::CDSSpread, "CDSSpread"},
{surface::ChartType::CreditTransition, "CreditTransition"},
{surface::ChartType::RecoveryRate, "RecoveryRate"},
{surface::ChartType::CommodityForward, "CommodityForward"},
{surface::ChartType::CommodityVol, "CommodityVol"},
{surface::ChartType::CrackSpread, "CrackSpread"},
{surface::ChartType::ContangoBackwardation, "ContangoBackwardation"},
{surface::ChartType::Correlation, "Correlation"},
{surface::ChartType::PCA, "PCA"},
{surface::ChartType::VaR, "VaR"},
{surface::ChartType::StressTestPnL, "StressTestPnL"},
{surface::ChartType::FactorExposure, "FactorExposure"},
{surface::ChartType::LiquidityHeatmap, "LiquidityHeatmap"},
{surface::ChartType::Drawdown, "Drawdown"},
{surface::ChartType::BetaSurface, "BetaSurface"},
{surface::ChartType::ImpliedDividend, "ImpliedDividend"},
{surface::ChartType::InflationExpectations, "InflationExpectations"},
{surface::ChartType::MonetaryPolicyPath, "MonetaryPolicyPath"},
}};
// nullopt for an unknown name. This used to fall back to Volatility, so a typo like
// "YieldCurv" quietly returned the Volatility capability row as if it were the answer.
std::optional<surface::ChartType> parse_chart_type(const QString& name) {
const QString wanted = name.trimmed();
for (const auto& p : kChartTypes)
if (wanted.compare(QString::fromLatin1(p.second), Qt::CaseInsensitive) == 0)
return p.first;
return std::nullopt;
}
QJsonObject capability_to_json(const surface::SurfaceCapability& c) {
return QJsonObject{
{"chart_type", chart_type_name(c.type)},
{"display_name", chart_type_name(c.type)},
{"tier", surface::tier_name(c.tier)},
{"dataset", QString::fromUtf8(c.dataset)},
{"schema", QString::fromUtf8(c.schema)},
{"symbology", QString::fromUtf8(c.symbology)},
{"description", QString::fromUtf8(c.description)},
{"needs_underlying", c.needs_underlying},
{"needs_date_range", c.needs_date_range},
{"needs_strike_window", c.needs_strike_window},
{"needs_expiry_filter", c.needs_expiry_filter},
{"needs_correlation_basket", c.needs_correlation_basket},
{"supports_3d", c.supports_3d},
{"supports_table", c.supports_table},
{"supports_line", c.supports_line},
};
}
// Grid values are floats, and QJsonValue(float) widens to double — so 0.21f is written
// as 0.20999999344348907 (17 digits). A 20x20 surface times six grids is thousands of
// those, i.e. roughly 3x the tokens for digits no float carries. Round to 4 decimals,
// which is far finer than the data's own precision. NaN/inf have no JSON form -> null.
double surface_json_num(float v) {
if (!std::isfinite(v))
return std::numeric_limits<double>::quiet_NaN(); // QJsonValue serialises NaN as null
return std::round(static_cast<double>(v) * 1e4) / 1e4;
}
QJsonArray surface_float_array(const std::vector<float>& xs) {
QJsonArray arr;
for (float v : xs)
arr.append(surface_json_num(v));
return arr;
}
QJsonArray z_to_json(const std::vector<std::vector<float>>& z) {
QJsonArray rows;
for (const auto& row : z)
rows.append(surface_float_array(row));
return rows;
}
QJsonObject vol_surface_to_json(const surface::VolatilitySurfaceData& v) {
QJsonArray strikes = surface_float_array(v.strikes), exps;
for (int e : v.expirations)
exps.append(e);
return QJsonObject{
{"underlying", QString::fromStdString(v.underlying)},
{"spot_price", surface_json_num(v.spot_price)},
{"strikes", strikes},
{"expirations", exps},
{"z", z_to_json(v.z)},
};
}
QJsonObject greeks_to_json(const surface::GreeksSurfaceData& g) {
QJsonArray strikes = surface_float_array(g.strikes), exps;
for (int e : g.expirations)
exps.append(e);
return QJsonObject{
{"underlying", QString::fromStdString(g.underlying)},
{"greek", QString::fromStdString(g.greek_name)},
{"spot_price", surface_json_num(g.spot_price)},
{"strikes", strikes},
{"expirations", exps},
{"z", z_to_json(g.z)},
};
}
QJsonObject skew_to_json(const surface::SkewSurfaceData& s) {
QJsonArray deltas = surface_float_array(s.deltas), exps;
for (int e : s.expirations)
exps.append(e);
return QJsonObject{
{"underlying", QString::fromStdString(s.underlying)},
{"deltas", deltas},
{"expirations", exps},
{"z", z_to_json(s.z)},
};
}
QJsonObject db_surface_to_json(const DatabentoSurfaceResult& r) {
QJsonArray xs = surface_float_array(r.x_axis), ys, xls, yls;
for (int v : r.y_axis)
ys.append(v);
for (const auto& s : r.x_labels)
xls.append(QString::fromStdString(s));
for (const auto& s : r.y_labels)
yls.append(QString::fromStdString(s));
return QJsonObject{
{"success", r.success}, {"error", r.error}, {"type", r.type}, {"x_axis", xs},
{"y_axis", ys}, {"x_labels", xls}, {"y_labels", yls}, {"z", z_to_json(r.z)},
};
}
QJsonObject vol_result_to_json(const DatabentoVolSurfaceResult& r) {
return QJsonObject{
{"success", r.success},
{"error", r.error},
{"vol", vol_surface_to_json(r.vol)},
{"delta", greeks_to_json(r.delta)},
{"gamma", greeks_to_json(r.gamma)},
{"vega", greeks_to_json(r.vega)},
{"theta", greeks_to_json(r.theta)},
{"skew", skew_to_json(r.skew)},
};
}
QJsonObject ohlcv_result_to_json(const DatabentoOhlcvResult& r) {
QJsonObject data;
for (auto it = r.data.constBegin(); it != r.data.constEnd(); ++it) {
QJsonArray bars;
for (const auto& b : it.value())
bars.append(b);
data[it.key()] = bars;
}
return QJsonObject{{"success", r.success}, {"error", r.error}, {"data", data}};
}
QJsonObject futures_result_to_json(const DatabentoFuturesResult& r) {
// This used to return only {"note": "Use surface_ready / cached_futures payload"} —
// a success result with NO futures data in it, for a tool whose whole purpose is the
// term structure. Both grids are small (commodities x contract months), so send them.
auto grid = [](const std::vector<std::string>& labels, const std::vector<int>& months,
const std::vector<std::vector<float>>& z) {
QJsonArray names;
for (const auto& n : labels)
names.append(QString::fromStdString(n));
QJsonArray ms;
for (int m : months)
ms.append(m);
return QJsonObject{{"commodities", names}, {"contract_months", ms}, {"z", z_to_json(z)}};
};
return QJsonObject{
{"success", r.success},
{"error", r.error},
{"forward", grid(r.forward.commodities, r.forward.contract_months, r.forward.z)},
{"contango", grid(r.contango.commodities, r.contango.contract_months, r.contango.z)},
};
}
// Bridge helper for *_ready signals. Each DB fetch kicks the call and
// listens for one of (vol_surface_ready, surface_ready, ohlcv_ready,
// futures_ready, fetch_failed); the first match resolves the promise.
template <typename SignalSig, typename KickFn, typename PayloadFn>
void bridge_db_fetch(QPointer<QObject> /*holder_parent*/, ToolContext ctx,
std::shared_ptr<QPromise<ToolResult>> promise, KickFn&& kick, SignalSig signal_member,
PayloadFn&& payload_fn) {
auto* svc = &DatabentoService::instance();
AsyncDispatch::callback_to_promise(
svc, std::move(ctx), promise,
[svc, kick = std::forward<KickFn>(kick), signal_member,
payload_fn = std::forward<PayloadFn>(payload_fn)](auto resolve) {
auto* h = new QObject(svc);
QObject::connect(svc, signal_member, h, [resolve, h, payload_fn](auto result) {
resolve(ToolResult::ok_data(payload_fn(result)));
h->deleteLater();
});
QObject::connect(svc, &DatabentoService::fetch_failed, h, [resolve, h](QString err) {
resolve(ToolResult::fail(err));
h->deleteLater();
});
kick();
});
}
} // namespace
std::vector<ToolDef> get_surface_analytics_tools() {
std::vector<ToolDef> tools;
// 1. list_surface_categories
{
ToolDef t;
t.name = "list_surface_categories";
t.description =
"List the 7 surface categories (Equity Deriv, Fixed Income, FX, Credit, Commodities, Risk, Macro).";
t.category = "surface-analytics";
t.handler = [](const QJsonObject&) -> ToolResult {
QJsonArray arr;
for (const auto& cat : surface::get_surface_categories()) {
QJsonArray types;
for (auto type : cat.types)
types.append(surface::chart_type_name(type));
arr.append(QJsonObject{
{"name", QString::fromUtf8(cat.name)},
{"surface_types", types},
{"count", static_cast<int>(cat.types.size())},
});
}
return ToolResult::ok_data(arr);
};
tools.push_back(std::move(t));
}
// 2. list_surface_types
{
ToolDef t;
t.name = "list_surface_types";
t.description = "List all 35 surface types with capability metadata (tier, dataset, schema, required inputs, "
"supported view modes).";
t.category = "surface-analytics";
t.handler = [](const QJsonObject&) -> ToolResult {
QJsonArray arr;
for (const auto& cap : surface::SURFACE_CAPABILITIES)
arr.append(capability_to_json(cap));
return ToolResult::ok_data(arr);
};
tools.push_back(std::move(t));
}
// 3. get_surface_capability
{
ToolDef t;
t.name = "get_surface_capability";
t.description = "Get capability metadata for one ChartType (tier, dataset/schema lineage, required inputs).";
t.category = "surface-analytics";
t.input_schema = ToolSchemaBuilder()
.string("chart_type", "ChartType name (e.g. 'Volatility', 'DeltaSurface', 'YieldCurve')")
.required()
.length(1, 64)
.build();
t.handler = [](const QJsonObject& args) -> ToolResult {
const auto ct = parse_chart_type(args["chart_type"].toString());
if (!ct) {
QStringList names;
for (const auto& p : kChartTypes)
names << QString::fromLatin1(p.second);
return ToolResult::fail("Unknown chart_type '" + args["chart_type"].toString().trimmed() +
"'. Valid names: " + names.join(", "));
}
return ToolResult::ok_data(capability_to_json(surface::capability_for(*ct)));
};
tools.push_back(std::move(t));
}
// 4. test_databento_connection
{
ToolDef t;
t.name = "test_databento_connection";
t.description = "Verify that the Databento API key works.";
t.category = "surface-analytics";
t.default_timeout_ms = 30000;
t.async_handler = [](const QJsonObject&, ToolContext ctx, std::shared_ptr<QPromise<ToolResult>> promise) {
auto* svc = &DatabentoService::instance();
AsyncDispatch::callback_to_promise(svc, std::move(ctx), promise, [svc](auto resolve) {
auto* h = new QObject(svc);
QObject::connect(svc, &DatabentoService::connection_tested, h,
[resolve, h](bool ok, const QString& msg) {
resolve(ok ? ToolResult::ok(msg) : ToolResult::fail(msg));
h->deleteLater();
});
svc->test_connection();
});
};
tools.push_back(std::move(t));
}
// 5. fetch_databento_options_surface
{
ToolDef t;
t.name = "fetch_databento_options_surface";
t.description = "Fetch the full options surface (vol + delta + gamma + vega + theta + skew) for an underlying.";
t.category = "surface-analytics";
t.is_destructive = true;
t.default_timeout_ms = kDefaultTimeoutMs;
t.input_schema = ToolSchemaBuilder()
.string("symbol", "Underlying ticker (e.g. SPY, AAPL)")
.required()
.length(1, 16)
.number("spot", "Spot price (0 = look up from DataHub)")
.default_num(0)
.min(0)
.build();
t.async_handler = [](const QJsonObject& args, ToolContext ctx, std::shared_ptr<QPromise<ToolResult>> promise) {
const QString sym = args["symbol"].toString();
const float spot = static_cast<float>(args["spot"].toDouble(0));
bridge_db_fetch(
{}, std::move(ctx), promise,
[sym, spot]() { DatabentoService::instance().fetch_options_surface(sym, spot); },
&DatabentoService::vol_surface_ready,
[](const DatabentoVolSurfaceResult& r) { return vol_result_to_json(r); });
};
tools.push_back(std::move(t));
}
// 6. fetch_databento_ohlcv
{
ToolDef t;
t.name = "fetch_databento_ohlcv";
t.description =
"Fetch historical OHLCV bars for one or more symbols (used for correlation, PCA, drawdown, beta).";
t.category = "surface-analytics";
t.is_destructive = true;
t.default_timeout_ms = kDefaultTimeoutMs;
t.input_schema = ToolSchemaBuilder()
.array("symbols", "Symbols to fetch", QJsonObject{{"type", "string"}})
.required()
.integer("days", "History window in days")
.default_int(60)
.between(1, 5000)
.build();
t.async_handler = [](const QJsonObject& args, ToolContext ctx, std::shared_ptr<QPromise<ToolResult>> promise) {
QStringList syms;
for (const auto& v : args["symbols"].toArray()) {
const QString sym = v.toString().trimmed();
if (!sym.isEmpty())
syms.append(sym);
}
if (syms.isEmpty()) {
// A billable Databento call with nothing to fetch — fail before it is made.
AsyncDispatch::callback_to_promise(nullptr, ctx, promise, [](auto resolve) {
resolve(ToolResult::fail("'symbols' must be a non-empty array of tickers"));
});
return;
}
const int days = args["days"].toInt(60);
bridge_db_fetch(
{}, std::move(ctx), promise, [syms, days]() { DatabentoService::instance().fetch_ohlcv(syms, days); },
&DatabentoService::ohlcv_ready, [](const DatabentoOhlcvResult& r) { return ohlcv_result_to_json(r); });
};
tools.push_back(std::move(t));
}
// 7. fetch_databento_futures_term_structure
{
ToolDef t;
t.name = "fetch_databento_futures_term_structure";
t.description = "Fetch futures term structure for commodities (forward curve + contango/backwardation).";
t.category = "surface-analytics";
t.is_destructive = true;
t.default_timeout_ms = kDefaultTimeoutMs;
t.input_schema =
ToolSchemaBuilder()
.array("commodities", "Commodity root symbols (e.g. CL, NG, GC)", QJsonObject{{"type", "string"}})
.required()
.build();
t.async_handler = [](const QJsonObject& args, ToolContext ctx, std::shared_ptr<QPromise<ToolResult>> promise) {
QStringList cs;
for (const auto& v : args["commodities"].toArray()) {
const QString c = v.toString().trimmed();
if (!c.isEmpty())
cs.append(c);
}
if (cs.isEmpty()) {
AsyncDispatch::callback_to_promise(nullptr, ctx, promise, [](auto resolve) {
resolve(ToolResult::fail("'commodities' must be a non-empty array of root symbols (e.g. CL, NG)"));
});
return;
}
bridge_db_fetch(
{}, std::move(ctx), promise, [cs]() { DatabentoService::instance().fetch_futures_term_structure(cs); },
&DatabentoService::futures_ready,
[](const DatabentoFuturesResult& r) { return futures_result_to_json(r); });
};
tools.push_back(std::move(t));
}
// Generic single-arg fetch builder for surface_ready endpoints.
auto make_db_surface_tool = [](const QString& name, const QString& desc,
std::function<void(const QJsonObject&)> /*kick*/) {
ToolDef t;
t.name = name;
t.description = desc;
t.category = "surface-analytics";
t.is_destructive = true;
t.default_timeout_ms = kDefaultTimeoutMs;
return t;
};
// 8. fetch_databento_local_vol
{
ToolDef t =
make_db_surface_tool("fetch_databento_local_vol", "Fetch local volatility surface for an underlying.", {});
t.input_schema = ToolSchemaBuilder()
.string("symbol", "Underlying ticker")
.required()
.length(1, 16)
.number("spot", "Spot price (0 = auto)")
.default_num(0)
.min(0)
.build();
t.async_handler = [](const QJsonObject& args, ToolContext ctx, std::shared_ptr<QPromise<ToolResult>> promise) {
const QString sym = args["symbol"].toString();
const float spot = static_cast<float>(args["spot"].toDouble(0));
bridge_db_fetch(
{}, std::move(ctx), promise, [sym, spot]() { DatabentoService::instance().fetch_local_vol(sym, spot); },
&DatabentoService::surface_ready,
[](const DatabentoSurfaceResult& r) { return db_surface_to_json(r); });
};
tools.push_back(std::move(t));
}
// 9. fetch_databento_implied_dividend
{
ToolDef t = make_db_surface_tool("fetch_databento_implied_dividend", "Fetch implied dividend surface.", {});
t.input_schema = ToolSchemaBuilder()
.string("symbol", "Underlying ticker")
.required()
.length(1, 16)
.number("spot", "Spot price (0 = auto)")
.default_num(0)
.min(0)
.build();
t.async_handler = [](const QJsonObject& args, ToolContext ctx, std::shared_ptr<QPromise<ToolResult>> promise) {
const QString sym = args["symbol"].toString();
const float spot = static_cast<float>(args["spot"].toDouble(0));
bridge_db_fetch(
{}, std::move(ctx), promise,
[sym, spot]() { DatabentoService::instance().fetch_implied_dividend(sym, spot); },
&DatabentoService::surface_ready,
[](const DatabentoSurfaceResult& r) { return db_surface_to_json(r); });
};
tools.push_back(std::move(t));
}
// 10. fetch_databento_liquidity
{
ToolDef t =
make_db_surface_tool("fetch_databento_liquidity", "Fetch options liquidity heatmap for an underlying.", {});
t.input_schema = ToolSchemaBuilder()
.string("symbol", "Underlying ticker")
.required()
.length(1, 16)
.number("spot", "Spot price (0 = auto)")
.default_num(0)
.min(0)
.build();
t.async_handler = [](const QJsonObject& args, ToolContext ctx, std::shared_ptr<QPromise<ToolResult>> promise) {
const QString sym = args["symbol"].toString();
const float spot = static_cast<float>(args["spot"].toDouble(0));
bridge_db_fetch(
{}, std::move(ctx), promise, [sym, spot]() { DatabentoService::instance().fetch_liquidity(sym, spot); },
&DatabentoService::surface_ready,
[](const DatabentoSurfaceResult& r) { return db_surface_to_json(r); });
};
tools.push_back(std::move(t));
}
// 11. fetch_databento_commodity_vol
{
ToolDef t = make_db_surface_tool("fetch_databento_commodity_vol",
"Fetch commodity volatility surface for a root symbol.", {});
t.input_schema =
ToolSchemaBuilder().string("root_symbol", "Commodity root (e.g. CL, NG)").required().length(1, 16).build();
t.async_handler = [](const QJsonObject& args, ToolContext ctx, std::shared_ptr<QPromise<ToolResult>> promise) {
const QString s = args["root_symbol"].toString();
bridge_db_fetch(
{}, std::move(ctx), promise, [s]() { DatabentoService::instance().fetch_commodity_vol(s); },
&DatabentoService::surface_ready,
[](const DatabentoSurfaceResult& r) { return db_surface_to_json(r); });
};
tools.push_back(std::move(t));
}
// 12. fetch_databento_crack_spread
{
ToolDef t = make_db_surface_tool("fetch_databento_crack_spread",
"Fetch crack-spread / crush-spread surface (energy/grains).", {});
t.async_handler = [](const QJsonObject&, ToolContext ctx, std::shared_ptr<QPromise<ToolResult>> promise) {
bridge_db_fetch(
{}, std::move(ctx), promise, []() { DatabentoService::instance().fetch_crack_spread(); },
&DatabentoService::surface_ready,
[](const DatabentoSurfaceResult& r) { return db_surface_to_json(r); });
};
tools.push_back(std::move(t));
}
// 13. fetch_databento_stress_test
{
ToolDef t = make_db_surface_tool("fetch_databento_stress_test",
"Run stress-test P&L surface for a basket of symbols.", {});
t.input_schema =
ToolSchemaBuilder().array("symbols", "Basket symbols", QJsonObject{{"type", "string"}}).required().build();
t.async_handler = [](const QJsonObject& args, ToolContext ctx, std::shared_ptr<QPromise<ToolResult>> promise) {
QStringList syms;
for (const auto& v : args["symbols"].toArray()) {
const QString sym = v.toString().trimmed();
if (!sym.isEmpty())
syms.append(sym);
}
if (syms.isEmpty()) {
AsyncDispatch::callback_to_promise(nullptr, ctx, promise, [](auto resolve) {
resolve(ToolResult::fail("'symbols' must be a non-empty array of tickers"));
});
return;
}
bridge_db_fetch(
{}, std::move(ctx), promise, [syms]() { DatabentoService::instance().fetch_stress_test(syms); },
&DatabentoService::surface_ready,
[](const DatabentoSurfaceResult& r) { return db_surface_to_json(r); });
};
tools.push_back(std::move(t));
}
// 14. fetch_databento_yield_curve
{
ToolDef t = make_db_surface_tool("fetch_databento_yield_curve",
"Fetch a yield-curve surface (Treasuries / sovereigns).", {});
t.async_handler = [](const QJsonObject&, ToolContext ctx, std::shared_ptr<QPromise<ToolResult>> promise) {
bridge_db_fetch(
{}, std::move(ctx), promise, []() { DatabentoService::instance().fetch_yield_curve(); },
&DatabentoService::surface_ready,
[](const DatabentoSurfaceResult& r) { return db_surface_to_json(r); });
};
tools.push_back(std::move(t));
}
// 15. get_databento_cached_data
{
ToolDef t;
t.name = "get_databento_cached_data";
t.description =
"Get the last-fetched cached Databento data (vol, ohlcv, futures) without triggering a network call.";
t.category = "surface-analytics";
t.handler = [](const QJsonObject&) -> ToolResult {
auto& svc = DatabentoService::instance();
return ToolResult::ok_data(QJsonObject{
{"has_api_key", svc.has_api_key()},
{"last_fetch_time", svc.last_fetch_time().toString(Qt::ISODate)},
{"vol", vol_result_to_json(svc.last_vol())},
{"ohlcv", ohlcv_result_to_json(svc.last_ohlcv())},
});
};
tools.push_back(std::move(t));
}
LOG_INFO(TAG, QString("Defined %1 surface-analytics tools").arg(tools.size()));
return tools;
}
} // namespace fincept::mcp::tools