gloomberb 0.9.2 → 0.9.4

package/src/plugins/builtin/ticker-detail/data-panes/fundamental-graph/model.ts

@@ -71,9 +71,19 @@ export function buildFundamentalGraphRows(
   symbol = "",
   period: FundamentalPeriod = "annual",
 ): FundamentalGraphRow[] {
-  const sorted = [...statements]
+  const sortedStatements = [...statements]
     .filter((statement) => typeof statement[metric] === "number")
     .sort((left, right) => left.date.localeCompare(right.date));
+  const byCategory = new Map<string, FinancialStatement>();
+  for (const statement of sortedStatements) {
+    const category = periodCategory(statement.date, period);
+    const key = `${symbol}\u0000${category}`;
+    const previous = byCategory.get(key);
+    if (!previous || statement.date.localeCompare(previous.date) >= 0) {
+      byCategory.set(key, statement);
+    }
+  }
+  const sorted = [...byCategory.values()].sort((left, right) => left.date.localeCompare(right.date));
   const maxAbs = Math.max(1, ...sorted.map((statement) => Math.abs(statement[metric] as number)));
   return sorted.map((statement, index) => {
     const value = statement[metric] as number;
@@ -159,10 +169,23 @@ export function buildValuationGraphRows(
   });
 }
 
-function metricDefs(kind: GraphKind): ReadonlyArray<MetricDefinition> {
+export function metricDefs(kind: GraphKind): ReadonlyArray<MetricDefinition> {
   return kind === "valuation" ? VALUATION_METRICS : FUNDAMENTAL_METRICS;
 }
 
+export function allMetricDefs(): ReadonlyArray<{ kind: GraphKind; definition: MetricDefinition }> {
+  return [
+    ...FUNDAMENTAL_METRICS.map((definition) => ({ kind: "fundamental" as const, definition })),
+    ...VALUATION_METRICS.map((definition) => ({ kind: "valuation" as const, definition })),
+  ];
+}
+
+export function metricKind(metric: GraphMetricKey): GraphKind | null {
+  if (FUNDAMENTAL_METRICS.some((definition) => definition.key === metric)) return "fundamental";
+  if (VALUATION_METRICS.some((definition) => definition.key === metric)) return "valuation";
+  return null;
+}
+
 export function defaultMetric(kind: GraphKind): GraphMetricKey {
   return kind === "valuation" ? "priceSales" : "totalRevenue";
 }

package/src/plugins/builtin/ticker-detail/data-panes/fundamental-graph.tsx

@@ -1,5 +1,5 @@
 import { useMemo } from "react";
-import type { PaneProps, PaneTemplateDef } from "../../../../types/plugin";
+import type { PaneProps, PaneTemplateDef, TickerResearchTabProps } from "../../../../types/plugin";
 import { formatTickerListInput } from "../../../../tickers/list";
 import { usePaneInstance, usePaneTicker } from "../../../../state/app/context";
 import { usePluginPaneState } from "../../../runtime";
@@ -26,7 +26,7 @@ export function FundamentalGraphPane({ focused, width, height }: PaneProps) {
   const { symbol, exchange } = useBoundTicker();
   const symbols = useMemo(() => symbolsFromPaneSettings(pane?.settings, symbol), [pane?.settings, symbol]);
   const configuredKind = graphKindFromSettings(pane?.settings, "fundamental");
-  const [period, setPeriod] = usePluginPaneState<FundamentalPeriod>("period", "annual");
+  const [period, setPeriod] = usePluginPaneState<FundamentalPeriod>("period", "quarterly");
   const [chartKind, setChartKind] = usePluginPaneState<GraphKind>("chartKind", configuredKind);
   const [metric, setMetric] = usePluginPaneState<GraphMetricKey>("metric", defaultMetric(configuredKind));
   const resolvedMetric = isMetricForKind(chartKind, metric) ? metric : defaultMetric(chartKind);
@@ -54,9 +54,9 @@ export function FundamentalGraphPane({ focused, width, height }: PaneProps) {
   );
 }
 
-export function FundamentalGraphsResearchTab({ focused, width, height }: { focused: boolean; width: number; height: number }) {
+export function FundamentalGraphsResearchTab({ focused, width, height, onCapture }: TickerResearchTabProps) {
   const { symbol, financials } = usePaneTicker();
-  const [period, setPeriod] = usePluginPaneState<FundamentalPeriod>("detailPeriod", "annual");
+  const [period, setPeriod] = usePluginPaneState<FundamentalPeriod>("detailPeriod", "quarterly");
   const [chartKind, setChartKind] = usePluginPaneState<GraphKind>("detailChartKind", "fundamental");
   const [metric, setMetric] = usePluginPaneState<GraphMetricKey>("detailMetric", "totalRevenue");
   const resolvedMetric = isMetricForKind(chartKind, metric) ? metric : defaultMetric(chartKind);
@@ -79,6 +79,7 @@ export function FundamentalGraphsResearchTab({ focused, width, height }: { focus
       setMetric={setMetric}
       chartKind={chartKind}
       setChartKind={setChartKind}
+      onCapture={onCapture}
     />
   );
 }

package/src/plugins/builtin/ticker-detail/data-panes.test.ts

@@ -49,6 +49,22 @@ describe("ticker data panes", () => {
     ]);
   });
 
+  test("collapses duplicate quarterly statement dates into one displayed period", () => {
+    const rows = buildFundamentalGraphRows([
+      { date: "2025-03-29", eps: 0.44 },
+      { date: "2025-03-31", eps: 0.44 },
+      { date: "2025-06-28", eps: 0.54 },
+      { date: "2025-06-30", eps: 0.54 },
+      { date: "2025-09-27", eps: 0.75 },
+    ] satisfies FinancialStatement[], "eps", "AMD", "quarterly");
+
+    expect(rows.map((row) => [row.date, row.category, row.value])).toEqual([
+      ["2025-03-31", "2025 Q1", 0.44],
+      ["2025-06-30", "2025 Q2", 0.54],
+      ["2025-09-27", "2025 Q3", 0.75],
+    ]);
+  });
+
   test("builds valuation graph rows from available multiples", () => {
     const rows = buildValuationGraphRows({
       quote: { symbol: "AMD", price: 100, currency: "USD", change: 0, changePercent: 0, lastUpdated: 1, marketCap: 1_000 },

package/src/plugins/builtin/ticker-detail/index.test.tsx

@@ -305,6 +305,25 @@ async function clickFrameText(text: string) {
   await flushFrame();
 }
 
+async function emitKeypress(event: { name?: string; sequence?: string }) {
+  await act(async () => {
+    (testSetup!.renderer as any).keyInput.emit("keypress", {
+      ctrl: false,
+      meta: false,
+      option: false,
+      shift: false,
+      eventType: "press",
+      repeated: false,
+      preventDefault: () => {},
+      stopPropagation: () => {},
+      ...event,
+    });
+    await Promise.resolve();
+    await testSetup!.renderOnce();
+  });
+  await flushFrame();
+}
+
 function spanLineText(line: { spans: Array<{ text: string }> }): string {
   return line.spans.map((span) => span.text).join("");
 }
@@ -531,6 +550,130 @@ describe("TickerResearchPane", () => {
     expect(detailHarnessState?.paneState[TEST_PANE_ID]?.activeTabId).toBe("financials");
   });
 
+  test("shows metric tabs for fundamental graph charts and defaults them to quarterly data", async () => {
+    setSharedRegistryForTests(makeRegistry());
+    setOptionsProvider(createProvider(false));
+
+    testSetup = await testRender(
+      <DetailHarness
+        config={createDetailConfig("AAPL")}
+        ticker={makeTicker("AAPL")}
+        financials={makeFinancials({
+          annualStatements: [{ date: "2024-12-31", totalRevenue: 1_000 }],
+          quarterlyStatements: [
+            { date: "2025-03-31", totalRevenue: 200 },
+            { date: "2025-06-30", totalRevenue: 250 },
+          ],
+        })}
+        activeTabId="fundamental-graphs"
+        height={28}
+      />,
+      { width: 90, height: 28 },
+    );
+
+    await flushFrame();
+    const frame = testSetup.captureCharFrame();
+    expect(frame).toContain("Revenue");
+    expect(frame).toContain("Gross Profit");
+    expect(frame).not.toContain("Revenue (quarterly)");
+    expect(frame).not.toContain("[g]roup");
+    expect(frame).toContain("2025-03-31");
+    expect(frame).toContain("2025-06-30");
+    expect(frame.indexOf("2025-06-30")).toBeLessThan(frame.indexOf("2025-03-31"));
+  });
+
+  test("captures arrows for graph metric tabs between enter and escape", async () => {
+    setSharedRegistryForTests(makeRegistry());
+    setOptionsProvider(createProvider(false));
+
+    testSetup = await testRender(
+      <DetailHarness
+        config={createDetailConfig("AAPL")}
+        ticker={makeTicker("AAPL")}
+        financials={makeFinancials({
+          annualStatements: [{ date: "2024-12-31", totalRevenue: 1_000, grossProfit: 400 }],
+          quarterlyStatements: [
+            { date: "2025-03-31", totalRevenue: 200, grossProfit: 80 },
+            { date: "2025-06-30", totalRevenue: 250, grossProfit: 120 },
+          ],
+        })}
+        activeTabId="fundamental-graphs"
+        height={28}
+      />,
+      { width: 90, height: 28 },
+    );
+
+    await flushFrame();
+    expect(detailHarnessState?.paneState[TEST_PANE_ID]?.activeTabId).toBe("fundamental-graphs");
+
+    await act(async () => {
+      testSetup!.mockInput.pressEnter();
+      await testSetup!.renderOnce();
+    });
+    await flushFrame();
+
+    await act(async () => {
+      testSetup!.mockInput.pressArrow("right");
+      await testSetup!.renderOnce();
+    });
+    await flushFrame();
+
+    expect(detailHarnessState?.paneState[TEST_PANE_ID]?.pluginState?.["ticker-detail"]?.detailMetric).toBe("grossProfit");
+    expect(detailHarnessState?.paneState[TEST_PANE_ID]?.activeTabId).toBe("fundamental-graphs");
+
+    await emitKeypress({ name: "escape", sequence: "\u001b" });
+    expect(detailHarnessState?.inputCaptured).toBe(false);
+
+    await act(async () => {
+      testSetup!.mockInput.pressArrow("right");
+      await testSetup!.renderOnce();
+    });
+    await flushFrame();
+
+    await settleTickerTabCommit();
+    expect(detailHarnessState?.paneState[TEST_PANE_ID]?.activeTabId).toBe("chart");
+  });
+
+  test("clicking graph content focuses metric tabs for arrow navigation", async () => {
+    setSharedRegistryForTests(makeRegistry());
+    setOptionsProvider(createProvider(false));
+
+    testSetup = await testRender(
+      <DetailHarness
+        config={createDetailConfig("AAPL")}
+        ticker={makeTicker("AAPL")}
+        financials={makeFinancials({
+          annualStatements: [{ date: "2024-12-31", totalRevenue: 1_000, grossProfit: 400 }],
+          quarterlyStatements: [
+            { date: "2025-03-31", totalRevenue: 200, grossProfit: 80 },
+            { date: "2025-06-30", totalRevenue: 250, grossProfit: 120 },
+          ],
+        })}
+        activeTabId="fundamental-graphs"
+        height={28}
+      />,
+      { width: 90, height: 28 },
+    );
+
+    await flushFrame();
+
+    await act(async () => {
+      await testSetup!.mockMouse.click(24, 6);
+      await testSetup!.renderOnce();
+    });
+    await flushFrame();
+    expect(detailHarnessState?.inputCaptured).toBe(true);
+
+    await act(async () => {
+      testSetup!.mockInput.pressArrow("right");
+      await testSetup!.renderOnce();
+    });
+    await flushFrame();
+
+    expect(detailHarnessState?.paneState[TEST_PANE_ID]?.pluginState?.["ticker-detail"]?.detailMetric).toBe("grossProfit");
+    expect(detailHarnessState?.paneState[TEST_PANE_ID]?.activeTabId).toBe("fundamental-graphs");
+  });
+
   test("shows Trade when an IBKR gateway profile exists", async () => {
     setSharedRegistryForTests(makeRegistry());
     setOptionsProvider(createProvider(false));

package/src/plugins/catalog-ui.ts

@@ -12,6 +12,7 @@ import { layoutManagerPlugin } from "./builtin/layout-manager";
 import { predictionMarketsPlugin } from "./prediction-markets";
 import { analyticsPlugin } from "./builtin/analytics";
 import { alertsPlugin } from "./builtin/alerts";
+import { kellySizerPlugin } from "./builtin/kelly-sizer";
 import {
   brokerPlugin,
   macroPlugin,
@@ -36,6 +37,7 @@ export const uiBuiltinPlugins: GloomPlugin[] = [
   marketOverviewPlugin,
   macroPlugin,
   analyticsPlugin,
+  kellySizerPlugin,
   alertsPlugin,
 ];
 

package/src/plugins/ibkr/broker-adapter.ts

@@ -40,6 +40,25 @@ export const ibkrBroker: BrokerAdapter = {
     return importFlexPositions(normalized.flex);
   },
 
+  async importPortfolioSnapshot(instance) {
+    const normalized = normalizeIbkrConfig(instance.config);
+    if (normalized.connectionMode === "gateway") {
+      const service = ibkrGatewayManager.getService(instance.id);
+      await refreshGatewayData(instance);
+      const [accounts, positions] = await Promise.all([
+        service.getAccounts(normalized.gateway),
+        service.getPositions(normalized.gateway),
+      ]);
+      return { accounts, positions };
+    }
+
+    const xml = await loadFlexStatement(normalized.flex);
+    return {
+      accounts: parseFlexAccounts(xml),
+      positions: parseFlexPositions(xml),
+    };
+  },
+
   async connect(instance) {
     const normalized = normalizeIbkrConfig(instance.config);
     if (normalized.connectionMode !== "gateway") return;

package/src/plugins/ibkr/config.test.ts

@@ -1,5 +1,10 @@
 import { describe, expect, test } from "bun:test";
-import { buildIbkrConfigFromValues, normalizeIbkrConfig } from "./config";
+import {
+  buildIbkrConfigFromValues,
+  IBKR_STATEMENT_URL,
+  LEGACY_IBKR_STATEMENT_URL,
+  normalizeIbkrConfig,
+} from "./config";
 
 describe("ibkr config helpers", () => {
   test("builds nested manual gateway config from flat wizard values", () => {
@@ -45,6 +50,30 @@ describe("ibkr config helpers", () => {
     expect(config.gatewaySetupMode).toBe("auto");
     expect(config.flex.token).toBe("abc");
     expect(config.flex.queryId).toBe("123");
-    expect(config.flex.endpoint).toContain("FlexStatementService.SendRequest");
+    expect(config.flex.endpoint).toBe(IBKR_STATEMENT_URL);
+  });
+
+  test("migrates the legacy default Flex endpoint to the current IBKR endpoint", () => {
+    const config = normalizeIbkrConfig({
+      flex: {
+        token: "abc",
+        queryId: "123",
+        endpoint: LEGACY_IBKR_STATEMENT_URL,
+      },
+    });
+
+    expect(config.flex.endpoint).toBe(IBKR_STATEMENT_URL);
+  });
+
+  test("preserves custom non-default Flex endpoints", () => {
+    const config = normalizeIbkrConfig({
+      flex: {
+        token: "abc",
+        queryId: "123",
+        endpoint: "https://example.com/custom/SendRequest",
+      },
+    });
+
+    expect(config.flex.endpoint).toBe("https://example.com/custom/SendRequest");
   });
 });

package/src/plugins/ibkr/config.ts

@@ -1,7 +1,8 @@
 import type { BrokerConfigField } from "../../types/broker";
 import type { IbkrGatewayConfig, ResolvedIbkrGatewayConnection } from "./gateway/service";
 
-export const IBKR_STATEMENT_URL = "https://gdcdyn.interactivebrokers.com/Universal/servlet/FlexStatementService.SendRequest";
+export const LEGACY_IBKR_STATEMENT_URL = "https://gdcdyn.interactivebrokers.com/Universal/servlet/FlexStatementService.SendRequest";
+export const IBKR_STATEMENT_URL = "https://ndcdyn.interactivebrokers.com/AccountManagement/FlexWebService/SendRequest";
 
 type IbkrConnectionMode = "flex" | "gateway";
 type IbkrGatewaySetupMode = "auto" | "manual";
@@ -119,6 +120,12 @@ function coerceString(value: unknown, fallback = ""): string {
   return typeof value === "string" ? value : fallback;
 }
 
+function normalizeFlexEndpoint(value: unknown): string {
+  const endpoint = coerceString(value, DEFAULT_FLEX_CONFIG.endpoint).trim();
+  if (!endpoint || endpoint === LEGACY_IBKR_STATEMENT_URL) return IBKR_STATEMENT_URL;
+  return endpoint;
+}
+
 function getMode(value: unknown): IbkrConnectionMode {
   return value === "gateway" ? "gateway" : "flex";
 }
@@ -166,7 +173,7 @@ export function normalizeIbkrConfig(raw?: Record<string, unknown>): IbkrConfig {
     flex: {
       token: coerceString(nestedFlex.token ?? input.token),
       queryId: coerceString(nestedFlex.queryId ?? input.queryId),
-      endpoint: coerceString(nestedFlex.endpoint ?? input.endpoint, DEFAULT_FLEX_CONFIG.endpoint),
+      endpoint: normalizeFlexEndpoint(nestedFlex.endpoint ?? input.endpoint),
     },
     gateway: {
       host,

package/src/plugins/ibkr/flex/index.test.ts

@@ -59,6 +59,10 @@ describe("parseFlexAccounts", () => {
               <FxPosition accountId="DU12345" assetCategory="CASH" functionalCurrency="USD" fxCurrency="USD" quantity="-303029.144938754" value="-303029.144938754" />
               <FxPosition accountId="DU12345" assetCategory="CASH" functionalCurrency="USD" fxCurrency="EUR" quantity="-351957.025" value="-405102.535775" />
             </FxPositions>
+            <OpenPositions>
+              <OpenPosition accountId="DU12345" symbol="AAPL" assetCategory="STK" position="100" currency="USD" positionValue="100000" fxRateToBase="1" />
+              <OpenPosition accountId="DU12345" symbol="ASML" assetCategory="STK" position="10" currency="EUR" positionValue="50000" fxRateToBase="1.2" />
+            </OpenPositions>
           </FlexStatement>
         </FlexStatements>
       </FlexQueryResponse>
@@ -71,7 +75,9 @@ describe("parseFlexAccounts", () => {
       name: "Main",
       currency: "USD",
       source: "flex",
+      asOfDate: "2026-03-27",
       netLiquidation: 764713.626876249,
+      grossPositionValue: 160000,
       totalCashValue: -1050953.720462251,
       settledCash: -917604.448220862,
       cashBalances: [
@@ -110,7 +116,9 @@ describe("parseFlexAccounts", () => {
         currency: "USD",
         source: "flex",
         updatedAt: new Date(2026, 2, 27).getTime(),
+        asOfDate: "2026-03-27",
         netLiquidation: 12345.67,
+        grossPositionValue: undefined,
         totalCashValue: undefined,
         settledCash: undefined,
         cashBalances: undefined,
@@ -190,9 +198,9 @@ describe("parseFlexPortfolioPerformance", () => {
 
 describe("requestFlexStatement", () => {
   test("uses the configured HTTP transport for statement requests", async () => {
-    const requests: string[] = [];
-    setHttpFetchTransport(async (url) => {
-      requests.push(url);
+    const requests: Array<{ url: string; init: RequestInit | undefined }> = [];
+    setHttpFetchTransport(async (url, init) => {
+      requests.push({ url, init });
       return new Response(
         "<FlexStatementResponse><ReferenceCode>987654</ReferenceCode></FlexStatementResponse>",
         { status: 200 },
@@ -202,16 +210,17 @@ describe("requestFlexStatement", () => {
     await expect(requestFlexStatement({
       token: "secret-flex-token",
       queryId: "12345",
-      endpoint: "https://gdcdyn.interactivebrokers.com/Universal/servlet/FlexStatementService.SendRequest",
+      endpoint: "https://ndcdyn.interactivebrokers.com/AccountManagement/FlexWebService/SendRequest",
     })).resolves.toBe("987654");
 
     expect(requests).toHaveLength(1);
-    expect(requests[0]).toContain("q=12345");
+    expect(requests[0]?.url).toContain("q=12345");
+    expect((requests[0]?.init?.headers as Record<string, string> | undefined)?.["User-Agent"]).toBeTruthy();
   });
 
   test("adds request context to vague IBKR Flex errors without exposing the token", async () => {
     globalThis.fetch = (async () => new Response(
-      "<FlexStatementResponse><ErrorMessage>Load failed</ErrorMessage></FlexStatementResponse>",
+      "<FlexStatementResponse><ErrorCode>1001</ErrorCode><ErrorMessage>Load failed</ErrorMessage></FlexStatementResponse>",
       { status: 200 },
     )) as unknown as typeof fetch;
 
@@ -220,14 +229,14 @@ describe("requestFlexStatement", () => {
       await requestFlexStatement({
         token: "secret-flex-token",
         queryId: "12345",
-        endpoint: "https://gdcdyn.interactivebrokers.com/Universal/servlet/FlexStatementService.SendRequest",
+        endpoint: "https://ndcdyn.interactivebrokers.com/AccountManagement/FlexWebService/SendRequest",
       });
     } catch (error) {
       message = error instanceof Error ? error.message : String(error);
     }
 
-    expect(message).toContain("IBKR Flex request failed while requesting the statement: Load failed.");
-    expect(message).toContain("Endpoint FlexStatementService.SendRequest");
+    expect(message).toContain("IBKR Flex request failed while requesting the statement: IBKR error 1001: Load failed.");
+    expect(message).toContain("Endpoint SendRequest");
     expect(message).toContain("query ID 12345");
     expect(message).toContain("token configured");
     expect(message).toContain("Flex Web Service is enabled");

package/src/plugins/ibkr/flex/index.ts

@@ -63,6 +63,34 @@ function parseFlexDate(raw: string | undefined): string | null {
   return new Date(parsed).toISOString().slice(0, 10);
 }
 
+function parseFlexGrossPositionValue(
+  body: string,
+  statementAccountId: string,
+  baseCurrency: string | undefined,
+): number | undefined {
+  let total = 0;
+  let hasValue = false;
+
+  for (const entry of body.matchAll(/<OpenPosition\b([^>]*)\/?>/g)) {
+    const attributes = parseAttributes(entry[1] ?? "");
+    const accountId = attributes.accountId || statementAccountId;
+    if (!accountId || (statementAccountId && accountId !== statementAccountId)) continue;
+
+    const marketValue = parseNumber(attributes.positionValue);
+    if (marketValue == null) continue;
+
+    const positionCurrency = attributes.currency || baseCurrency;
+    const fxRateToBase = parseNumber(attributes.fxRateToBase)
+      ?? (baseCurrency && positionCurrency === baseCurrency ? 1 : undefined);
+    if (fxRateToBase == null) continue;
+
+    total += Math.abs(marketValue * fxRateToBase);
+    hasValue = true;
+  }
+
+  return hasValue ? total : undefined;
+}
+
 function buildContractRef(attributes: Record<string, string>, symbol: string, assetCategory: string): BrokerContractRef | undefined {
   const conIdRaw = attributes.conid || attributes.conId;
   const strikeRaw = attributes.strike;
@@ -211,7 +239,9 @@ export function parseFlexAccounts(xml: string): BrokerAccount[] {
       currency: accountCurrency,
       source: "flex",
       updatedAt: parseFlexTimestamp(statementAttrs.whenGenerated, statementAttrs.toDate || statementAttrs.fromDate),
+      asOfDate: parseFlexDate(statementAttrs.toDate || statementAttrs.fromDate) ?? undefined,
       netLiquidation: parseNumber(changeInNavAttrs?.endingValue),
+      grossPositionValue: parseFlexGrossPositionValue(body, accountId, accountCurrency),
       totalCashValue: parseNumber(baseCashAttrs?.endingCash),
       settledCash: parseNumber(baseCashAttrs?.endingSettledCash),
       cashBalances: cashBalances.length > 0 ? cashBalances : undefined,

package/src/plugins/ibkr/flex/statement-client.ts

@@ -2,7 +2,8 @@ import { httpFetch } from "../../../utils/http-transport";
 import type { FlexQueryConfig } from "../config";
 import { IBKR_STATEMENT_URL } from "../config";
 
-const IBKR_STATEMENT_GET_URL = "https://gdcdyn.interactivebrokers.com/Universal/servlet/FlexStatementService.GetStatement";
+const IBKR_STATEMENT_GET_URL = "https://ndcdyn.interactivebrokers.com/AccountManagement/FlexWebService/GetStatement";
+const FLEX_USER_AGENT = "Gloomberb/1.0 Flex";
 const FLEX_STATEMENT_CACHE_MS = 15 * 60_000;
 const FLEX_STATEMENT_INITIAL_WAIT_MS = 3_000;
 const FLEX_STATEMENT_POLL_DELAY_MS = 5_000;
@@ -29,10 +30,54 @@ function decodeXmlText(value: string): string {
     .replace(/'/g, "'");
 }
 
+function extractXmlTag(text: string, tagName: string): string | null {
+  const match = text.match(new RegExp(`<${tagName}>\\s*([^<]*?)\\s*<\\/${tagName}>`, "i"));
+  return match?.[1] ? decodeXmlText(match[1].trim()) : null;
+}
+
 function extractFlexErrorMessage(text: string): string | null {
-  const errorMatch = text.match(/<ErrorMessage>([^<]+)<\/ErrorMessage>/);
-  if (errorMatch?.[1]) return decodeXmlText(errorMatch[1].trim());
-  return null;
+  const message = extractXmlTag(text, "ErrorMessage");
+  const code = extractXmlTag(text, "ErrorCode");
+  if (message && code) return `IBKR error ${code}: ${message}`;
+  return message;
+}
+
+function buildFlexUrl(endpoint: string, params: Record<string, string>): string {
+  const url = new URL(endpoint);
+  for (const [key, value] of Object.entries(params)) {
+    url.searchParams.set(key, value);
+  }
+  return url.toString();
+}
+
+function resolveFlexGetEndpoint(sendEndpoint: string | undefined): string {
+  if (!sendEndpoint || sendEndpoint === IBKR_STATEMENT_URL) return IBKR_STATEMENT_GET_URL;
+
+  try {
+    const url = new URL(sendEndpoint);
+    url.search = "";
+    if (url.pathname.endsWith("/SendRequest")) {
+      url.pathname = url.pathname.replace(/\/SendRequest$/, "/GetStatement");
+      return url.toString();
+    }
+    if (url.pathname.endsWith("FlexStatementService.SendRequest")) {
+      url.pathname = url.pathname.replace(/FlexStatementService\.SendRequest$/, "FlexStatementService.GetStatement");
+      return url.toString();
+    }
+  } catch {
+    return IBKR_STATEMENT_GET_URL;
+  }
+
+  return IBKR_STATEMENT_GET_URL;
+}
+
+function flexRequestInit(): RequestInit {
+  return {
+    headers: {
+      "User-Agent": FLEX_USER_AGENT,
+    },
+    signal: AbortSignal.timeout(30_000),
+  };
 }
 
 function endpointName(endpoint: string | undefined): string {
@@ -69,11 +114,15 @@ function flexError(providerMessage: string, context: FlexErrorContext): Error {
 
 export async function requestFlexStatement(config: FlexQueryConfig): Promise<string> {
   const endpoint = config.endpoint || IBKR_STATEMENT_URL;
-  const url = `${endpoint}?t=${config.token}&q=${config.queryId}&v=3`;
+  const url = buildFlexUrl(endpoint, {
+    t: config.token,
+    q: config.queryId,
+    v: "3",
+  });
   let resp: Response;
   let text: string;
   try {
-    resp = await httpFetch(url, { signal: AbortSignal.timeout(30_000) });
+    resp = await httpFetch(url, flexRequestInit());
     text = await resp.text();
   } catch (error) {
     throw flexError(error instanceof Error ? error.message : "Network request failed", {
@@ -84,8 +133,8 @@ export async function requestFlexStatement(config: FlexQueryConfig): Promise<str
     });
   }
 
-  const codeMatch = text.match(/<ReferenceCode>(\d+)<\/ReferenceCode>/);
-  if (!codeMatch) {
+  const referenceCode = extractXmlTag(text, "ReferenceCode");
+  if (!referenceCode) {
     throw flexError(extractFlexErrorMessage(text) || "No reference code returned", {
       phase: "request",
       endpoint,
@@ -95,7 +144,7 @@ export async function requestFlexStatement(config: FlexQueryConfig): Promise<str
     });
   }
 
-  return codeMatch[1]!;
+  return referenceCode;
 }
 
 async function getFlexStatement(
@@ -105,17 +154,22 @@ async function getFlexStatement(
 ): Promise<string> {
   await new Promise((resolve) => setTimeout(resolve, FLEX_STATEMENT_INITIAL_WAIT_MS));
 
-  const url = `${IBKR_STATEMENT_GET_URL}?t=${token}&q=${referenceCode}&v=3`;
+  const endpoint = resolveFlexGetEndpoint(context.endpoint);
+  const url = buildFlexUrl(endpoint, {
+    t: token,
+    q: referenceCode,
+    v: "3",
+  });
   for (let attempt = 0; attempt < FLEX_STATEMENT_MAX_DOWNLOAD_ATTEMPTS; attempt += 1) {
     let resp: Response;
     let text: string;
     try {
-      resp = await httpFetch(url, { signal: AbortSignal.timeout(30_000) });
+      resp = await httpFetch(url, flexRequestInit());
       text = await resp.text();
     } catch (error) {
       throw flexError(error instanceof Error ? error.message : "Network request failed", {
         phase: "download",
-        endpoint: context.endpoint,
+        endpoint,
         queryId: context.queryId,
         token,
         referenceCode,
@@ -135,7 +189,7 @@ async function getFlexStatement(
     if (providerMessage) {
       throw flexError(providerMessage, {
         phase: "download",
-        endpoint: context.endpoint,
+        endpoint,
         queryId: context.queryId,
         token,
         referenceCode,
@@ -146,7 +200,7 @@ async function getFlexStatement(
 
   throw flexError("statement generation timed out", {
     phase: "download",
-    endpoint: context.endpoint,
+    endpoint,
     queryId: context.queryId,
     token,
     referenceCode,

package/src/plugins/ibkr/gateway/account-loaders.ts

@@ -96,7 +96,7 @@ export async function loadIbkrAccounts({
     const result = await firstValueFrom(
       api.getAccountSummary(
         "All",
-        "NetLiquidation,TotalCashValue,SettledCash,AvailableFunds,BuyingPower,ExcessLiquidity,InitMarginReq,MaintMarginReq,$LEDGER:ALL",
+        "NetLiquidation,GrossPositionValue,TotalCashValue,SettledCash,AvailableFunds,BuyingPower,ExcessLiquidity,InitMarginReq,MaintMarginReq,$LEDGER:ALL",
       )
         .pipe(take(1), timeout(10_000)),
     );