@vesper85/strategy-sdk 0.1.0 → 0.1.3

package/dist/index.js

@@ -1,19 +1,57 @@
 import { PolymarketGammaClient } from 'polymarket-gamma';
 import { ClobClient, Side } from '@polymarket/clob-client';
-import { MaxUint256, ethers } from 'ethers';
+import { ethers } from 'ethers';
 import axios from 'axios';
 import { serializeSignature, createWalletClient, http } from 'viem';
 import { connectMCPServer, removeConnection } from '@osiris-ai/agent-sdk';
 import { Hyperliquid } from 'hyperliquid';
 import { createClient } from 'redis';
 import superjson from 'superjson';
-import { TechnicalAnalysisService } from '@vesper85/technical-indicators';
+import { TechnicalAnalysisService } from '@osiris-ai/technical-indicators';
 import WebSocket from 'ws';
+import { RealTimeDataClient, ConnectionStatus } from '@polymarket/real-time-data-client';
 import { privateKeyToAccount } from 'viem/accounts';
 import { sepolia, base, optimism, arbitrum, polygon, mainnet } from 'viem/chains';
 
 // @osiris-ai/strategy-sdk - Strategy SDK for Trading
 
+// src/types/event-types.ts
+function isMarketSubscription(sub) {
+  return sub.type === "price" || sub.type === "orderbook" || sub.type === "trade" || sub.type === "fill";
+}
+function isWalletSubscription(sub) {
+  return sub.type === "wallet";
+}
+function isOpportunitySubscription(sub) {
+  return sub.type === "opportunity";
+}
+function isCustomSubscription(sub) {
+  return sub.type === "custom";
+}
+function isClobMarketSubscription(sub) {
+  return sub.type === "clob_market";
+}
+function isClobUserSubscription(sub) {
+  return sub.type === "clob_user";
+}
+function isActivitySubscription(sub) {
+  return sub.type === "activity";
+}
+function isCommentsSubscription(sub) {
+  return sub.type === "comments";
+}
+function isCryptoPricesSubscription(sub) {
+  return sub.type === "crypto_prices";
+}
+function isRfqSubscription(sub) {
+  return sub.type === "rfq";
+}
+function isPolymarketSubscription(sub) {
+  return isClobMarketSubscription(sub) || isClobUserSubscription(sub) || isActivitySubscription(sub) || isCommentsSubscription(sub) || isCryptoPricesSubscription(sub) || isRfqSubscription(sub);
+}
+function isOsirisSubscription(sub) {
+  return isWalletSubscription(sub) || isOpportunitySubscription(sub);
+}
 var OsirisSigner = class {
   hubBaseUrl;
   accessToken;
@@ -148,13 +186,88 @@ var OsirisSigner = class {
     return void 0;
   }
 };
