fix: correct EOD timestamp decoding and clarify option bulk filters

Author: userFRM

crates/thetadatadx/build_support/ticks.rs

@@ -82,9 +82,11 @@ fn generate_parser(out: &mut String, type_name: &str, def: &TickTypeDef) {
     )
     .unwrap();
 
-    // If eod_style, emit the local eod_num and eod_price helpers inline.
+    // If eod_style, emit the local EOD helpers inline.
     if def.eod_style {
-        out.push_str("    // EOD rows may have Price-typed cells or plain Number cells.\n");
+        out.push_str(
+            "    // EOD numeric/time fields may arrive as Price, Number, or Timestamp cells.\n",
+        );
         out.push_str("    fn eod_num(row: &crate::proto::DataValueList, idx: usize) -> i32 {\n");
         out.push_str("        row.values\n");
         out.push_str("            .get(idx)\n");
@@ -96,6 +98,26 @@ fn generate_parser(out: &mut String, type_name: &str, def: &TickTypeDef) {
         out.push_str(
             "                crate::proto::data_value::DataType::Price(p) => Some(p.value),\n",
         );
+        out.push_str(
+            "                crate::proto::data_value::DataType::Timestamp(ts) => Some(crate::decode::timestamp_to_ms_of_day(ts.epoch_ms)),\n",
+        );
+        out.push_str("                _ => None,\n");
+        out.push_str("            })\n");
+        out.push_str("            .unwrap_or(0)\n");
+        out.push_str("    }\n\n");
+
+        out.push_str("    // EOD date fields may arrive as Price, Number, or Timestamp cells.\n");
+        out.push_str("    fn eod_date(row: &crate::proto::DataValueList, idx: usize) -> i32 {\n");
+        out.push_str("        row.values\n");
+        out.push_str("            .get(idx)\n");
+        out.push_str("            .and_then(|dv| dv.data_type.as_ref())\n");
+        out.push_str("            .and_then(|dt| match dt {\n");
+        out.push_str(
+            "                crate::proto::data_value::DataType::Number(n) => Some(*n as i32),\n",
+        );
+        out.push_str(
+            "                crate::proto::data_value::DataType::Price(p) => Some(p.value),\n",
+        );
         out.push_str(
             "                crate::proto::data_value::DataType::Timestamp(ts) => Some(crate::decode::timestamp_to_date(ts.epoch_ms)),\n",
         );
@@ -318,6 +340,14 @@ fn generate_parser(out: &mut String, type_name: &str, def: &TickTypeDef) {
                 )
                 .unwrap();
             }
+            "eod_date" => {
+                writeln!(
+                    out,
+                    "                {}: {var}.map(|i| eod_date(row, i)).unwrap_or(0),",
+                    col.field
+                )
+                .unwrap();
+            }
             "eod_price" => {
                 // EOD price field: decode to f64 from Price or Number cell.
                 writeln!(

crates/thetadatadx/endpoint_schema.toml

@@ -9,7 +9,8 @@
 #   f64     -> row_float(row, i)                          default: 0.0
 #   String  -> row_text(row, i)                           default: ""
 #   price   -> decode to f64 via Price::new(raw, pt).to_f64()
-#   eod_num -> eod_num(row, i) handles both Price and Number cells  default: 0
+#   eod_num -> EOD numeric/time field: Price/Number direct, Timestamp -> ms_of_day
+#   eod_date -> EOD date field: Price/Number direct, Timestamp -> YYYYMMDD
 #   eod_price -> EOD price fields: decode to f64 at parse time
 #
 # Parser options:
@@ -115,7 +116,7 @@ columns = [
     { name = "ask_exchange",  field = "ask_exchange",  type = "eod_num" },
     { name = "ask",           field = "ask",           type = "eod_price" },
     { name = "ask_condition", field = "ask_condition", type = "eod_num" },
-    { name = "date",          field = "date",          type = "eod_num" },
+    { name = "date",          field = "date",          type = "eod_date" },
 ]
 
 # ─────────────────────────────────────────────────────────────────────────────

crates/thetadatadx/src/decode.rs

@@ -170,7 +170,7 @@ fn civil_to_epoch_days(year: i32, month: u32, day: u32) -> i64 {
 /// Convert `epoch_ms` to milliseconds-of-day in Eastern Time (DST-aware).
 // Reason: ms_of_day fits in i32; epoch_ms is in valid market data range.
 #[allow(clippy::cast_possible_wrap, clippy::cast_possible_truncation)]
-fn timestamp_to_ms_of_day(epoch_ms: u64) -> i32 {
+pub(crate) fn timestamp_to_ms_of_day(epoch_ms: u64) -> i32 {
     let offset = eastern_offset_ms(epoch_ms);
     let local_ms = epoch_ms as i64 + offset;
     (local_ms.rem_euclid(86_400_000)) as i32
@@ -764,6 +764,15 @@ mod tests {
         }
     }
 
+    /// Build a DataValue containing a Timestamp.
+    fn dv_timestamp(epoch_ms: u64) -> proto::DataValue {
+        proto::DataValue {
+            data_type: Some(proto::data_value::DataType::Timestamp(
+                proto::ZonedDateTime { epoch_ms, zone: 0 },
+            )),
+        }
+    }
+
     /// Build a DataValue with no data_type set (missing).
     fn dv_missing() -> proto::DataValue {
         proto::DataValue { data_type: None }
@@ -1062,4 +1071,32 @@ mod tests {
         assert_eq!(super::parse_time_text("invalid"), 0);
         assert_eq!(super::parse_time_text(""), 0);
     }
+
+    #[test]
+    fn parse_eod_timestamp_aliases_decode_time_and_date_separately() {
+        // 2026-04-01 13:30:00 UTC = 2026-04-01 09:30:00 ET (EDT).
+        let epoch_ms: u64 = 1_775_050_200_000;
+        let table = proto::DataTable {
+            headers: vec![
+                "timestamp".into(),
+                "timestamp2".into(),
+                "open".into(),
+                "close".into(),
+            ],
+            data_table: vec![row_of(vec![
+                dv_timestamp(epoch_ms),
+                dv_timestamp(epoch_ms),
+                dv_number(15000),
+                dv_number(15100),
+            ])],
+        };
+
+        let ticks = parse_eod_ticks(&table);
+        assert_eq!(ticks.len(), 1);
+        assert_eq!(ticks[0].ms_of_day, 34_200_000);
+        assert_eq!(ticks[0].ms_of_day2, 34_200_000);
+        assert_eq!(ticks[0].date, 20260401);
+        assert!((ticks[0].open - 15000.0).abs() < 1e-10);
+        assert!((ticks[0].close - 15100.0).abs() < 1e-10);
+    }
 }

docs-site/docs/historical/option/history/eod.md

@@ -80,6 +80,8 @@ for (const auto& t : data) {
 
 ## Response
 
+> `strike_range` filters a wildcard bulk request. If you pin `strike` to one contract, the response stays single-strike. Use `strike="0"` in ThetaDataDx SDK/MCP or `strike=*` in the v3 REST API when you want multi-strike EOD output.
+
 <div class="param-list">
 <div class="param">
 <div class="param-header"><code>date</code><span class="param-type">string</span></div>
@@ -122,4 +124,3 @@ for (const auto& t : data) {
 ```
 
 > EOD data for SPY 2026-04-17 550 call. Days with no trades show `0.00` for OHLC but still have closing bid/ask.
-

docs-site/docs/historical/option/history/greeks-eod.md

@@ -94,10 +94,12 @@ for (const auto& t : data) {
 </div>
 <div class="param">
 <div class="param-header"><code>strike_range</code><span class="param-type">int</span><span class="param-badge optional">optional</span></div>
-<div class="param-desc">Strike range filter</div>
+<div class="param-desc">Strike range filter. This only narrows a wildcard bulk query; it does not expand a pinned strike into neighboring strikes.</div>
 </div>
 </div>
 
+> For multi-strike EOD Greeks requests, use a wildcard strike selection first (`strike="0"` in ThetaDataDx SDK/MCP, `strike=*` in the v3 REST API), then apply `strike_range`.
+
 ## Response
 
 <div class="param-list">

docs-site/docs/options.md

@@ -131,6 +131,13 @@ for row in chain[:5]:
 
 When you pass `"0"` for `expiration` or `strike`, the server returns data across all matching contracts. Each tick includes contract identification fields (`expiration`, `strike`, `right`) so you can distinguish which contract each tick belongs to.
 
+`strike_range` only narrows one of these wildcard bulk queries. It does not expand a pinned strike into neighboring strikes. In other words:
+
+- `strike="500"` + `strike_range=5` still targets the single 500 strike contract
+- `strike="0"` + `strike_range=5` returns a spot-relative range of strikes around ATM
+
+If you are comparing against the v3 REST API, the same wildcard behavior is expressed with `strike=*` / `expiration=*` instead of `"0"`.
+
 ::: warning
 The `right` parameter does **not** accept `"0"` as a wildcard. Use `"C"` (call), `"P"` (put), or `"both"` (calls and puts). Only `expiration` and `strike` accept `"0"` as a wildcard.
 :::

tools/mcp/README.md

@@ -132,6 +132,16 @@ The server speaks standard MCP over stdio:
 - `option_history_greeks_implied_volatility`, `option_history_trade_greeks_implied_volatility`
 - `option_at_time_trade`, `option_at_time_quote`
 
+### Wildcard Option Queries
+
+For option tools, MCP uses `"0"` as the wildcard value for `strike` and `expiration`.
+
+- Use a pinned strike like `"strike":"385"` when you want one contract.
+- Use `"strike":"0"` when you want a bulk chain-style response with contract identification fields on each row.
+- `strike_range` filters a wildcard bulk selection around spot / ATM. It does **not** fan out a pinned strike into neighboring strikes.
+
+This matches the current Java terminal behavior. The v3 REST surface uses `*` for the same wildcard concept; the MCP server uses `"0"` because it follows the underlying SDK contract.
+
 ### Index Data (9 tools)
 - `index_list_symbols`, `index_list_dates`
 - `index_snapshot_ohlc`, `index_snapshot_price`, `index_snapshot_market_value`
@@ -161,6 +171,14 @@ Response:
 {"jsonrpc":"2.0","id":2,"result":{"content":[{"type":"text","text":"{\"ticks\":[{\"date\":20240102,\"ms_of_day\":57600000,\"open\":187.15,\"high\":188.44,\"low\":183.89,\"close\":185.64,\"volume\":82488700,\"count\":1036575,\"bid\":185.63,\"ask\":185.65,\"bid_size\":1,\"ask_size\":3},...],\"count\":41}"}]}}
 ```
 
+### Fetch bulk option Greeks around ATM
+
+```json
+{"jsonrpc":"2.0","id":5,"method":"tools/call","params":{"name":"option_history_greeks_eod","arguments":{"symbol":"SPY","expiration":"20230120","strike":"0","right":"C","start_date":"20221219","end_date":"20221220","strike_range":5}}}
+```
+
+This returns a filtered bulk response across multiple strikes. If you change `strike` to `"385"`, the response is limited to that single contract.
+
 ### Compute Greeks offline
 
 ```json

tools/mcp/src/main.rs

@@ -445,14 +445,19 @@ fn serialize_eod_ticks(ticks: &[tdbe::types::tick::EodTick]) -> Value {
             let mut row = json!({
                 "date": t.date,
                 "ms_of_day": t.ms_of_day,
+                "ms_of_day2": t.ms_of_day2,
                 "open": t.open,
                 "high": t.high,
                 "low": t.low,
                 "close": t.close,
                 "volume": t.volume,
                 "count": t.count,
+                "bid_exchange": t.bid_exchange,
                 "bid": t.bid,
+                "bid_condition": t.bid_condition,
+                "ask_exchange": t.ask_exchange,
                 "ask": t.ask,
+                "ask_condition": t.ask_condition,
                 "bid_size": t.bid_size,
                 "ask_size": t.ask_size,
             });
@@ -1095,22 +1100,22 @@ mod tests {
 
     fn sample_eod_tick(expiration: i32, strike: f64, right: i32) -> EodTick {
         EodTick {
-            ms_of_day: 0,
-            ms_of_day2: 0,
+            ms_of_day: 34_200_000,
+            ms_of_day2: 57_600_000,
             open: 1.0,
             high: 1.0,
             low: 1.0,
             close: 1.0,
             volume: 10,
             count: 1,
             bid_size: 2,
-            bid_exchange: 0,
+            bid_exchange: 11,
             bid: 0.9,
-            bid_condition: 0,
+            bid_condition: 22,
             ask_size: 3,
-            ask_exchange: 0,
+            ask_exchange: 33,
             ask: 1.1,
-            ask_condition: 0,
+            ask_condition: 44,
             date: 20221219,
             expiration,
             strike,
@@ -1296,6 +1301,45 @@ mod tests {
         );
     }
 
+    #[test]
+    fn serialize_eod_ticks_preserves_full_eod_fields() {
+        let payload = serialize_eod_ticks(&[sample_eod_tick(0, 0.0, 0)]);
+        let tick = payload
+            .get("ticks")
+            .and_then(|value: &Value| value.as_array())
+            .and_then(|rows| rows.first())
+            .expect("serialized tick row should exist");
+
+        assert_eq!(
+            tick.get("ms_of_day").and_then(|value: &Value| value.as_i64()),
+            Some(34_200_000)
+        );
+        assert_eq!(
+            tick.get("ms_of_day2").and_then(|value: &Value| value.as_i64()),
+            Some(57_600_000)
+        );
+        assert_eq!(
+            tick.get("bid_exchange")
+                .and_then(|value: &Value| value.as_i64()),
+            Some(11)
+        );
+        assert_eq!(
+            tick.get("bid_condition")
+                .and_then(|value: &Value| value.as_i64()),
+            Some(22)
+        );
+        assert_eq!(
+            tick.get("ask_exchange")
+                .and_then(|value: &Value| value.as_i64()),
+            Some(33)
+        );
+        assert_eq!(
+            tick.get("ask_condition")
+                .and_then(|value: &Value| value.as_i64()),
+            Some(44)
+        );
+    }
+
     #[test]
     fn serialize_option_history_greeks_eod_omits_contract_identifiers_for_single_contract_rows() {
         let payload = serialize_greeks_ticks(&[sample_greeks_tick(0, 0.0, 0)]);