@startsimpli/api 0.5.16 → 0.5.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@startsimpli/api",
-  "version": "0.5.16",
+  "version": "0.5.18",
   "description": "Type-safe Django REST API client for StartSimpli apps",
   "main": "./src/index.ts",
   "types": "./src/index.ts",

package/src/constants/endpoints.ts

@@ -78,6 +78,13 @@ export const ENDPOINTS = {
   EARNINGS_CALENDAR: 'api/v1/markets/calendar',
   TRADING_SNAPSHOTS: 'api/v1/markets/trading/snapshots',
 
+  // Options (TENTATIVE — schemas to be confirmed by claude-mac via agent_bridge req 42c763b2)
+  OPTIONS_CHAIN: 'api/v1/markets/options/chain',
+  OPTIONS_IV: 'api/v1/markets/options/iv',
+  OPTIONS_SKEW: 'api/v1/markets/options/skew',
+  OPTIONS_GREEKS: 'api/v1/markets/options/greeks',
+  VIX_TERM: 'api/v1/markets/vix_term',
+
   // Sources ops
   SOURCES_HEALTH: 'api/v1/sources/ops/health',
 } as const;

package/src/index.ts

@@ -224,10 +224,22 @@ export type {
   EarningsCalendarResponse,
   PairConsensus,
   CommitteeVotes,
+  PairMember,
   PairSnapshot,
   AlpacaPosition,
   AlpacaSnapshot,
   TradingSnapshot,
   TradingSnapshotsResponse,
   TradingSnapshotsParams,
+  OptionSide,
+  OptionContract,
+  OptionsChainParams,
+  OptionsChainResponse,
+  OptionsIvPoint,
+  OptionsIvResponse,
+  OptionsSkewPoint,
+  OptionsSkewResponse,
+  OptionsGreeks,
+  VixTermPoint,
+  VixTermResponse,
 } from './lib/markets-api';

package/src/lib/markets-api.ts