-var MaxUint256BigInt = BigInt(MaxUint256.toString());
+
+// src/utils/index.ts
+function mapToGammaMarket(raw) {
+  const safeParse = (value) => {
+    try {
+      return typeof value === "string" ? JSON.parse(value) : value;
+    } catch {
+      return [];
+    }
+  };
+  return {
+    // Identity & Basic Info
+    id: raw.id,
+    question: raw.question,
+    slug: raw.slug,
+    condition_id: raw.conditionId,
+    question_id: raw.questionId,
+    // If present
+    description: raw.description,
+    // Dates
+    end_date: raw.endDate,
+    start_date: raw.startDate,
+    created_at: raw.createdAt,
+    updated_at: raw.updatedAt,
+    closed_time: raw.closedTime,
+    // Images
+    image: raw.image,
+    icon: raw.icon,
+    twitter_card_image: raw.twitterCardImage,
+    // Categorization
+    category: raw.category,
+    tags: raw.tags,
+    market_type: raw.marketType,
+    active: raw.active,
+    closed: raw.closed,
+    archived: raw.archived,
+    restricted: raw.restricted,
+    // Financials & Numbers (Type Conversions)
+    liquidity: raw.liquidity ? parseFloat(raw.liquidity) : 0,
+    volume: raw.volume,
+    // Interface keeps this as string
+    volume_24hr: raw.volume24hr?.toString(),
+    // Prices (Number -> String conversion based on your Interface)
+    best_bid: raw.bestBid?.toString(),
+    best_ask: raw.bestAsk?.toString(),
+    last_trade_price: raw.lastTradePrice?.toString(),
+    // Arrays (Parsing stringified JSON)
+    outcomes: safeParse(raw.outcomes),
+    outcome_prices: safeParse(raw.outcomePrices),
+    outcomePrices: safeParse(raw.outcomePrices),
+    // Populating alias
+    clob_token_ids: safeParse(raw.clobTokenIds),
+    clobTokenIds: safeParse(raw.clobTokenIds),
+    // Populating alias
+    uma_resolution_statuses: safeParse(raw.umaResolutionStatuses),
+    // Market Maker & Fees
+    market_maker_address: raw.marketMakerAddress,
+    maker_fee_bps: raw.makerFeeBps,
+    taker_fee_bps: raw.takerFeeBps,
+    // IDs
+    created_by: raw.updatedBy,
+    // Note: response has updatedBy, mapping to potentially relevant field
+    updated_by: raw.updatedBy,
+    // Misc
+    events: raw.events,
+    // Pass through if structure matches, otherwise map Event type similarly
+    new: raw.new,
+    featured: raw.featured,
+    cyom: raw.cyom,
+    competitive: raw.competitive
+  };
+}
+
+// src/clients/polymarket-client.ts
+var MaxUint256BigInt = typeof ethers.constants !== "undefined" && ethers.constants.MaxUint256 ? BigInt(ethers.MaxUint256.toString()) : BigInt("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
 var POLYGON_CHAIN_ID = 137;
 var USDC_ADDRESS = "0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174";
 var CTF_ADDRESS = "0x4D97DCd97eC945f40cF65F87097ACe5EA0476045";
 var CTF_EXCHANGE_ADDRESS = "0x4bFb41d5B3570DeFd03C39a9A4D8dE6Bd8B8982E";
 var DEFAULT_CLOB_HOST = "https://clob.polymarket.com";
 var POLYGON_RPC_URL = "https://polygon-rpc.com";
+process.env.MCP_GATEWAY_URL ? `${process.env.MCP_GATEWAY_URL}/@osiris/polymarket/mcp` : "https://gateway.backend.osirislabs.xyz/@osiris/polymarket/mcp";
 var ERC20_ABI = [
   "function approve(address spender, uint256 amount) external returns (bool)",
   "function allowance(address owner, address spender) external view returns (uint256)",
@@ -164,6 +277,13 @@ var ERC1155_ABI = [
   "function setApprovalForAll(address operator, bool approved) external",
   "function isApprovedForAll(address account, address operator) external view returns (bool)"
 ];
+function wrapWalletForV5Compatibility(wallet) {
+  const wrappedWallet = wallet;
+  wrappedWallet._signTypedData = async function(domain, types, value) {
+    return wallet.signTypedData(domain, types, value);
+  };
+  return wrappedWallet;
+}
 var PolymarketClient = class {
   constructor(logger, signer, userAddress, options) {
     this.logger = logger;
@@ -171,7 +291,7 @@ var PolymarketClient = class {
     this.userAddress = userAddress;
     this.gammaClient = new PolymarketGammaClient();
     this.provider = new ethers.JsonRpcProvider(POLYGON_RPC_URL);
-    this.isOsirisSigner = signer instanceof OsirisSigner || signer.impl instanceof OsirisSigner || signer.getPrivateKey() === void 0;
+    this.isOsirisSigner = signer instanceof OsirisSigner || signer.getPrivateKey() === void 0;
     this.options = {
       chainId: options?.chainId ?? POLYGON_CHAIN_ID,
       autoApprove: options?.autoApprove ?? false,
@@ -230,11 +350,11 @@ var PolymarketClient = class {
         throw new Error("Could not obtain private key for CLOB client initialization. Private key signer is required for trading.");
       }
       this.wallet = new ethers.Wallet(privateKey, this.provider);
+      const v5CompatibleWallet = wrapWalletForV5Compatibility(this.wallet);
       const tempClient = new ClobClient(
         this.options.clobHost,
         this.options.chainId,
-        this.wallet
-        // Cast to any for CLOB client v5 compatibility
+        v5CompatibleWallet
       );
       this.logger.info("Deriving API credentials...");
       const apiCreds = await tempClient.createOrDeriveApiKey();
@@ -242,8 +362,7 @@ var PolymarketClient = class {
       this.clobClient = new ClobClient(
         this.options.clobHost,
         this.options.chainId,
-        this.wallet,
-        // Cast to any for CLOB client v5 compatibility
+        v5CompatibleWallet,
         apiCreds,
         signatureType
       );
@@ -257,15 +376,6 @@ var PolymarketClient = class {
   isTradingClientInitialized() {
     return this.tradingInitialized;
   }
-  async getPrivateKeyFromSigner() {
-    if (this.signer && "getPrivateKey" in this.signer) {
-      return this.signer.getPrivateKey();
-    }
-    if (this.signer && this.signer.account?.privateKey) {
-      return this.signer.account.privateKey;
-    }
-    return null;
-  }
   ensureTradingClient() {
     if (!this.clobClient || !this.tradingInitialized) {
       throw new Error("Trading client not initialized. Call initializeTradingClient() first.");
@@ -568,7 +678,7 @@ var PolymarketClient = class {
       const allowanceResult = await this.callMCPTool("check_allowance", {
         token: tokenType
       });
-      this.logger.debug("[MCP] Allowance check result:", allowanceResult);
+      console.log("allowanceResult", allowanceResult);
       const allowanceContent = this.extractMCPContent(allowanceResult);
       const contractMatches = allowanceContent?.match(/0x[a-fA-F0-9]{40}:\s*(true|false)/gi);
       let hasFullAllowance = true;
@@ -661,18 +771,6 @@ var PolymarketClient = class {
       ctfWasAlreadyApproved: false
     };
     try {
-      const address = this.userAddress;
-      if (!address) {
-        throw new Error("userAddress is required for MCP approvals");
-      }
-      const chooseWalletResult = await this.callMCPTool("choose_wallet", {
-        address
-      });
-      const walletError = this.detectMCPError(chooseWalletResult);
-      if (walletError) {
-        this.logger.error(`[MCP] Choose wallet failed: ${walletError}`);
-        throw new Error(`Choose wallet failed: ${walletError}`);
-      }
       const usdcHasAllowance = await this.checkAllowanceViaMCP("USDC");
       if (usdcHasAllowance) {
         result.usdcWasAlreadyApproved = true;
@@ -753,16 +851,13 @@ var PolymarketClient = class {
       if (!address) {
         throw new Error("userAddress is required for MCP order placement");
       }
-      this.logger.info(`[MCP] Creating limit order: ${params.side} ${params.size} @ ${params.price}`);
-      this.logger.debug(`[MCP] Using wallet address: ${address}`);
-      this.logger.debug(`[MCP] Calling choose_wallet for address: ${address}`);
+      this.logger.info(`Creating limit order via MCP: ${params.side} ${params.size} @ ${params.price}`);
       const chooseWalletResult = await this.callMCPTool("choose_wallet", {
         address
       });
-      this.logger.debug(`[MCP] choose_wallet result: ${JSON.stringify(chooseWalletResult, null, 2)}`);
       const walletError = this.detectMCPError(chooseWalletResult);
       if (walletError) {
-        this.logger.error(`[MCP] Choose wallet failed: ${walletError}`);
+        this.logger.error(`Choose wallet failed: ${walletError}`);
         return {
           success: false,
           errorMsg: walletError
@@ -775,7 +870,7 @@ var PolymarketClient = class {
           errorMsg: `Failed to approve ${params.side === "BUY" ? "USDC" : "Conditional Token"}. Please try again.`
         };
       }
-      const orderParams = {
+      const orderResult = await this.callMCPTool("create_and_post_order", {
         userOrder: {
           tokenID: params.tokenId,
           side: params.side,
@@ -784,11 +879,7 @@ var PolymarketClient = class {
         },
         orderType: params.expiration ? "GTD" : "GTC",
         deferExec: false
-      };
-      this.logger.debug(`[MCP] Limit order params:`, orderParams);
-      this.logger.info(`[MCP] Submitting limit order: ${params.side} ${params.size} @ ${params.price} for token ${params.tokenId.substring(0, 20)}...`);
-      const orderResult = await this.callMCPTool("create_and_post_order", orderParams);
-      this.logger.debug(`[MCP] Raw limit order result: ${JSON.stringify(orderResult, null, 2)}`);
+      });
       const orderError = this.detectMCPError(orderResult);
       if (orderError) {
         this.logger.error(`Limit order via MCP failed: ${orderError}`);
@@ -799,13 +890,13 @@ var PolymarketClient = class {
       }
       const orderDetails = this.extractOrderDetails(orderResult);
       if (!orderDetails) {
-        this.logger.error(`Failed to extract order details from MCP response`, orderResult);
+        this.logger.error("Failed to extract order details from MCP response");
         return {
           success: false,
           errorMsg: "Failed to extract order details from MCP response"
         };
       }
-      this.logger.info(`[MCP] Limit order created: ${orderDetails.orderID}`);
+      this.logger.info(`Limit order via MCP created: ${orderDetails.orderID}`);
       return {
         success: true,
         orderId: orderDetails.orderID,
@@ -866,14 +957,10 @@ var PolymarketClient = class {
       if (!address) {
         throw new Error("userAddress is required for MCP order placement");
       }
-      this.logger.info(`[MCP] Creating market order: ${params.side} ${params.amount} USDC`);
-      this.logger.debug(`[MCP] Using wallet address: ${address}`);
-      this.logger.debug(`[MCP] Order details: tokenId=${params.tokenId}, side=${params.side}, amount=${params.amount}`);
-      this.logger.debug(`[MCP] Calling choose_wallet for address: ${address}`);
+      this.logger.info(`Creating market order via MCP: ${params.side} ${params.amount}`);
       const chooseWalletResult = await this.callMCPTool("choose_wallet", {
         address
       });
-      this.logger.debug(`[MCP] choose_wallet result: ${JSON.stringify(chooseWalletResult, null, 2)}`);
       const walletError = this.detectMCPError(chooseWalletResult);
       if (walletError) {
         this.logger.error(`Choose wallet failed: ${walletError}`);
@@ -889,19 +976,16 @@ var PolymarketClient = class {
           errorMsg: `Failed to approve ${params.side === "BUY" ? "USDC" : "Conditional Token"}. Please try again.`
         };
       }
-      const orderParams = {
+      const orderResult = await this.callMCPTool("create_and_post_market_order", {
         userMarketOrder: {
           tokenID: params.tokenId,
           side: params.side,
-          amount: params.amount
+          amount: params.amount,
+          orderType: params.slippageTolerance ? "FOK" : "FOK"
+          // Fill or Kill
         },
         orderType: "FOK"
-        // Fill or Kill
-      };
-      this.logger.debug(`[MCP] Market order params:`, orderParams);
-      this.logger.info(`[MCP] Submitting market order: ${params.side} ${params.amount} USDC for token ${params.tokenId.substring(0, 20)}...`);
-      const orderResult = await this.callMCPTool("create_and_post_market_order", orderParams);
-      this.logger.debug(`[MCP] Raw order result: ${JSON.stringify(orderResult, null, 2)}`);
+      });
       const orderError = this.detectMCPError(orderResult);
       if (orderError) {
         this.logger.error(`Market order via MCP failed: ${orderError}`);
@@ -912,7 +996,7 @@ var PolymarketClient = class {
       }
       const orderDetails = this.extractOrderDetails(orderResult);
       if (!orderDetails) {
-        this.logger.error(`Failed to extract order details from MCP response`, orderResult);
+        this.logger.error("Failed to extract order details from MCP response");
         return {
           success: false,
           errorMsg: "Failed to extract order details from MCP response"
@@ -1027,9 +1111,8 @@ var PolymarketClient = class {
   // ============================================
   async buy(tokenId, size) {
     if (!this.tradingInitialized) {
-      throw new Error(
-        `Trading client not initialized. Call initializeTradingClient() before placing orders. Attempted to buy ${size} USDC of token ${tokenId}.`
-      );
+      this.logger.warning(`[Dummy] Buying ${size} of ${tokenId} - trading client not initialized`);
+      return;
     }
     const response = await this.createMarketOrder({
       tokenId,
@@ -1042,9 +1125,8 @@ var PolymarketClient = class {
   }
   async sell(tokenId, size) {
     if (!this.tradingInitialized) {
-      throw new Error(
-        `Trading client not initialized. Call initializeTradingClient() before placing orders. Attempted to sell ${size} shares of token ${tokenId}.`
-      );
+      this.logger.warning(`[Dummy] Selling ${size} of ${tokenId} - trading client not initialized`);
+      return;
     }
     const response = await this.createMarketOrder({
       tokenId,
@@ -1056,73 +1138,6 @@ var PolymarketClient = class {
     }
   }
   // ============================================
-  // Convenience Trading Methods
-  // ============================================
-  /**
-   * Place a limit buy order
-   */
-  async buyLimit(tokenId, price, size) {
-    if (!this.tradingInitialized) {
-      throw new Error(
-        `Trading client not initialized. Call initializeTradingClient() before placing orders.`
-      );
-    }
-    return this.createLimitOrder({
-      tokenId,
-      price,
-      size,
-      side: "BUY"
-    });
-  }
-  /**
-   * Place a limit sell order
-   */
-  async sellLimit(tokenId, price, size) {
-    if (!this.tradingInitialized) {
-      throw new Error(
-        `Trading client not initialized. Call initializeTradingClient() before placing orders.`
-      );
-    }
-    return this.createLimitOrder({
-      tokenId,
-      price,
-      size,
-      side: "SELL"
-    });
-  }
-  /**
-   * Place a market buy order
-   */
-  async buyMarket(tokenId, amount, slippage = 0.05) {
-    if (!this.tradingInitialized) {
-      throw new Error(
-        `Trading client not initialized. Call initializeTradingClient() before placing orders.`
-      );
-    }
-    return this.createMarketOrder({
-      tokenId,
-      amount,
-      side: "BUY",
-      slippageTolerance: slippage
-    });
-  }
-  /**
-   * Place a market sell order
-   */
-  async sellMarket(tokenId, size, slippage = 0.05) {
-    if (!this.tradingInitialized) {
-      throw new Error(
-        `Trading client not initialized. Call initializeTradingClient() before placing orders.`
-      );
-    }
-    return this.createMarketOrder({
-      tokenId,
-      amount: size,
-      side: "SELL",
-      slippageTolerance: slippage
-    });
-  }
-  // ============================================
   // Data Methods
   // ============================================
   async getPrice(ticker) {
@@ -1182,7 +1197,8 @@ var PolymarketClient = class {
         throw new Error(`Gamma API error: ${response.status} ${response.statusText}`);
       }
       const data = await response.json();
-      return data;
+      const mappedData = data.map(mapToGammaMarket);
+      return mappedData;
     } catch (error) {
       this.logger.error("Error fetching markets from Gamma API", error);
       throw error;
@@ -1270,26 +1286,8 @@ var PolymarketClient = class {
     return this.fetchData("/activity", { user, ...params });
   }
   async getTopHolders(marketId) {
-    try {
-      if (this.clobClient) {
-        try {
-          const market = await this.getMarket(marketId);
-          if (market && market.tokens) {
-            return market.tokens.map((token) => ({
-              tokenId: token.token_id,
-              outcome: token.outcome,
-              holders: token.holders || 0
-            }));
-          }
-        } catch (e) {
-        }
-      }
-      this.logger.debug("getTopHolders: No direct API available, returning market token info if available");
-      return [];
-    } catch (error) {
-      this.logger.error(`Error fetching top holders for ${marketId}`, error);
-      return [];
-    }
+    this.logger.warning("getTopHolders not directly supported by public Data API");
+    return [];
   }
   async getPortfolioValue(user) {
     try {
@@ -1304,18 +1302,8 @@ var PolymarketClient = class {
     }
   }
   async getClosedPositions(user, params) {
-    try {
-      const allPositions = await this.getPositions(user, params);
-      const closedPositions = allPositions.filter((pos) => {
-        const size = parseFloat(pos.size || pos.amount || "0");
-        const isClosed = size === 0 || pos.closed === true || pos.status === "closed";
-        return isClosed;
-      });
-      return closedPositions;
-    } catch (error) {
-      this.logger.error("Error fetching closed positions", error);
-      return [];
-    }
+    this.logger.warning("getClosedPositions not directly supported, returning empty");
+    return [];
   }
   async getTradedMarketsCount(user) {
     try {
@@ -1338,21 +1326,8 @@ var PolymarketClient = class {
   }
   // Account methods
   async getPosition(ticker) {
-    try {
-      if (!this.userAddress) {
-        this.logger.error("getPosition requires userAddress to be set");
-        return null;
-      }
-      const positions = await this.getPositions(this.userAddress);
-      const matchingPosition = positions.find((pos) => {
-        const marketMatch = pos.market === ticker || pos.slug === ticker || pos.condition_id === ticker || pos.asset_id === ticker || pos.token_id === ticker;
-        return marketMatch && parseFloat(pos.size || pos.amount || "0") > 0;
-      });
-      return matchingPosition || null;
-    } catch (error) {
-      this.logger.error(`Error fetching position for ${ticker}`, error);
-      return null;
-    }
+    this.logger.warning("getPosition(ticker) not implemented. Use getPositions(user) instead.");
+    return null;
   }
 };
 var HyperliquidClient = class {
@@ -1720,11 +1695,11 @@ async function runStrategy(strategy, config, context) {
     }
     return false;
   } catch (error) {
-    config.logger.error(`Error executing strategy: ${error.message}`, error);
+    config.logger?.error(`Error executing strategy: ${error.message}`, error);
     throw error;
   }
 }
-function createStrategyEngine(strategy, config, context) {
+function createStrategyEngine(strategy, context, config) {
   return new StrategyEngine(strategy, config, context);
 }
 var StrategyEngine = class {
@@ -1732,6 +1707,7 @@ var StrategyEngine = class {
     this.strategy = strategy;
     this.config = config;
     this.context = context;
+    this.config.logger = this.config.logger || createConsoleLogger();
   }
   intervalId = null;
   isRunning = false;
@@ -1739,6 +1715,9 @@ var StrategyEngine = class {
    * Start the engine with the configured tick interval
    */
   start() {
+    if (!this.config.logger) {
+      this.config.logger = createConsoleLogger();
+    }
     if (this.isRunning) {
       this.config.logger.warning("Strategy engine is already running");
       return;
@@ -1755,6 +1734,9 @@ var StrategyEngine = class {
    * Stop the engine
    */
   stop() {
+    if (!this.config.logger) {
+      this.config.logger = createConsoleLogger();
+    }
     if (!this.isRunning) {
       return;
     }
@@ -1773,6 +1755,9 @@ var StrategyEngine = class {
   }
   async tick() {
     const tickStart = Date.now();
+    if (!this.config.logger) {
+      this.config.logger = createConsoleLogger();
+    }
     this.config.logger.debug(`Tick start: ${(/* @__PURE__ */ new Date()).toISOString()}`);
     try {
       await runStrategy(this.strategy, this.config, this.context);
@@ -1803,7 +1788,8 @@ function validateStrategy(strategy) {
     );
   }
 }
-var EventRunner = class {
+var POLYMARKET_RTDS_URL = "wss://ws-live-data.polymarket.com";
+var PolymarketEventRunner = class {
   constructor(strategy, config, context) {
     this.strategy = strategy;
     this.config = config;
@@ -1817,31 +1803,34 @@ var EventRunner = class {
     this.maxReconnectAttempts = config.reconnect?.maxAttempts ?? 10;
     this.baseReconnectDelay = config.reconnect?.delayMs ?? 1e3;
     this.maxReconnectDelay = config.reconnect?.maxDelayMs ?? 3e4;
+    this.pingIntervalMs = config.pingIntervalMs ?? 5e3;
   }
   ws = null;
   isRunning = false;
   reconnectAttempts = 0;
   reconnectTimeout = null;
+  pingInterval = null;
   isIntentionallyClosed = false;
   // Default reconnection settings
   maxReconnectAttempts;
   baseReconnectDelay;
   maxReconnectDelay;
+  pingIntervalMs;
   /**
    * Start listening to events
-   * Connects to the WebSocket and subscribes to events
+   * Connects to Polymarket RTDS and subscribes to events
    */
   start() {
     if (this.isRunning) {
-      this.config.logger.warning("Event runner is already running");
+      this.config.logger.warning("Polymarket event runner is already running");
       return;
     }
     this.isRunning = true;
     this.isIntentionallyClosed = false;
     this.reconnectAttempts = 0;
     const strategyName = this.config.strategyId || "unnamed-strategy";
-    this.config.logger.info(`Starting event runner for strategy ${strategyName}`);
-    this.config.logger.info(`Connecting to event source: ${this.config.eventSourceUrl}`);
+    this.config.logger.info(`Starting Polymarket event runner for strategy ${strategyName}`);
+    this.config.logger.info(`Connecting to Polymarket RTDS: ${POLYMARKET_RTDS_URL}`);
     this.connect();
   }
   /**
@@ -1853,6 +1842,10 @@ var EventRunner = class {
     }
     this.isRunning = false;
     this.isIntentionallyClosed = true;
+    if (this.pingInterval) {
+      clearInterval(this.pingInterval);
+      this.pingInterval = null;
+    }
     if (this.reconnectTimeout) {
       clearTimeout(this.reconnectTimeout);
       this.reconnectTimeout = null;
@@ -1865,7 +1858,7 @@ var EventRunner = class {
       }
       this.ws = null;
     }
-    this.config.logger.info("Event runner stopped");
+    this.config.logger.info("Polymarket event runner stopped");
   }
   /**
    * Check if the runner is currently active
@@ -1885,39 +1878,65 @@ var EventRunner = class {
     };
   }
   /**
-   * Connect to the WebSocket event source
+   * Connect to Polymarket RTDS WebSocket
    */
   connect() {
     if (this.isIntentionallyClosed) {
       return;
     }
     try {
-      this.ws = new WebSocket(this.config.eventSourceUrl);
+      this.ws = new WebSocket(POLYMARKET_RTDS_URL);
       this.ws.on("open", () => {
-        this.config.logger.info("Connected to event source");
+        this.config.logger.info("Connected to Polymarket RTDS");
         this.reconnectAttempts = 0;
+        this.startPingInterval();
         this.subscribeToEvents();
       });
       this.ws.on("message", (data) => {
         this.handleMessage(data);
       });
       this.ws.on("error", (error) => {
-        this.config.logger.error(`WebSocket error: ${error.message}`, error);
+        this.config.logger.error(`Polymarket RTDS WebSocket error: ${error.message}`, error);
       });
       this.ws.on("close", (code, reason) => {
         const reasonStr = reason.toString() || "none";
-        this.config.logger.info(`WebSocket closed (code: ${code}, reason: ${reasonStr})`);
+        this.config.logger.info(`Polymarket RTDS WebSocket closed (code: ${code}, reason: ${reasonStr})`);
+        if (this.pingInterval) {
+          clearInterval(this.pingInterval);
+          this.pingInterval = null;
+        }
         if (!this.isIntentionallyClosed && this.isRunning) {
           this.attemptReconnect();
         }
       });
+      this.ws.on("pong", () => {
+        this.config.logger.debug("Received PONG from Polymarket RTDS");
+      });
     } catch (error) {
-      this.config.logger.error(`Failed to connect to WebSocket: ${error.message}`, error);
+      this.config.logger.error(`Failed to connect to Polymarket RTDS: ${error.message}`, error);
       if (this.isRunning && !this.isIntentionallyClosed) {
         this.attemptReconnect();
       }
     }
   }
+  /**
+   * Start ping interval to maintain connection (Polymarket recommends 5 seconds)
+   */
+  startPingInterval() {
+    if (this.pingInterval) {
+      clearInterval(this.pingInterval);
+    }
+    this.pingInterval = setInterval(() => {
+      if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+        try {
+          this.ws.send("PING");
+          this.config.logger.debug("Sent PING to Polymarket RTDS");
+        } catch (error) {
+          this.config.logger.warning("Failed to send PING");
+        }
+      }
+    }, this.pingIntervalMs);
+  }
   /**
    * Attempt to reconnect with exponential backoff
    */
@@ -1940,6 +1959,165 @@ var EventRunner = class {
       this.connect();
     }, delay);
   }
+  /**
+   * Map strategy subscriptions to Polymarket RTDS subscriptions
+   * Only MarketSubscription types are supported by Polymarket RTDS
+   * WalletSubscription and OpportunitySubscription are Osiris-only features
+   */
+  mapToRTDSSubscriptions() {
+    if (!this.strategy.subscriptions) {
+      return [];
+    }
+    const rtdsSubscriptions = [];
+    for (const sub of this.strategy.subscriptions) {
+      let rtdsSub = null;
+      if (isCryptoPricesSubscription(sub)) {
+        rtdsSub = {
+          topic: "crypto_prices",
+          type: "update"
+        };
+        if (sub.symbol) {
+          rtdsSub.filters = JSON.stringify({ symbol: sub.symbol.toLowerCase() });
+        }
+      } else if (isActivitySubscription(sub)) {
+        rtdsSub = {
+          topic: "activity",
+          type: sub.messageType || "*"
+        };
+        if (sub.eventSlug) {
+          rtdsSub.filters = JSON.stringify({ event_slug: sub.eventSlug });
+        } else if (sub.marketSlug) {
+          rtdsSub.filters = JSON.stringify({ market_slug: sub.marketSlug });
+        }
+      } else if (isClobMarketSubscription(sub)) {
+        rtdsSub = {
+          topic: "clob_market",
+          type: sub.messageType || "*",
+          filters: JSON.stringify([sub.marketId])
+        };
+      } else if (isClobUserSubscription(sub)) {
+        rtdsSub = {
+          topic: "clob_user",
+          type: sub.messageType || "*"
+        };
+        if (this.config.clobAuth) {
+          rtdsSub.clob_auth = this.config.clobAuth;
+        } else {
+          this.config.logger.warning(
+            `clob_user subscription requires clobAuth credentials`
+          );
+        }
+      } else if (isCommentsSubscription(sub)) {
+        rtdsSub = {
+          topic: "comments",
+          type: sub.messageType || "*"
+        };
+        if (sub.parentEntityId && sub.parentEntityType) {
+          rtdsSub.filters = JSON.stringify({
+            parentEntityID: sub.parentEntityId,
+            parentEntityType: sub.parentEntityType
+          });
+        }
+      } else if (isRfqSubscription(sub)) {
+        rtdsSub = {
+          topic: "rfq",
+          type: sub.messageType || "*"
+        };
+      } else if (isMarketSubscription(sub)) {
+        const topic = this.mapEventTypeToTopic(sub.type);
+        rtdsSub = {
+          topic,
+          type: this.getMessageTypeForTopic(topic)
+        };
+      } else if (isCustomSubscription(sub)) {
+        const validRTDSTopics = [
+          "crypto_prices",
+          "comments",
+          "activity",
+          "orders",
+          "trades",
+          "profile"
+        ];
+        if (validRTDSTopics.includes(sub.topic)) {
+          const topic = sub.topic;
+          rtdsSub = {
+            topic,
+            type: this.getMessageTypeForTopic(topic)
+          };
+        } else {
+          this.config.logger.warning(
+            `Custom subscription topic '${sub.topic}' is not a valid Polymarket RTDS topic. Valid topics: ${validRTDSTopics.join(", ")}`
+          );
+          continue;
+        }
+      } else {
+        this.config.logger.warning(
+          `Subscription type '${sub.type}' is not supported by Polymarket RTDS. Osiris-only subscription types (wallet, opportunity) should use eventSource: 'osiris'.`
+        );
+        continue;
+      }
+      if (!rtdsSub) continue;
+      if (this.config.clobAuth && ["orders", "trades"].includes(rtdsSub.topic)) {
+        rtdsSub.clob_auth = this.config.clobAuth;
+      }
+      if (this.config.walletAddress && ["activity", "profile"].includes(rtdsSub.topic)) {
+        rtdsSub.gamma_auth = {
+          address: this.config.walletAddress
+        };
+      }
+      rtdsSubscriptions.push(rtdsSub);
+    }
+    return rtdsSubscriptions;
+  }
+  /**
+   * Get the message type for a given RTDS topic
+   * Each topic has specific message types as per the Polymarket RTDS documentation
+   * 
+   * Note: Only 'crypto_prices' and 'comments' are documented RTDS topics.
+   * 'trades' and 'orders' subscriptions require the CLOB WebSocket API, not RTDS.
+   */
+  getMessageTypeForTopic(topic) {
+    switch (topic) {
+      case "crypto_prices":
+        return "update";
+      case "comments":
+        return "comment_created";
+      case "trades":
+        this.config.logger.warning(
+          `Topic 'trades' may not be supported by Polymarket RTDS. Consider using the CLOB WebSocket API for order/trade events.`
+        );
+        return "trade";
+      case "orders":
+        this.config.logger.warning(
+          `Topic 'orders' may not be supported by Polymarket RTDS. Consider using the CLOB WebSocket API for order/trade events.`
+        );
+        return "order_placed";
+      case "activity":
+        return "trade";
+      case "profile":
+        return "update";
+      default:
+        return "update";
+    }
+  }
+  /**
+   * Map EventType to Polymarket RTDS topic
+   */
+  mapEventTypeToTopic(eventType) {
+    switch (eventType) {
+      case "price":
+        return "crypto_prices";
+      case "trade":
+        return "trades";
+      case "orderbook":
+      case "fill":
+        return "orders";
+      case "custom":
+        return "activity";
+      default:
+        return "activity";
+    }
+  }
   /**
    * Subscribe to events based on strategy's subscriptions
    */
@@ -1952,14 +2130,15 @@ var EventRunner = class {
       this.config.logger.warning("No subscriptions defined for strategy");
       return;
     }
+    const rtdsSubscriptions = this.mapToRTDSSubscriptions();
     const subscribeMessage = {
       action: "subscribe",
-      subscriptions: this.strategy.subscriptions
+      subscriptions: rtdsSubscriptions
     };
     try {
       this.ws.send(JSON.stringify(subscribeMessage));
       this.config.logger.info(
-        `Subscribed to ${this.strategy.subscriptions.length} event(s): ` + this.strategy.subscriptions.map((s) => `${s.type}${s.market ? `@${s.market}` : ""}`).join(", ")
+        `Subscribed to ${rtdsSubscriptions.length} Polymarket RTDS topic(s): ` + rtdsSubscriptions.map((s) => s.topic).join(", ")
       );
     } catch (error) {
       this.config.logger.error(`Failed to send subscription: ${error.message}`, error);
@@ -1975,9 +2154,10 @@ var EventRunner = class {
     if (!this.strategy.subscriptions || this.strategy.subscriptions.length === 0) {
       return;
     }
+    const rtdsSubscriptions = this.mapToRTDSSubscriptions();
     const unsubscribeMessage = {
       action: "unsubscribe",
-      subscriptions: this.strategy.subscriptions
+      subscriptions: rtdsSubscriptions
     };
     try {
       this.ws.send(JSON.stringify(unsubscribeMessage));
@@ -1990,7 +2170,11 @@ var EventRunner = class {
   handleMessage(data) {
     try {
       const rawData = typeof data === "string" ? data : data.toString();
-      if (rawData === "PING" || rawData === "PONG" || rawData.trim() === "") {
+      if (rawData === "PING") {
+        this.ws?.send("PONG");
+        return;
+      }
+      if (rawData === "PONG" || rawData.trim() === "") {
         return;
       }
       let message;
@@ -2000,20 +2184,98 @@ var EventRunner = class {
         this.config.logger.warning(`Received non-JSON message: ${rawData.slice(0, 100)}`);
         return;
       }
-      if (!this.isValidEvent(message)) {
+      if (!this.isValidRTDSMessage(message)) {
         this.config.logger.debug(`Received non-event message: ${JSON.stringify(message).slice(0, 200)}`);
         return;
       }
-      this.dispatchEvent(message);
+      const strategyEvent = this.convertToStrategyEvent(message);
+      this.dispatchEvent(strategyEvent);
     } catch (error) {
       this.config.logger.error(`Error handling message: ${error.message}`, error);
     }
   }
   /**
-   * Validate that a message is a valid StrategyEvent
+   * Validate that a message is a valid Polymarket RTDS message
    */
-  isValidEvent(message) {
-    return message && typeof message === "object" && typeof message.type === "string" && typeof message.timestamp === "number" && typeof message.data === "object";
+  isValidRTDSMessage(message) {
+    return message && typeof message === "object" && typeof message.topic === "string" && typeof message.type === "string" && typeof message.timestamp === "number" && typeof message.payload === "object";
+  }
+  /**
+   * Convert Polymarket RTDS message to StrategyEvent
+   */
+  convertToStrategyEvent(message) {
+    const eventType = this.mapTopicToEventType(message.topic);
+    const eventData = this.extractEventData(message);
+    return {
+      type: eventType,
+      timestamp: message.timestamp,
+      market: eventData.market,
+      data: eventData
+    };
+  }
+  /**
+   * Map Polymarket RTDS topic to EventType
+   */
+  mapTopicToEventType(topic) {
+    switch (topic) {
+      case "crypto_prices":
+        return "price";
+      case "trades":
+        return "trade";
+      case "orders":
+        return "orderbook";
+      case "activity":
+      case "comments":
+      case "profile":
+      default:
+        return "custom";
+    }
+  }
+  /**
+   * Extract event data from Polymarket RTDS payload
+   */
+  extractEventData(message) {
+    const payload = message.payload;
+    const data = {
+      raw: {
+        ...payload,
+        topic: message.topic,
+        // Include topic for easier filtering
+        type: message.type
+        // Include message type
+      }
+    };
+    switch (message.topic) {
+      case "crypto_prices":
+        data.price = payload.price ?? payload.value;
+        data.previousPrice = payload.previousPrice ?? payload.previous;
+        data.changePercent = payload.changePercent ?? payload.change;
+        break;
+      case "trades":
+        data.price = payload.price;
+        data.size = payload.size ?? payload.amount;
+        data.side = payload.side;
+        data.tradeId = payload.tradeId ?? payload.id;
+        break;
+      case "orders":
+        data.bestBid = payload.bestBid ?? payload.bid;
+        data.bestAsk = payload.bestAsk ?? payload.ask;
+        data.spread = payload.spread;
+        data.orderId = payload.orderId ?? payload.id;
+        break;
+      case "comments":
+        data.commentText = payload.text ?? payload.comment;
+        data.author = payload.author ?? payload.user;
+        data.market = payload.market ?? payload.slug;
+        data.commentType = payload.type;
+        data.reactions = payload.reactions;
+        break;
+    }
+    if (payload.market) data.market = payload.market;
+    if (payload.asset) data.market = payload.asset;
+    if (payload.tokenId) data.market = payload.tokenId;
+    if (payload.conditionId) data.market = payload.conditionId;
+    return data;
   }
   /**
    * Dispatch an event to the strategy's onEvent handler
@@ -2037,8 +2299,1280 @@ var EventRunner = class {
     this.config.logger.debug(`Event handling completed in ${eventDuration}ms`);
   }
 };
-function createEventRunner(strategy, config, context) {
-  return new EventRunner(strategy, config, context);
+function createPolymarketEventRunner(strategy, config, context) {
+  return new PolymarketEventRunner(strategy, config, context);
+}
+
+// src/engine/event-runner.ts
+var OsirisEventRunner = class {
+  constructor(strategy, config, context) {
+    this.strategy = strategy;
+    this.config = config;
+    this.context = context;
+    if (!this.strategy.subscriptions || this.strategy.subscriptions.length === 0) {
+      throw new Error("Strategy must have subscriptions defined for event-based execution");
+    }
+    if (typeof this.strategy.onEvent !== "function") {
+      throw new Error("Strategy must implement onEvent method for event-based execution");
+    }
+    this.maxReconnectAttempts = config.reconnect?.maxAttempts ?? 10;
+    this.baseReconnectDelay = config.reconnect?.delayMs ?? 1e3;
+    this.maxReconnectDelay = config.reconnect?.maxDelayMs ?? 3e4;
+    if (!config.eventSourceUrl) ;
+  }
+  ws = null;
+  isRunning = false;
+  reconnectAttempts = 0;
+  reconnectTimeout = null;
+  isIntentionallyClosed = false;
+  // Default reconnection settings
+  maxReconnectAttempts;
+  baseReconnectDelay;
+  maxReconnectDelay;
+  /**
+   * Start listening to events
+   * Connects to the WebSocket and subscribes to events
+   */
+  start() {
+    if (this.isRunning) {
+      this.config.logger.warning("Event runner is already running");
+      return;
+    }
+    this.isRunning = true;
+    this.isIntentionallyClosed = false;
+    this.reconnectAttempts = 0;
+    const strategyName = this.config.strategyId || "unnamed-strategy";
+    this.config.logger.info(`Starting event runner for strategy ${strategyName}`);
+    this.config.logger.info(`Connecting to event source: ${this.config.eventSourceUrl}`);
+    this.connect();
+  }
+  /**
+   * Stop listening and disconnect from WebSocket
+   */
+  stop() {
+    if (!this.isRunning) {
+      return;
+    }
+    this.isRunning = false;
+    this.isIntentionallyClosed = true;
+    if (this.reconnectTimeout) {
+      clearTimeout(this.reconnectTimeout);
+      this.reconnectTimeout = null;
+    }
+    if (this.ws) {
+      try {
+        this.unsubscribeFromEvents();
+        this.ws.close(1e3, "Intentional close");
+      } catch (error) {
+      }
+      this.ws = null;
+    }
+    this.config.logger.info("Event runner stopped");
+  }
+  /**
+   * Check if the runner is currently active
+   */
+  isActive() {
+    return this.isRunning;
+  }
+  /**
+   * Get current connection status
+   */
+  getStatus() {
+    return {
+      running: this.isRunning,
+      connected: this.ws?.readyState === WebSocket.OPEN,
+      reconnectAttempts: this.reconnectAttempts,
+      subscriptionCount: this.strategy.subscriptions?.length ?? 0
+    };
+  }
+  /**
+   * Connect to the WebSocket event source
+   */
+  connect() {
+    if (this.isIntentionallyClosed) {
+      return;
+    }
+    try {
+      if (!this.config.eventSourceUrl) {
+        throw new Error("eventSourceUrl is required for OsirisEventRunner");
+      }
+      this.ws = new WebSocket(this.config.eventSourceUrl);
+      this.ws.on("open", () => {
+        this.config.logger.info("Connected to event source");
+        this.reconnectAttempts = 0;
+        this.subscribeToEvents();
+      });
+      this.ws.on("message", (data) => {
+        this.handleMessage(data);
+      });
+      this.ws.on("error", (error) => {
+        this.config.logger.error(`WebSocket error: ${error.message}`, error);
+      });
+      this.ws.on("close", (code, reason) => {
+        const reasonStr = reason.toString() || "none";
+        this.config.logger.info(`WebSocket closed (code: ${code}, reason: ${reasonStr})`);
+        if (!this.isIntentionallyClosed && this.isRunning) {
+          this.attemptReconnect();
+        }
+      });
+    } catch (error) {
+      this.config.logger.error(`Failed to connect to WebSocket: ${error.message}`, error);
+      if (this.isRunning && !this.isIntentionallyClosed) {
+        this.attemptReconnect();
+      }
+    }
+  }
+  /**
+   * Attempt to reconnect with exponential backoff
+   */
+  attemptReconnect() {
+    if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+      this.config.logger.error(`Max reconnection attempts (${this.maxReconnectAttempts}) reached`);
+      this.isRunning = false;
+      return;
+    }
+    this.reconnectAttempts++;
+    const delay = Math.min(
+      this.baseReconnectDelay * Math.pow(2, this.reconnectAttempts - 1) + Math.random() * 1e3,
+      this.maxReconnectDelay
+    );
+    this.config.logger.info(
+      `Reconnecting in ${Math.round(delay)}ms (attempt ${this.reconnectAttempts}/${this.maxReconnectAttempts})`
+    );
+    this.reconnectTimeout = setTimeout(() => {
+      this.reconnectTimeout = null;
+      this.connect();
+    }, delay);
+  }
+  /**
+   * Subscribe to events based on strategy's subscriptions
+   */
+  /**
+   * Subscribe to events based on strategy's subscriptions
+   * Maps SDK subscriptions to Osiris Pub/Sub protocol
+   */
+  subscribeToEvents() {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      this.config.logger.warning("Cannot subscribe - WebSocket not connected");
+      return;
+    }
+    if (!this.strategy.subscriptions || this.strategy.subscriptions.length === 0) {
+      this.config.logger.warning("No subscriptions defined for strategy");
+      return;
+    }
+    const topics = [];
+    const filters = {};
+    for (const sub of this.strategy.subscriptions) {
+      const topic = this.mapSubscriptionToTopic(sub);
+      if (topic) {
+        topics.push(topic);
+        if (sub.conditions) {
+          filters[topic] = sub.conditions;
+        }
+      }
+    }
+    if (topics.length === 0) {
+      this.config.logger.warning("No valid topics mapped from subscriptions");
+      return;
+    }
+    const subscribeMessage = {
+      action: "subscribe",
+      topics,
+      filters: Object.keys(filters).length > 0 ? filters : void 0
+    };
+    try {
+      this.ws.send(JSON.stringify(subscribeMessage));
+      this.config.logger.info(
+        `Subscribed to ${topics.length} topics: ${topics.join(", ")}`
+      );
+    } catch (error) {
+      this.config.logger.error(`Failed to send subscription: ${error.message}`, error);
+    }
+  }
+  /**
+   * Map EventSubscription to Osiris Pub/Sub topic string
+   * Uses discriminated union to properly handle each subscription type
+   */
+  mapSubscriptionToTopic(sub) {
+    switch (sub.type) {
+      // Market subscriptions → market:{market}
+      case "price":
+      case "orderbook":
+      case "trade":
+      case "fill":
+        return sub.market ? `market:${sub.market}` : null;
+      // Wallet subscriptions → wallet:{wallet}
+      case "wallet":
+        return sub.wallet ? `wallet:${sub.wallet}` : null;
+      // Opportunity subscriptions → opps:{filter}
+      case "opportunity":
+        return `opps:${sub.filter || "all"}`;
+      // Custom subscriptions → use topic directly
+      case "custom":
+        return sub.topic || null;
+      default:
+        return null;
+    }
+  }
+  /**
+   * Unsubscribe from events before disconnecting
+   */
+  /**
+   * Unsubscribe from events before disconnecting
+   */
+  unsubscribeFromEvents() {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      return;
+    }
+    if (!this.strategy.subscriptions || this.strategy.subscriptions.length === 0) {
+      return;
+    }
+    const topics = this.strategy.subscriptions.map((s) => this.mapSubscriptionToTopic(s)).filter((t) => t !== null);
+    if (topics.length === 0) return;
+    const unsubscribeMessage = {
+      action: "unsubscribe",
+      topics
+    };
+    try {
+      this.ws.send(JSON.stringify(unsubscribeMessage));
+    } catch (error) {
+    }
+  }
+  /**
+   * Handle incoming WebSocket messages
+   */
+  handleMessage(data) {
+    try {
+      const rawData = typeof data === "string" ? data : data.toString();
+      if (rawData === "PING" || rawData === "PONG" || rawData.trim() === "") {
+        return;
+      }
+      let message;
+      try {
+        message = JSON.parse(rawData);
+      } catch (parseError) {
+        this.config.logger.warning(`Received non-JSON message: ${rawData.slice(0, 100)}`);
+        return;
+      }
+      if (message.type === "connected") {
+        this.config.logger.info(`Osiris Pub/Sub: ${message.message}`);
+        return;
+      }
+      if (message.type === "subscribe.result") {
+        if (message.success) {
+          this.config.logger.info(`Successfully subscribed to: ${message.subscribed.join(", ")}`);
+        } else {
+          this.config.logger.error(`Subscription failed: ${JSON.stringify(message.errors)}`);
+        }
+        return;
+      }
+      if (message.type === "error") {
+        this.config.logger.error(`Osiris Pub/Sub Error: ${message.error}`);
+        return;
+      }
+      if (message.type === "pong") {
+        return;
+      }
+      const event = this.mapMessageToStrategyEvent(message);
+      if (event) {
+        this.dispatchEvent(event);
+      } else {
+        this.config.logger.debug(`Unhandled message type: ${message.type}`);
+      }
+    } catch (error) {
+      this.config.logger.error(`Error handling message: ${error.message}`, error);
+    }
+  }
+  /**
+   * Map incoming Osiris message to StrategyEvent
+   * Uses proper fields for each event type (market vs wallet)
+   */
+  mapMessageToStrategyEvent(message) {
+    const timestamp = message.ts || Date.now();
+    switch (message.type) {
+      case "market.analysis":
+        return {
+          type: "price",
+          // Treating analysis as 'price/market' update
+          market: message.slug,
+          timestamp,
+          data: {
+            ...message.data,
+            raw: message
+          }
+        };
+      case "wallet.analysis":
+        return {
+          type: "wallet",
+          wallet: message.address,
+          // Use wallet field, not market
+          timestamp,
+          data: {
+            ...message.data,
+            raw: message
+          }
+        };
+      case "opportunity":
+        return {
+          type: "opportunity",
+          market: message.slug,
+          timestamp,
+          data: {
+            ...message.data,
+            raw: message
+          }
+        };
+      default:
+        if (message.type && message.data) {
+          return {
+            type: "custom",
+            market: message.slug || message.topic,
+            timestamp,
+            data: {
+              ...message.data,
+              raw: message
+            }
+          };
+        }
+        return null;
+    }
+  }
+  /**
+   * Validate that a message is a valid StrategyEvent
+   */
+  isValidEvent(message) {
+    return message && typeof message === "object" && typeof message.type === "string";
+  }
+  /**
+   * Dispatch an event to the strategy's onEvent handler
+   */
+  async dispatchEvent(event) {
+    const eventStart = Date.now();
+    const target = event.market || event.wallet || "";
+    this.config.logger.debug(
+      `Dispatching ${event.type} event${target ? ` for ${target}` : ""}`
+    );
+    try {
+      if (this.strategy.onEvent) {
+        await this.strategy.onEvent(event, this.context);
+      }
+    } catch (error) {
+      this.config.logger.error(
+        `Error in strategy onEvent handler: ${error.message}`,
+        error
+      );
+    }
+    const eventDuration = Date.now() - eventStart;
+    this.config.logger.debug(`Event handling completed in ${eventDuration}ms`);
+  }
+};
+function createEventRunner(strategy, config, context) {
+  const hasPolymarketSubscription = strategy.subscriptions?.some(
+    (sub) => sub.eventSource === "polymarket"
+  );
+  const hasOsirisSubscription = strategy.subscriptions?.some(
+    (sub) => !sub.eventSource || sub.eventSource === "osiris"
+  );
+  if (hasPolymarketSubscription) {
+    if (hasOsirisSubscription) {
+      config.logger.warning(
+        "Strategy has both Polymarket and generic Osiris subscriptions. Only Polymarket events will be processed by this runner. Mixed sources are not currently supported in a single runner."
+      );
+    }
+    return createPolymarketEventRunner(strategy, {
+      logger: config.logger,
+      strategyId: config.strategyId,
+      clobAuth: config.polymarket?.clobAuth,
+      walletAddress: config.polymarket?.walletAddress,
+      pingIntervalMs: config.polymarket?.pingIntervalMs,
+      reconnect: config.reconnect
+    }, context);
+  }
+  if (!config.eventSourceUrl) ;
+  return new OsirisEventRunner(strategy, config, context);
+}
+var PolymarketRTDSService = class {
+  client = null;
+  config;
+  isConnected = false;
+  activeSubscriptions = [];
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Connect to the Polymarket RTDS WebSocket
+   */
+  connect() {
+    if (this.isConnected) {
+      this.config.logger.warning("PolymarketRTDS: Already connected");
+      return;
+    }
+    this.config.logger.info("PolymarketRTDS: Connecting...");
+    this.client = new RealTimeDataClient({
+      onConnect: (_client) => {
+        this.isConnected = true;
+        this.config.logger.info("PolymarketRTDS: Connected");
+        this.config.onConnect?.();
+      },
+      onMessage: (_client, message) => {
+        this.handleMessage(message);
+      },
+      onStatusChange: (status) => {
+        if (status === ConnectionStatus.DISCONNECTED) {
+          this.isConnected = false;
+          this.config.logger.info("PolymarketRTDS: Disconnected");
+          this.config.onDisconnect?.();
+        } else if (status === ConnectionStatus.CONNECTING) {
+          this.config.logger.info("PolymarketRTDS: Reconnecting...");
+        }
+      },
+      pingInterval: this.config.pingIntervalMs ?? 5e3,
+      autoReconnect: this.config.autoReconnect ?? true
+    });
+    this.client.connect();
+  }
+  /**
+   * Disconnect from the Polymarket RTDS WebSocket
+   */
+  disconnect() {
+    if (!this.client) {
+      return;
+    }
+    this.config.logger.info("PolymarketRTDS: Disconnecting...");
+    this.client.disconnect();
+    this.client = null;
+    this.isConnected = false;
+    this.activeSubscriptions = [];
+  }
+  /**
+   * Check if connected
+   */
+  isActive() {
+    return this.isConnected;
+  }
+  /**
+   * Subscribe to events
+   * Converts SDK EventSubscription types to RTDS Subscription format
+   */
+  subscribe(subscriptions) {
+    if (!this.client) {
+      this.config.logger.warning("PolymarketRTDS: Cannot subscribe - not connected");
+      return;
+    }
+    const rtdsSubscriptions = this.mapToRTDSSubscriptions(subscriptions);
+    if (rtdsSubscriptions.length === 0) {
+      this.config.logger.warning("PolymarketRTDS: No valid subscriptions to add");
+      return;
+    }
+    const msg = { subscriptions: rtdsSubscriptions };
+    this.client.subscribe(msg);
+    this.activeSubscriptions.push(...rtdsSubscriptions);
+    this.config.logger.info(
+      `PolymarketRTDS: Subscribed to ${rtdsSubscriptions.length} topic(s): ` + rtdsSubscriptions.map((s) => `${s.topic}:${s.type}`).join(", ")
+    );
+  }
+  /**
+   * Unsubscribe from events
+   */
+  unsubscribe(subscriptions) {
+    if (!this.client) {
+      return;
+    }
+    const rtdsSubscriptions = this.mapToRTDSSubscriptions(subscriptions);
+    if (rtdsSubscriptions.length === 0) {
+      return;
+    }
+    const msg = { subscriptions: rtdsSubscriptions };
+    this.client.unsubscribe(msg);
+    for (const unsub of rtdsSubscriptions) {
+      const idx = this.activeSubscriptions.findIndex(
+        (s) => s.topic === unsub.topic && s.type === unsub.type
+      );
+      if (idx >= 0) {
+        this.activeSubscriptions.splice(idx, 1);
+      }
+    }
+    this.config.logger.info(
+      `PolymarketRTDS: Unsubscribed from ${rtdsSubscriptions.length} topic(s)`
+    );
+  }
+  /**
+   * Map SDK EventSubscription to RTDS Subscription format
+   */
+  mapToRTDSSubscriptions(subscriptions) {
+    const result = [];
+    for (const sub of subscriptions) {
+      const rtdsSub = this.mapSubscription(sub);
+      if (rtdsSub) {
+        result.push(rtdsSub);
+      }
+    }
+    return result;
+  }
+  /**
+   * Map a single SDK EventSubscription to RTDS Subscription
+   */
+  mapSubscription(sub) {
+    if (isClobMarketSubscription(sub)) {
+      return this.mapClobMarketSubscription(sub);
+    }
+    if (isClobUserSubscription(sub)) {
+      return this.mapClobUserSubscription(sub);
+    }
+    if (isActivitySubscription(sub)) {
+      return this.mapActivitySubscription(sub);
+    }
+    if (isCommentsSubscription(sub)) {
+      return this.mapCommentsSubscription(sub);
+    }
+    if (isCryptoPricesSubscription(sub)) {
+      return this.mapCryptoPricesSubscription(sub);
+    }
+    if (isRfqSubscription(sub)) {
+      return this.mapRfqSubscription(sub);
+    }
+    if (isMarketSubscription(sub)) {
+      return this.mapMarketSubscription(sub);
+    }
+    this.config.logger.warning(
+      `PolymarketRTDS: Unsupported subscription type '${sub.type}'`
+    );
+    return null;
+  }
+  mapClobMarketSubscription(sub) {
+    return {
+      topic: "clob_market",
+      type: sub.messageType || "*",
+      filters: JSON.stringify([sub.marketId])
+    };
+  }
+  mapClobUserSubscription(sub) {
+    if (!this.config.clobAuth) {
+      this.config.logger.warning(
+        "PolymarketRTDS: clob_user subscription requires clobAuth credentials"
+      );
+    }
+    return {
+      topic: "clob_user",
+      type: sub.messageType || "*",
+      clob_auth: this.config.clobAuth
+    };
+  }
+  mapActivitySubscription(sub) {
+    let filters;
+    if (sub.eventSlug) {
+      filters = JSON.stringify({ event_slug: sub.eventSlug });
+    } else if (sub.marketSlug) {
+      filters = JSON.stringify({ market_slug: sub.marketSlug });
+    }
+    return {
+      topic: "activity",
+      type: sub.messageType || "*",
+      filters
+    };
+  }
+  mapCommentsSubscription(sub) {
+    let filters;
+    if (sub.parentEntityId && sub.parentEntityType) {
+      filters = JSON.stringify({
+        parentEntityID: sub.parentEntityId,
+        parentEntityType: sub.parentEntityType
+      });
+    }
+    return {
+      topic: "comments",
+      type: sub.messageType || "*",
+      filters
+    };
+  }
+  mapCryptoPricesSubscription(sub) {
+    let filters;
+    if (sub.symbol) {
+      filters = JSON.stringify({ symbol: sub.symbol.toLowerCase() });
+    }
+    return {
+      topic: "crypto_prices",
+      type: "update",
+      filters
+    };
+  }
+  mapRfqSubscription(sub) {
+    return {
+      topic: "rfq",
+      type: sub.messageType || "*"
+    };
+  }
+  mapMarketSubscription(sub) {
+    switch (sub.type) {
+      case "price":
+        return {
+          topic: "clob_market",
+          type: "price_change",
+          filters: JSON.stringify([sub.market])
+        };
+      case "orderbook":
+        return {
+          topic: "clob_market",
+          type: "agg_orderbook",
+          filters: JSON.stringify([sub.market])
+        };
+      case "trade":
+        return {
+          topic: "activity",
+          type: "trades",
+          filters: JSON.stringify({ market_slug: sub.market })
+        };
+      case "fill":
+        if (!this.config.clobAuth) {
+          this.config.logger.warning(
+            "PolymarketRTDS: fill subscription requires clobAuth credentials"
+          );
+        }
+        return {
+          topic: "clob_user",
+          type: "order",
+          clob_auth: this.config.clobAuth
+        };
+      default:
+        return {
+          topic: "activity",
+          type: "trades",
+          filters: JSON.stringify({ market_slug: sub.market })
+        };
+    }
+  }
+  /**
+   * Handle incoming RTDS messages
+   */
+  handleMessage(message) {
+    try {
+      const event = this.convertToStrategyEvent(message);
+      this.config.onEvent(event);
+    } catch (error) {
+      this.config.logger.error(
+        `PolymarketRTDS: Error processing message - ${error.message}`
+      );
+    }
+  }
+  /**
+   * Convert RTDS Message to StrategyEvent
+   */
+  convertToStrategyEvent(message) {
+    const eventType = this.mapTopicToEventType(message.topic, message.type);
+    const eventData = this.extractEventData(message);
+    return {
+      type: eventType,
+      timestamp: message.timestamp || Date.now(),
+      market: eventData.market,
+      data: eventData
+    };
+  }
+  /**
+   * Map RTDS topic/type to SDK EventType
+   */
+  mapTopicToEventType(topic, type) {
+    switch (topic) {
+      case "crypto_prices":
+        return "price";
+      case "clob_market":
+        switch (type) {
+          case "price_change":
+          case "last_trade_price":
+            return "price";
+          case "agg_orderbook":
+            return "orderbook";
+          default:
+            return "custom";
+        }
+      case "activity":
+        return "trade";
+      case "clob_user":
+        return type === "trade" ? "trade" : "fill";
+      default:
+        return "custom";
+    }
+  }
+  /**
+   * Extract event data from RTDS message payload
+   */
+  extractEventData(message) {
+    const payload = message.payload;
+    const data = {
+      raw: {
+        topic: message.topic,
+        type: message.type,
+        ...payload
+      }
+    };
+    switch (message.topic) {
+      case "crypto_prices":
+        data.price = payload.value;
+        data.market = payload.symbol;
+        break;
+      case "clob_market":
+        if (message.type === "price_change") {
+          data.market = payload.market;
+          if (payload.price_changes?.length > 0) {
+            const change = payload.price_changes[0];
+            data.bestBid = parseFloat(change.best_bid);
+            data.bestAsk = parseFloat(change.best_ask);
+            data.price = parseFloat(change.price);
+          }
+        } else if (message.type === "agg_orderbook") {
+          data.market = payload.market;
+          data.bids = payload.bids;
+          data.asks = payload.asks;
+          if (payload.bids?.length > 0) {
+            data.bestBid = parseFloat(payload.bids[0].price);
+          }
+          if (payload.asks?.length > 0) {
+            data.bestAsk = parseFloat(payload.asks[0].price);
+          }
+        } else if (message.type === "last_trade_price") {
+          data.market = payload.market;
+          data.price = parseFloat(payload.price);
+          data.side = payload.side;
+          data.size = parseFloat(payload.size);
+        }
+        break;
+      case "activity":
+        data.market = payload.slug || payload.conditionId;
+        data.price = payload.price;
+        data.size = payload.size;
+        data.side = payload.side?.toLowerCase();
+        data.tradeId = payload.transactionHash;
+        break;
+      case "clob_user":
+        data.market = payload.market;
+        data.orderId = payload.id;
+        data.price = parseFloat(payload.price);
+        data.size = parseFloat(payload.size || payload.original_size);
+        data.side = payload.side?.toLowerCase();
+        break;
+      case "rfq":
+        data.market = payload.market;
+        data.price = payload.price;
+        data.size = payload.sizeIn || payload.sizeOut;
+        data.side = payload.side?.toLowerCase();
+        break;
+    }
+    return data;
+  }
+};
+function createPolymarketRTDSService(config) {
+  return new PolymarketRTDSService(config);
+}
+var DEFAULT_OSIRIS_RTDS_URL = "wss://rtds.osirislabs.xyz";
+var OsirisRTDSService = class {
+  ws = null;
+  config;
+  isConnected = false;
+  reconnectAttempts = 0;
+  reconnectTimeout = null;
+  pingInterval = null;
+  isIntentionallyClosed = false;
+  activeTopics = /* @__PURE__ */ new Set();
+  // Reconnection settings
+  maxReconnectAttempts;
+  baseReconnectDelay;
+  maxReconnectDelay;
+  pingIntervalMs;
+  url;
+  constructor(config) {
+    this.config = config;
+    this.maxReconnectAttempts = config.reconnect?.maxAttempts ?? 10;
+    this.baseReconnectDelay = config.reconnect?.delayMs ?? 1e3;
+    this.maxReconnectDelay = config.reconnect?.maxDelayMs ?? 3e4;
+    this.pingIntervalMs = config.pingIntervalMs ?? 3e4;
+    this.url = config.url || DEFAULT_OSIRIS_RTDS_URL;
+  }
+  /**
+   * Connect to the Osiris Pub/Sub WebSocket
+   */
+  connect() {
+    if (this.isConnected) {
+      this.config.logger.warning("OsirisRTDS: Already connected");
+      return;
+    }
+    this.isIntentionallyClosed = false;
+    this.config.logger.info(`OsirisRTDS: Connecting to ${this.url}...`);
+    try {
+      this.ws = new WebSocket(this.url);
+      this.ws.on("open", () => {
+        this.isConnected = true;
+        this.reconnectAttempts = 0;
+        this.config.logger.info("OsirisRTDS: Connected");
+        this.startPingInterval();
+        this.config.onConnect?.();
+      });
+      this.ws.on("message", (data) => {
+        this.handleMessage(data);
+      });
+      this.ws.on("error", (error) => {
+        this.config.logger.error(`OsirisRTDS: Error - ${error.message}`);
+        this.config.onError?.(error);
+      });
+      this.ws.on("close", (code, reason) => {
+        this.isConnected = false;
+        this.stopPingInterval();
+        const reasonStr = reason.toString() || "none";
+        this.config.logger.info(`OsirisRTDS: Disconnected (code: ${code}, reason: ${reasonStr})`);
+        this.config.onDisconnect?.();
+        if (!this.isIntentionallyClosed) {
+          this.attemptReconnect();
+        }
+      });
+    } catch (error) {
+      this.config.logger.error(`OsirisRTDS: Connection failed - ${error.message}`);
+      if (!this.isIntentionallyClosed) {
+        this.attemptReconnect();
+      }
+    }
+  }
+  /**
+   * Disconnect from the Osiris Pub/Sub WebSocket
+   */
+  disconnect() {
+    this.isIntentionallyClosed = true;
+    this.stopPingInterval();
+    if (this.reconnectTimeout) {
+      clearTimeout(this.reconnectTimeout);
+      this.reconnectTimeout = null;
+    }
+    if (this.ws) {
+      this.config.logger.info("OsirisRTDS: Disconnecting...");
+      try {
+        if (this.activeTopics.size > 0) {
+          this.unsubscribeFromTopics(Array.from(this.activeTopics));
+        }
+        this.ws.close(1e3, "Intentional close");
+      } catch {
+      }
+      this.ws = null;
+    }
+    this.isConnected = false;
+    this.activeTopics.clear();
+  }
+  /**
+   * Check if connected
+   */
+  isActive() {
+    return this.isConnected;
+  }
+  /**
+   * Subscribe to events
+   */
+  subscribe(subscriptions) {
+    if (!this.ws || !this.isConnected) {
+      this.config.logger.warning("OsirisRTDS: Cannot subscribe - not connected");
+      return;
+    }
+    const { topics, filters } = this.mapToOsirisSubscriptions(subscriptions);
+    if (topics.length === 0) {
+      this.config.logger.warning("OsirisRTDS: No valid topics to subscribe");
+      return;
+    }
+    const message = {
+      action: "subscribe",
+      topics,
+      ...Object.keys(filters).length > 0 ? { filters } : {}
+    };
+    try {
+      this.ws.send(JSON.stringify(message));
+      topics.forEach((t) => this.activeTopics.add(t));
+      this.config.logger.info(`OsirisRTDS: Subscribing to ${topics.join(", ")}`);
+    } catch (error) {
+      this.config.logger.error(`OsirisRTDS: Failed to subscribe - ${error.message}`);
+    }
+  }
+  /**
+   * Unsubscribe from topics
+   */
+  unsubscribe(subscriptions) {
+    if (!this.ws || !this.isConnected) {
+      return;
+    }
+    const { topics } = this.mapToOsirisSubscriptions(subscriptions);
+    this.unsubscribeFromTopics(topics);
+  }
+  /**
+   * Unsubscribe from topics by name
+   */
+  unsubscribeFromTopics(topics) {
+    if (topics.length === 0) return;
+    const message = {
+      action: "unsubscribe",
+      topics
+    };
+    try {
+      this.ws?.send(JSON.stringify(message));
+      topics.forEach((t) => this.activeTopics.delete(t));
+      this.config.logger.info(`OsirisRTDS: Unsubscribed from ${topics.join(", ")}`);
+    } catch {
+    }
+  }
+  /**
+   * Send ping to keep connection alive
+   */
+  ping() {
+    if (this.ws && this.isConnected) {
+      try {
+        this.ws.send(JSON.stringify({ action: "ping" }));
+      } catch {
+      }
+    }
+  }
+  /**
+   * Map SDK subscriptions to Osiris Pub/Sub format
+   */
+  mapToOsirisSubscriptions(subscriptions) {
+    const topics = [];
+    const filters = {};
+    for (const sub of subscriptions) {
+      const topic = this.mapSubscriptionToTopic(sub);
+      if (topic) {
+        topics.push(topic);
+        if (sub.conditions) {
+          filters[topic] = sub.conditions;
+        }
+      }
+    }
+    return { topics, filters };
+  }
+  /**
+   * Map SDK subscription to Osiris topic string
+   */
+  mapSubscriptionToTopic(sub) {
+    if (isMarketSubscription(sub)) {
+      return sub.market ? `market:${sub.market}` : null;
+    }
+    if (isWalletSubscription(sub)) {
+      return sub.wallet ? `wallet:${sub.wallet.toLowerCase()}` : null;
+    }
+    if (isOpportunitySubscription(sub)) {
+      return `opps:${sub.filter || "all"}`;
+    }
+    if (isCustomSubscription(sub)) {
+      return sub.topic || null;
+    }
+    return null;
+  }
+  /**
+   * Start ping interval
+   */
+  startPingInterval() {
+    this.stopPingInterval();
+    this.pingInterval = setInterval(() => this.ping(), this.pingIntervalMs);
+  }
+  /**
+   * Stop ping interval
+   */
+  stopPingInterval() {
+    if (this.pingInterval) {
+      clearInterval(this.pingInterval);
+      this.pingInterval = null;
+    }
+  }
+  /**
+   * Attempt reconnection with exponential backoff
+   */
+  attemptReconnect() {
+    if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+      this.config.logger.error(
+        `OsirisRTDS: Max reconnection attempts (${this.maxReconnectAttempts}) reached`
+      );
+      return;
+    }
+    this.reconnectAttempts++;
+    const delay = Math.min(
+      this.baseReconnectDelay * Math.pow(2, this.reconnectAttempts - 1) + Math.random() * 1e3,
+      this.maxReconnectDelay
+    );
+    this.config.logger.info(
+      `OsirisRTDS: Reconnecting in ${Math.round(delay)}ms (attempt ${this.reconnectAttempts}/${this.maxReconnectAttempts})`
+    );
+    this.reconnectTimeout = setTimeout(() => {
+      this.reconnectTimeout = null;
+      this.connect();
+    }, delay);
+  }
+  /**
+   * Handle incoming WebSocket messages
+   */
+  handleMessage(data) {
+    try {
+      const rawData = typeof data === "string" ? data : data.toString();
+      if (!rawData.trim()) return;
+      let message;
+      try {
+        message = JSON.parse(rawData);
+      } catch {
+        this.config.logger.warning(`OsirisRTDS: Non-JSON message received`);
+        return;
+      }
+      switch (message.type) {
+        case "connected":
+          this.config.logger.info(`OsirisRTDS: ${message.message}`);
+          return;
+        case "subscribe.result":
+          if (message.success) {
+            this.config.logger.info(
+              `OsirisRTDS: Subscribed to ${message.subscribed?.join(", ")}`
+            );
+          } else {
+            this.config.logger.error(
+              `OsirisRTDS: Subscription failed - ${message.errors?.join(", ")}`
+            );
+          }
+          return;
+        case "error":
+          this.config.logger.error(`OsirisRTDS: Server error - ${message.error}`);
+          return;
+        case "pong":
+          return;
+      }
+      const event = this.convertToStrategyEvent(message);
+      if (event) {
+        this.config.onEvent(event);
+      }
+    } catch (error) {
+      this.config.logger.error(`OsirisRTDS: Error processing message - ${error.message}`);
+    }
+  }
+  /**
+   * Convert Osiris message to StrategyEvent
+   */
+  convertToStrategyEvent(message) {
+    const timestamp = message.ts || Date.now();
+    switch (message.type) {
+      case "market.analysis":
+        return {
+          type: "price",
+          // Market analysis treated as price/market update
+          market: message.slug,
+          timestamp,
+          data: {
+            ...message.data,
+            raw: message
+          }
+        };
+      case "wallet.analysis":
+        return {
+          type: "wallet",
+          wallet: message.address,
+          timestamp,
+          data: {
+            ...message.data,
+            raw: message
+          }
+        };
+      case "opportunity":
+        return {
+          type: "opportunity",
+          market: message.slug,
+          timestamp,
+          data: {
+            ...message.data,
+            raw: message
+          }
+        };
+      default:
+        return null;
+    }
+  }
+};
+function createOsirisRTDSService(config) {
+  return new OsirisRTDSService(config);
+}
+
+// src/rtds/unified-rtds.service.ts
+var UnifiedRTDSService = class {
+  config;
+  polymarketService = null;
+  osirisService = null;
+  polymarketConnected = false;
+  osirisConnected = false;
+  constructor(config) {
+    this.config = config;
+    this.initializeServices();
+  }
+  /**
+   * Initialize the underlying services based on configuration
+   */
+  initializeServices() {
+    if (this.config.polymarket?.enabled !== false) {
+      this.polymarketService = new PolymarketRTDSService({
+        logger: this.config.logger,
+        onEvent: this.config.onEvent,
+        onError: this.config.onError,
+        onConnect: () => {
+          this.polymarketConnected = true;
+          this.checkAllConnected();
+        },
+        onDisconnect: () => {
+          this.polymarketConnected = false;
+          this.checkAnyDisconnected();
+        },
+        clobAuth: this.config.polymarket?.clobAuth
+      });
+    }
+    if (this.config.osiris?.enabled !== false) {
+      this.osirisService = new OsirisRTDSService({
+        logger: this.config.logger,
+        onEvent: this.config.onEvent,
+        onError: this.config.onError,
+        onConnect: () => {
+          this.osirisConnected = true;
+          this.checkAllConnected();
+        },
+        onDisconnect: () => {
+          this.osirisConnected = false;
+          this.checkAnyDisconnected();
+        },
+        url: this.config.osiris?.url || DEFAULT_OSIRIS_RTDS_URL,
+        pingIntervalMs: this.config.osiris?.pingIntervalMs,
+        reconnect: this.config.reconnect
+      });
+    }
+  }
+  /**
+   * Connect to all enabled services
+   */
+  connect() {
+    this.config.logger.info("UnifiedRTDS: Connecting to enabled services...");
+    if (this.polymarketService) {
+      this.polymarketService.connect();
+    }
+    if (this.osirisService) {
+      this.osirisService.connect();
+    }
+  }
+  /**
+   * Disconnect from all services
+   */
+  disconnect() {
+    this.config.logger.info("UnifiedRTDS: Disconnecting from all services...");
+    if (this.polymarketService) {
+      this.polymarketService.disconnect();
+    }
+    if (this.osirisService) {
+      this.osirisService.disconnect();
+    }
+  }
+  /**
+   * Check if connected to at least one service
+   */
+  isActive() {
+    return (this.polymarketService?.isActive() ?? false) || (this.osirisService?.isActive() ?? false);
+  }
+  /**
+   * Get connection status for each service
+   */
+  getStatus() {
+    return {
+      polymarket: {
+        enabled: this.polymarketService !== null,
+        connected: this.polymarketConnected
+      },
+      osiris: {
+        enabled: this.osirisService !== null,
+        connected: this.osirisConnected
+      }
+    };
+  }
+  /**
+   * Subscribe to events
+   * Automatically routes subscriptions to the appropriate backend
+   */
+  subscribe(subscriptions) {
+    const { polymarketSubs, osirisSubs } = this.routeSubscriptions(subscriptions);
+    if (polymarketSubs.length > 0) {
+      if (this.polymarketService) {
+        this.polymarketService.subscribe(polymarketSubs);
+      } else {
+        this.config.logger.warning(
+          "UnifiedRTDS: Polymarket subscriptions requested but service not enabled"
+        );
+      }
+    }
+    if (osirisSubs.length > 0) {
+      if (this.osirisService) {
+        this.osirisService.subscribe(osirisSubs);
+      } else {
+        this.config.logger.warning(
+          "UnifiedRTDS: Osiris subscriptions requested but service not enabled"
+        );
+      }
+    }
+  }
+  /**
+   * Unsubscribe from events
+   */
+  unsubscribe(subscriptions) {
+    const { polymarketSubs, osirisSubs } = this.routeSubscriptions(subscriptions);
+    if (polymarketSubs.length > 0 && this.polymarketService) {
+      this.polymarketService.unsubscribe(polymarketSubs);
+    }
+    if (osirisSubs.length > 0 && this.osirisService) {
+      this.osirisService.unsubscribe(osirisSubs);
+    }
+  }
+  /**
+   * Route subscriptions to appropriate backends based on type and eventSource
+   */
+  routeSubscriptions(subscriptions) {
+    const polymarketSubs = [];
+    const osirisSubs = [];
+    for (const sub of subscriptions) {
+      if (sub.eventSource === "polymarket") {
+        polymarketSubs.push(sub);
+        continue;
+      }
+      if (sub.eventSource === "osiris") {
+        osirisSubs.push(sub);
+        continue;
+      }
+      if (isPolymarketSubscription(sub)) {
+        polymarketSubs.push(sub);
+      } else if (isOsirisSubscription(sub)) {
+        osirisSubs.push(sub);
+      } else if (isMarketSubscription(sub)) {
+        polymarketSubs.push(sub);
+      } else if (isCustomSubscription(sub)) {
+        const topic = sub.topic;
+        if (topic.startsWith("market:") || topic.startsWith("wallet:") || topic.startsWith("opps:")) {
+          osirisSubs.push(sub);
+        } else {
+          polymarketSubs.push(sub);
+        }
+      } else {
+        polymarketSubs.push(sub);
+      }
+    }
+    return { polymarketSubs, osirisSubs };
+  }
+  /**
+   * Check if all enabled services are connected
+   */
+  checkAllConnected() {
+    const polymarketOk = !this.polymarketService || this.polymarketConnected;
+    const osirisOk = !this.osirisService || this.osirisConnected;
+    if (polymarketOk && osirisOk) {
+      this.config.onConnect?.();
+    }
+  }
+  /**
+   * Check if any service disconnected
+   */
+  checkAnyDisconnected() {
+    if (!this.polymarketConnected && !this.osirisConnected) {
+      this.config.onDisconnect?.();
+    }
+  }
+};
+function createUnifiedRTDSService(config) {
+  return new UnifiedRTDSService(config);
 }
 var CHAIN_MAP = {
   "evm:eip155:1": mainnet,
@@ -2190,6 +3724,6 @@ var Signer = class {
   }
 };
 
-export { EventRunner, HyperliquidClient, MemoryStateManager, OsirisSigner, PolymarketClient, PrivateKeySigner, RedisStateManager, Signer, StrategyEngine, createConsoleLogger, createEventRunner, createOsirisContext, createStrategyEngine, isEventBasedStrategy, isTickBasedStrategy, runStrategy, validateStrategy };
+export { DEFAULT_OSIRIS_RTDS_URL, HyperliquidClient, MemoryStateManager, OsirisEventRunner, OsirisRTDSService, OsirisSigner, PolymarketClient, PolymarketEventRunner, PolymarketRTDSService, PrivateKeySigner, RedisStateManager, Signer, StrategyEngine, UnifiedRTDSService, createConsoleLogger, createEventRunner, createOsirisContext, createOsirisRTDSService, createPolymarketEventRunner, createPolymarketRTDSService, createStrategyEngine, createUnifiedRTDSService, isActivitySubscription, isClobMarketSubscription, isClobUserSubscription, isCommentsSubscription, isCryptoPricesSubscription, isCustomSubscription, isEventBasedStrategy, isMarketSubscription, isOpportunitySubscription, isOsirisSubscription, isPolymarketSubscription, isRfqSubscription, isTickBasedStrategy, isWalletSubscription, runStrategy, validateStrategy };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map