@@ -188,30 +188,142 @@ export interface EarningsCalendarResponse {
 export type PairConsensus = 'BULL' | 'BEAR' | 'FLAT';
 
 export interface CommitteeVotes {
-  bull: number;
-  bear: number;
-  flat: number;
+  BULL: number;
+  BEAR: number;
+  FLAT: number;
+}
+
+export interface PairMember {
+  modelName: string;
+  features: string[];
+  thresholds: [number, number];
+  scoreToday: number;
+  signalToday: number;
+  endValueFull?: number | null;
 }
 
 export interface PairSnapshot {
-  topScore?: number | null;
-  consensus?: PairConsensus | null;
-  committeeVotes?: CommitteeVotes | null;
-  topConfig?: string | null;
-  thresholds?: { long?: number | null; short?: number | null } | null;
+  consensus: PairConsensus;
+  topScore: number;
+  topSignal: number;
+  targetSymbol: string;
+  committeeN: number;
+  committeeVotes: CommitteeVotes;
+  committeeMeanScore: number;
+  topConfigName: string;
+  members: PairMember[];
   [key: string]: unknown;
 }
 
+export type OptionSide = 'call' | 'put';
+
 export interface AlpacaPosition {
   symbol: string;
   qty: number;
-  side?: 'long' | 'short';
-  marketValue?: number | null;
-  avgEntryPrice?: number | null;
-  unrealizedPl?: number | null;
+  marketValue: number;
+  costBasis: number;
+  unrealizedPl: number;
+  // Optional options-position fields (populated server-side when symbol is OCC-format)
+  underlying?: string | null;
+  optionSide?: OptionSide | null;
+  strike?: number | null;
+  expiry?: string | null;
+  contracts?: number | null;
+  delta?: number | null;
+  gamma?: number | null;
+  theta?: number | null;
+  vega?: number | null;
+  iv?: number | null;
   [key: string]: unknown;
 }
 
+// ===== Options + VIX =====================================================
+// Schemas are TENTATIVE pending claude-mac confirmation (agent_bridge req
+// 42c763b2). All numeric fields run through coerce helpers since Django
+// serializes Decimals as strings.
+
+export interface OptionContract {
+  strike: number;
+  side: OptionSide;
+  bid: number | null;
+  ask: number | null;
+  last: number | null;
+  iv: number | null;
+  delta: number | null;
+  gamma: number | null;
+  theta: number | null;
+  vega: number | null;
+  oi: number;
+  volume: number;
+}
+
+export interface OptionsChainResponse {
+  symbol: string;
+  expiry: string;
+  spot: number;
+  contracts: OptionContract[];
+  expiries?: string[];
+  computedAt?: string | null;
+}
+
+export interface OptionsChainParams {
+  symbol: string;
+  expiry?: string;
+}
+
+export interface OptionsIvPoint {
+  date: string;
+  iv30: number;
+  iv60: number | null;
+  iv90: number | null;
+  iv30Rank: number | null;
+  iv30Percentile: number | null;
+}
+
+export interface OptionsIvResponse {
+  symbol: string;
+  count: number;
+  results: OptionsIvPoint[];
+}
+
+export interface OptionsSkewPoint {
+  strike: number;
+  iv: number;
+  side: OptionSide;
+}
+
+export interface OptionsSkewResponse {
+  symbol: string;
+  expiry: string;
+  spot: number;
+  results: OptionsSkewPoint[];
+}
+
+export interface OptionsGreeks {
+  symbol: string;
+  expiry: string;
+  strike: number;
+  side: OptionSide;
+  delta: number;
+  gamma: number;
+  theta: number;
+  vega: number;
+  iv: number;
+  computedAt: string | null;
+}
+
+export interface VixTermPoint {
+  symbol: 'VIX' | 'VIX3M' | 'VIX6M' | 'VIX1Y' | string;
+  value: number;
+  percentile252d: number | null;
+  dailyDelta: number | null;
+}
+
+export interface VixTermResponse {
+  generatedAt: string;
+  points: VixTermPoint[];
+}
+
 export interface AlpacaSnapshot {
   equity: number;
   cash: number;
@@ -270,6 +382,85 @@ export interface MarketsHealth {
   sourceInstances: SourceInstanceHealth[];
 }
 
+// Django serializes Decimal/numeric fields as strings (e.g. "219.440002").
+// Coerce known numeric fields to numbers so consumers can call .toFixed safely.
+const n = (v: unknown): number => typeof v === 'number' ? v : Number(v);
+const maybeN = (v: unknown): number | null => v == null ? null : n(v);
+
+function coerceBar(b: PriceBar): PriceBar {
+  return { ...b, open: n(b.open), high: n(b.high), low: n(b.low), close: n(b.close), volume: maybeN(b.volume) };
+}
+
+function coerceReturns(r: ReturnsAnalytics): ReturnsAnalytics {
+  return { ...r, startPrice: n(r.startPrice), endPrice: n(r.endPrice), simpleReturn: n(r.simpleReturn), logReturn: n(r.logReturn) };
+}
+
+function coercePairSpread(p: PairSpreadPoint): PairSpreadPoint {
+  return { ...p, longClose: n(p.longClose), shortClose: n(p.shortClose), spread: n(p.spread), logSpread: n(p.logSpread) };
+}
+
+function coerceBreadth(b: SectorBreadthPoint): SectorBreadthPoint {
+  return { ...b, nUp: n(b.nUp), nTotal: n(b.nTotal), pctUp: n(b.pctUp), meanReturn: n(b.meanReturn), returnDispersion: n(b.returnDispersion) };
+}
+
+function coercePosition(p: AlpacaPosition): AlpacaPosition {
+  return {
+    ...p,
+    qty: n(p.qty),
+    marketValue: n(p.marketValue),
+    costBasis: n(p.costBasis),
+    unrealizedPl: n(p.unrealizedPl),
+    strike: maybeN(p.strike),
+    contracts: maybeN(p.contracts),
+    delta: maybeN(p.delta),
+    gamma: maybeN(p.gamma),
+    theta: maybeN(p.theta),
+    vega: maybeN(p.vega),
+    iv: maybeN(p.iv),
+  };
+}
+
+function coerceContract(c: OptionContract): OptionContract {
+  return {
+    ...c,
+    strike: n(c.strike),
+    bid: maybeN(c.bid),
+    ask: maybeN(c.ask),
+    last: maybeN(c.last),
+    iv: maybeN(c.iv),
+    delta: maybeN(c.delta),
+    gamma: maybeN(c.gamma),
+    theta: maybeN(c.theta),
+    vega: maybeN(c.vega),
+    oi: n(c.oi),
+    volume: n(c.volume),
+  };
+}
+
+function coerceIvPoint(p: OptionsIvPoint): OptionsIvPoint {
+  return {
+    ...p,
+    iv30: n(p.iv30),
+    iv60: maybeN(p.iv60),
+    iv90: maybeN(p.iv90),
+    iv30Rank: maybeN(p.iv30Rank),
+    iv30Percentile: maybeN(p.iv30Percentile),
+  };
+}
+
+function coerceSkewPoint(p: OptionsSkewPoint): OptionsSkewPoint {
+  return { ...p, strike: n(p.strike), iv: n(p.iv) };
+}
+
+function coerceVixPoint(p: VixTermPoint): VixTermPoint {
+  return {
+    ...p,
+    value: n(p.value),
+    percentile252d: maybeN(p.percentile252d),
+    dailyDelta: maybeN(p.dailyDelta),
+  };
+}
+
 export class MarketsApi {
   constructor(private client: ApiClient) {}
 
@@ -284,22 +475,31 @@ export class MarketsApi {
   }
 
   async getBars(symbol: string, params?: BarsParams): Promise<PriceBar[] | PaginatedResponse<PriceBar>> {
-    return this.client.fetch.get<PriceBar[] | PaginatedResponse<PriceBar>>(
+    const res = await this.client.fetch.get<PriceBar[] | PaginatedResponse<PriceBar>>(
       ENDPOINTS.INSTRUMENT_BARS(symbol),
       { params: params as Record<string, unknown> | undefined },
     );
+    if (Array.isArray(res)) return res.map(coerceBar);
+    return { ...res, results: res.results.map(coerceBar) };
   }
 
   async getLatestBar(symbol: string, interval: BarInterval = '1d'): Promise<PriceBar> {
-    return this.client.fetch.get<PriceBar>(ENDPOINTS.INSTRUMENT_LATEST(symbol), {
+    const b = await this.client.fetch.get<PriceBar>(ENDPOINTS.INSTRUMENT_LATEST(symbol), {
       params: { interval },
     });
+    return coerceBar(b);
   }
 
   async getAnalytics(symbol: string, params: AnalyticsParams): Promise<AnalyticsResponse> {
-    return this.client.fetch.get<AnalyticsResponse>(ENDPOINTS.INSTRUMENT_ANALYTICS(symbol), {
+    const res = await this.client.fetch.get<AnalyticsResponse>(ENDPOINTS.INSTRUMENT_ANALYTICS(symbol), {
       params: params as unknown as Record<string, unknown>,
     });
+    if (params.metric === 'returns') return coerceReturns(res as ReturnsAnalytics);
+    if (params.metric === 'pair_spread' && Array.isArray(res)) return (res as PairSpreadPoint[]).map(coercePairSpread);
+    if (params.metric === 'volatility' && Array.isArray(res)) {
+      return (res as VolatilityPoint[]).map((v) => ({ ...v, volatility: n(v.volatility) }));
+    }
+    return res;
   }
 
   async getNews(symbol: string, params?: NewsParams): Promise<InstrumentNewsResponse> {
@@ -313,9 +513,10 @@ export class MarketsApi {
   }
 
   async getSectorBreadth(params: SectorBreadthParams): Promise<SectorBreadthResponse> {
-    return this.client.fetch.get<SectorBreadthResponse>(ENDPOINTS.SECTOR_BREADTH, {
+    const res = await this.client.fetch.get<SectorBreadthResponse>(ENDPOINTS.SECTOR_BREADTH, {
       params: params as unknown as Record<string, unknown>,
     });
+    return { ...res, results: res.results.map(coerceBreadth) };
   }
 
   async getEarningsCalendar(params: EarningsCalendarParams): Promise<EarningsCalendarResponse> {
@@ -325,9 +526,69 @@ export class MarketsApi {
     });
   }
 
+  // ===== Options + VIX (tentative — see agent_bridge req 42c763b2) =======
+
+  async getOptionsChain(params: OptionsChainParams): Promise<OptionsChainResponse> {
+    const res = await this.client.fetch.get<OptionsChainResponse>(ENDPOINTS.OPTIONS_CHAIN, {
+      params: params as unknown as Record<string, unknown>,
+    });
+    return {
+      ...res,
+      spot: n(res.spot),
+      contracts: (res.contracts ?? []).map(coerceContract),
+    };
+  }
+
+  async getOptionsIv(symbol: string): Promise<OptionsIvResponse> {
+    const res = await this.client.fetch.get<OptionsIvResponse>(ENDPOINTS.OPTIONS_IV, {
+      params: { symbol },
+    });
+    return { ...res, results: (res.results ?? []).map(coerceIvPoint) };
+  }
+
+  async getOptionsSkew(symbol: string, expiry: string): Promise<OptionsSkewResponse> {
+    const res = await this.client.fetch.get<OptionsSkewResponse>(ENDPOINTS.OPTIONS_SKEW, {
+      params: { symbol, expiry },
+    });
+    return { ...res, spot: n(res.spot), results: (res.results ?? []).map(coerceSkewPoint) };
+  }
+
+  async getOptionsGreeks(symbol: string, expiry: string, strike: number, side: OptionSide): Promise<OptionsGreeks> {
+    const res = await this.client.fetch.get<OptionsGreeks>(ENDPOINTS.OPTIONS_GREEKS, {
+      params: { symbol, expiry, strike, side },
+    });
+    return {
+      ...res,
+      strike: n(res.strike),
+      delta: n(res.delta),
+      gamma: n(res.gamma),
+      theta: n(res.theta),
+      vega: n(res.vega),
+      iv: n(res.iv),
+    };
+  }
+
+  async getVixTerm(): Promise<VixTermResponse> {
+    const res = await this.client.fetch.get<VixTermResponse>(ENDPOINTS.VIX_TERM);
+    return { ...res, points: (res.points ?? []).map(coerceVixPoint) };
+  }
+
   async getTradingSnapshots(params?: TradingSnapshotsParams): Promise<TradingSnapshotsResponse> {
-    return this.client.fetch.get<TradingSnapshotsResponse>(ENDPOINTS.TRADING_SNAPSHOTS, {
+    const res = await this.client.fetch.get<TradingSnapshotsResponse>(ENDPOINTS.TRADING_SNAPSHOTS, {
       params: params as Record<string, unknown> | undefined,
     });
+    return {
+      ...res,
+      results: res.results.map((s) => ({
+        ...s,
+        alpaca: {
+          ...s.alpaca,
+          equity: n(s.alpaca.equity),
+          cash: n(s.alpaca.cash),
+          buyingPower: n(s.alpaca.buyingPower),
+          positions: (s.alpaca.positions ?? []).map(coercePosition),
+        },
+      })),
+    };
   }
 }