@pear-protocol/exchanges-sdk 0.0.10 → 0.0.12

package/README.md

@@ -1,45 +1,40 @@
-# @backend/exchanges-sdk
+# @pear-protocol/exchanges-sdk
 
-Unified SDK for connecting to cryptocurrency derivative exchanges. Provides real-time account state tracking including balances, positions, and leverage management through a single, exchange-agnostic interface.
+Unified SDK for connecting to cryptocurrency derivative exchanges. Provides real-time account state tracking including balances, positions, and leverage management through a single, exchange-agnostic interface with automatic WebSocket streaming and credential resolution.
 
 ## Supported Exchanges
 
 | Exchange | Connector Name | Market Type |
 |----------|---------------|-------------|
-| Binance | `binanceusdm` | USDM Futures |
+| Binance | `binance` | USDM Futures |
 | Bybit | `bybit` | Linear Perpetuals |
 | Hyperliquid | `hyperliquid` | Perpetuals |
 
 ## Installation
 
-```json
-{
-  "dependencies": {
-    "@backend/exchanges-sdk": "workspace:*"
-  }
-}
+```bash
+npm install @pear-protocol/exchanges-sdk
 ```
 
-Requires `@pear-protocol/core-sdk` and `@backend/shared` as peer dependencies.
-
 ## Quick Start
 
 ```typescript
 import PearSDK from '@pear-protocol/core-sdk';
-import { ExchangesSDK } from '@backend/exchanges-sdk';
+import { ExchangesSDK } from '@pear-protocol/exchanges-sdk';
 
 const sdk = new PearSDK({ /* ... */ });
 const exchanges = new ExchangesSDK({ sdk });
 
 await exchanges.account.connect(tradeAccountId, 'binanceusdm');
 
+// Track balance and positions
 const balanceTracker = exchanges.account.trackBalance((balance) => {
-  console.log(balance.totalEquity);
+  console.log(balance.totalEquity, balance.unrealizedPnl);
 });
 
 const positionsTracker = exchanges.account.trackPositions((positions) => {
   for (const pos of positions) {
-    console.log(pos.symbol, pos.side, pos.size);
+    console.log(pos.symbol, pos.side, pos.size, pos.entryPrice);
   }
 });
 
@@ -61,12 +56,20 @@ const exchanges = new ExchangesSDK({ sdk });
 const exchanges = new ExchangesSDK({ sdk, demo: true });
 ```
 
+The `ExchangesSDK` exposes three top-level modules:
+
+| Module | Description |
+|--------|-------------|
+| `exchanges.account` | Account connection, balance/position tracking, leverage management |
+| `exchanges.credentials` | Exchange API credential fetching and caching |
+| `exchanges.sdk` | Reference to the underlying `PearSDK` instance |
+
 ### Connecting to an Exchange
 
-Credentials are fetched automatically from the backend when you call `connect`.
+Credentials are fetched automatically from the backend when you call `connect`. One exchange connection is active at a time.
 
 ```typescript
-await exchanges.account.connect(tradeAccountId, 'binanceusdm');
+await exchanges.account.connect(tradeAccountId, 'binance');
 await exchanges.account.connect(tradeAccountId, 'bybit');
 await exchanges.account.connect(tradeAccountId, 'hyperliquid');
 ```
@@ -75,12 +78,12 @@ Check connection status:
 
 ```typescript
 exchanges.account.isConnected;    // WebSocket is active
-exchanges.account.isInitialized;  // First state snapshot received
+exchanges.account.isInitialized;  // first state snapshot received
 ```
 
 ### Tracking Balance
 
-Subscribe to real-time balance updates. The callback fires on every balance change.
+Subscribe to real-time balance updates. The callback fires on every balance change from the exchange.
 
 ```typescript
 const tracker = exchanges.account.trackBalance((balance) => {
@@ -88,6 +91,8 @@ const tracker = exchanges.account.trackBalance((balance) => {
   balance.walletBalance;     // wallet balance excluding unrealized PnL
   balance.unrealizedPnl;     // total unrealized PnL
   balance.availableToTrade;  // available margin for new trades
+  balance.initialMarginUsed; // margin used by open positions
+  balance.maintenanceMargin; // maintenance margin requirement
   balance.marginRatio;       // current margin ratio
 
   // Per-asset breakdown
@@ -115,13 +120,13 @@ Subscribe to real-time position updates. The callback fires with the full list o
 ```typescript
 const tracker = exchanges.account.trackPositions((positions) => {
   for (const pos of positions) {
-    pos.symbol;          // "BTCUSDT"
-    pos.side;            // "long" | "short" | "both"
-    pos.size;            // "0.5"
-    pos.entryPrice;      // "65000.00"
-    pos.unrealizedPnl;   // "120.50"
-    pos.leverage;        // "10"
-    pos.marginType;      // "cross" | "isolated"
+    pos.symbol;           // "BTCUSDT"
+    pos.side;             // "long" | "short" | "both"
+    pos.size;             // "0.5"
+    pos.entryPrice;       // "65000.00"
+    pos.unrealizedPnl;    // "120.50"
+    pos.leverage;         // "10"
+    pos.marginType;       // "cross" | "isolated"
     pos.liquidationPrice; // "58000.00" or null
   }
 });
@@ -130,15 +135,17 @@ const current = tracker.get();
 tracker.untrack();
 ```
 
+Positions with a size of `"0"` are automatically removed from the tracked state.
+
 ### Tracking a Specific Asset
 
 Retrieve leverage, margin type, and trade size constraints for a specific coin. Useful when preparing to place a trade.
 
 ```typescript
 const tracker = exchanges.account.trackAsset('ETH', (info) => {
-  info.coin;             // "ETH"
-  info.leverage;         // "20"
-  info.marginType;       // "cross" | "isolated"
+  info.coin;        // "ETH"
+  info.leverage;    // "20"
+  info.marginType;  // "cross" | "isolated"
 });
 
 const current = tracker.get();
@@ -148,8 +155,6 @@ tracker.untrack();
 ### Managing Leverage
 
 ```typescript
-await exchanges.account.setLeverage('BTCUSDT', '10');
-
 // Read cached leverage (returns null if not yet fetched)
 const leverage = exchanges.account.getLeverage('BTCUSDT');
 ```
@@ -161,16 +166,35 @@ Access a read-only snapshot of the complete account state at any time.
 ```typescript
 const state = exchanges.account.getState();
 if (state) {
-  state.balance;          // latest balance or null
-  state.positions;        // Map of all open positions
-  state.leverageSettings; // Map of symbol to leverage
-  state.trackedAssets;    // Map of coin to asset info
+  state.balance;          // latest AccountBalance or null
+  state.positions;        // Map<"SYMBOL:side", AccountPosition>
+  state.leverageSettings; // Map<symbol, leverage>
+  state.trackedAssets;    // Map<coin, TrackedAssetInfo>
   state.lastUpdated;      // timestamp of last update
   state.initialized;      // true after first snapshot
 }
 ```
 
-### Disconnecting
+### Credential Management
+
+Credentials are resolved automatically on `connect`, but you can manage them directly:
+
+```typescript
+// Fetch credentials from the backend
+const creds = await exchanges.credentials.fetch(tradeAccountId);
+
+// Get cached credentials (null if not fetched)
+const cached = exchanges.credentials.get(tradeAccountId);
+
+// Get from cache or fetch if missing
+const creds = await exchanges.credentials.getOrFetch(tradeAccountId);
+
+// Clear cached credentials
+exchanges.credentials.clear(tradeAccountId); // specific account
+exchanges.credentials.clear();               // all accounts
+```
+
+### Cleanup
 
 ```typescript
 // Disconnect but keep credentials cached for reconnection
@@ -180,10 +204,3 @@ exchanges.account.disconnect();
 exchanges.destroy();
 ```
 
-## Behavior Notes
-
-- The WebSocket connection starts lazily when the first tracker is registered and stops when all trackers are removed.
-- On unexpected disconnection, the SDK reconnects automatically with exponential backoff (1s to 30s).
-- Reconnection is suppressed after explicit `disconnect()` or `destroy()` calls.
-- Credentials are held in memory only and never persisted to disk.
-- All numeric values (balances, sizes, prices, PnL) are returned as strings to preserve decimal precision.

package/dist/account/account-manager.d.ts

@@ -1,15 +1,15 @@
 import PearSDK from '@pear-protocol/core-sdk';
 import { Connector } from '@pear-protocol/types';
 import { Credentials } from '../credentials.js';
-import { BalanceCallback, Tracker, AccountBalance, PositionsCallback, AccountPosition, TrackedAssetCallback, TrackedAssetInfo, ExchangeState } from './types.js';
+import { B as BalanceCallback, i as Tracker, a as AccountBalance, P as PositionsCallback, c as AccountPosition, T as TrackedAssetCallback, h as TrackedAssetInfo } from '../types-D2dbAtin.js';
+import './exchanges/bybit/types.js';
+import './exchanges/hyperliquid/types.js';
 
 declare class AccountManager {
     private credentials;
     private sdk;
     private demo;
     private activeAccount;
-    private pendingExchange;
-    private pendingTradeAccountId;
     private balanceListeners;
     private positionListeners;
     private assetListeners;
@@ -18,17 +18,11 @@ declare class AccountManager {
     trackBalance(cb: BalanceCallback): Tracker<AccountBalance | null>;
     trackPositions(cb: PositionsCallback): Tracker<AccountPosition[]>;
     trackAsset(coin: string, cb: TrackedAssetCallback): Tracker<TrackedAssetInfo | null>;
-    setLeverage(symbol: string, leverage: string): Promise<void>;
     getLeverage(symbol: string): string | null;
-    getState(): Readonly<ExchangeState> | null;
-    disconnect(): void;
-    destroy(): void;
+    disconnect(): Promise<void>;
+    destroy(): Promise<void>;
     get isConnected(): boolean;
     get isInitialized(): boolean;
-    private get hasListeners();
-    private disconnectWs;
-    private maybeDisconnectWs;
-    private ensureWsStarted;
     private resolveCredentials;
     private startWs;
 }

package/dist/account/account-manager.js

@@ -5,8 +5,6 @@ class AccountManager {
   sdk;
   demo;
   activeAccount = null;
-  pendingExchange = null;
-  pendingTradeAccountId = null;
   balanceListeners = /* @__PURE__ */ new Map();
   positionListeners = /* @__PURE__ */ new Map();
   assetListeners = /* @__PURE__ */ new Map();
@@ -16,28 +14,21 @@ class AccountManager {
     this.demo = demo;
   }
   async connect(tradeAccountId, exchange) {
+    await this.disconnect();
     const creds = await this.resolveCredentials(tradeAccountId, exchange);
-    this.disconnectWs();
-    this.pendingTradeAccountId = tradeAccountId;
-    this.pendingExchange = exchange;
-    if (this.hasListeners) {
-      await this.startWs(exchange, creds);
-    }
+    await this.startWs(exchange, creds);
   }
   trackBalance(cb) {
     const id = Math.random().toString(36).slice(2);
     this.balanceListeners.set(id, cb);
     if (this.activeAccount) {
-      this.activeAccount.trackBalance(cb);
-    } else {
-      this.ensureWsStarted();
+      this.activeAccount.trackBalance(cb, id);
     }
     return {
       get: () => this.activeAccount?.getBalance() ?? null,
       untrack: () => {
         this.balanceListeners.delete(id);
         this.activeAccount?.untrackBalance(id);
-        this.maybeDisconnectWs();
       }
     };
   }
@@ -45,16 +36,13 @@ class AccountManager {
     const id = Math.random().toString(36).slice(2);
     this.positionListeners.set(id, cb);
     if (this.activeAccount) {
-      this.activeAccount.trackPositions(cb);
-    } else {
-      this.ensureWsStarted();
+      this.activeAccount.trackPositions(cb, id);
     }
     return {
       get: () => this.activeAccount?.getPositions() ?? [],
       untrack: () => {
         this.positionListeners.delete(id);
         this.activeAccount?.untrackPositions(id);
-        this.maybeDisconnectWs();
       }
     };
   }
@@ -62,39 +50,30 @@ class AccountManager {
     const id = Math.random().toString(36).slice(2);
     this.assetListeners.set(id, { coin, cb });
     if (this.activeAccount) {
-      this.activeAccount.trackAsset(coin, cb);
-    } else {
-      this.ensureWsStarted();
+      this.activeAccount.trackAsset(coin, cb, id);
     }
     return {
       get: () => this.activeAccount?.getTrackedAsset(coin) ?? null,
       untrack: () => {
         this.assetListeners.delete(id);
         this.activeAccount?.untrackAsset(id);
-        this.maybeDisconnectWs();
       }
     };
   }
-  async setLeverage(symbol, leverage) {
-    if (!this.activeAccount) throw new Error("No active account");
-    await this.activeAccount.setLeverage(symbol, leverage);
-  }
   getLeverage(symbol) {
     return this.activeAccount?.getLeverage(symbol) ?? null;
   }
-  getState() {
-    return this.activeAccount?.getState() ?? null;
-  }
-  disconnect() {
-    this.disconnectWs();
-    this.pendingExchange = null;
-    this.pendingTradeAccountId = null;
+  async disconnect() {
+    if (this.activeAccount) {
+      await this.activeAccount.disconnect();
+      this.activeAccount = null;
+    }
     this.balanceListeners.clear();
     this.positionListeners.clear();
     this.assetListeners.clear();
   }
-  destroy() {
-    this.disconnect();
+  async destroy() {
+    await this.disconnect();
     this.credentials.clear();
   }
   get isConnected() {
@@ -103,26 +82,6 @@ class AccountManager {
   get isInitialized() {
     return this.activeAccount?.isInitialized ?? false;
   }
-  get hasListeners() {
-    return this.balanceListeners.size > 0 || this.positionListeners.size > 0 || this.assetListeners.size > 0;
-  }
-  disconnectWs() {
-    if (this.activeAccount) {
-      this.activeAccount.destroy();
-      this.activeAccount = null;
-    }
-  }
-  maybeDisconnectWs() {
-    if (!this.hasListeners) {
-      this.disconnectWs();
-    }
-  }
-  ensureWsStarted() {
-    if (this.activeAccount || !this.pendingExchange || !this.pendingTradeAccountId) return;
-    const exchange = this.pendingExchange;
-    const tradeAccountId = this.pendingTradeAccountId;
-    this.resolveCredentials(tradeAccountId, exchange).then((creds) => this.startWs(exchange, creds)).catch((err) => console.warn("[AccountManager] Failed to start WS:", err));
-  }
   async resolveCredentials(tradeAccountId, exchange) {
     const creds = await this.credentials.getOrFetch(tradeAccountId);
     if (exchange === "hyperliquid") {
@@ -134,7 +93,10 @@ class AccountManager {
       if (!account.exchangeIdentifier) {
         throw new Error(`Trade account ${tradeAccountId} has no Hyperliquid address`);
       }
-      return { ...creds, address: account.exchangeIdentifier };
+      return {
+        ...creds,
+        address: account.exchangeIdentifier
+      };
     }
     return creds;
   }
@@ -142,14 +104,14 @@ class AccountManager {
     const account = new ExchangeAccount({ exchange, demo: this.demo });
     await account.connect(creds);
     this.activeAccount = account;
-    for (const cb of this.balanceListeners.values()) {
-      account.trackBalance(cb);
+    for (const [id, cb] of this.balanceListeners.entries()) {
+      account.trackBalance(cb, id);
     }
-    for (const cb of this.positionListeners.values()) {
-      account.trackPositions(cb);
+    for (const [id, cb] of this.positionListeners.entries()) {
+      account.trackPositions(cb, id);
     }
-    for (const { coin, cb } of this.assetListeners.values()) {
-      account.trackAsset(coin, cb);
+    for (const [id, { coin, cb }] of this.assetListeners.entries()) {
+      account.trackAsset(coin, cb, id);
     }
   }
 }

package/dist/account/exchange-account.d.ts

@@ -1,5 +1,7 @@
-import { Connector } from '@pear-protocol/types';
-import { AccountConfig, SupportedCredentials, BalanceCallback, AccountBalance, PositionsCallback, AccountPosition, TrackedAssetCallback, TrackedAssetInfo, ExchangeState } from './types.js';
+import { b as AccountConfig, g as SupportedCredentials, B as BalanceCallback, a as AccountBalance, P as PositionsCallback, c as AccountPosition, T as TrackedAssetCallback, h as TrackedAssetInfo } from '../types-D2dbAtin.js';
+import '@pear-protocol/types';
+import './exchanges/bybit/types.js';
+import './exchanges/hyperliquid/types.js';
 
 declare class ExchangeAccount {
     private exchange;
@@ -12,24 +14,20 @@ declare class ExchangeAccount {
     private onAuthError?;
     constructor(config: AccountConfig);
     connect(credentials: SupportedCredentials): Promise<void>;
-    disconnect(): void;
-    destroy(): void;
+    disconnect(): Promise<void>;
     get isConnected(): boolean;
     get isInitialized(): boolean;
     get hasListeners(): boolean;
-    trackBalance(cb: BalanceCallback): string;
+    trackBalance(cb: BalanceCallback, id?: string): string;
     untrackBalance(id: string): void;
     getBalance(): AccountBalance | null;
-    trackPositions(cb: PositionsCallback): string;
+    trackPositions(cb: PositionsCallback, id?: string): string;
     untrackPositions(id: string): void;
     getPositions(): AccountPosition[];
-    trackAsset(coin: string, cb: TrackedAssetCallback): string;
+    trackAsset(coin: string, cb: TrackedAssetCallback, id: string): string;
     untrackAsset(id: string): void;
     getTrackedAsset(coin: string): TrackedAssetInfo | null;
     getLeverage(symbol: string): string | null;
-    setLeverage(symbol: string, leverage: string): Promise<void>;
-    getState(): Readonly<ExchangeState>;
-    getExchange(): Connector;
     private applyStateUpdate;
 }
 

package/dist/account/exchange-account.js

@@ -17,32 +17,32 @@ class ExchangeAccount {
     this.state = createEmptyState();
   }
   async connect(credentials) {
-    this.disconnect();
+    await this.disconnect();
     this.state = createEmptyState();
-    this.orchestrator = createOrchestrator(this.exchange, {
-      onError: (error) => {
-        console.warn(`[ExchangeAccount] ${this.exchange} error:`, error.message);
-        if (error.message.includes("auth") || error.message.includes("login")) {
-          this.onAuthError?.();
-        }
+    this.orchestrator = createOrchestrator(
+      this.exchange,
+      {
+        onError: (error) => {
+          console.warn(`[ExchangeAccount] ${this.exchange} error:`, error.message);
+          if (error.message.includes("auth") || error.message.includes("login")) {
+            this.onAuthError?.();
+          }
+        },
+        onStateUpdate: (update) => this.applyStateUpdate(update),
+        demo: this.demo
       },
-      onStateUpdate: (update) => this.applyStateUpdate(update),
-      demo: this.demo
-    });
-    await this.orchestrator.start(credentials);
-  }
-  disconnect() {
-    if (this.orchestrator) {
-      this.orchestrator.stop();
-      this.orchestrator = null;
-    }
+      credentials
+    );
+    await this.orchestrator.start();
   }
-  destroy() {
-    this.disconnect();
+  async disconnect() {
     this.balanceListeners.clear();
     this.positionListeners.clear();
     this.assetListeners.clear();
-    this.state = createEmptyState();
+    if (this.orchestrator) {
+      await this.orchestrator.stop();
+      this.orchestrator = null;
+    }
   }
   get isConnected() {
     return this.orchestrator?.isConnected ?? false;
@@ -53,14 +53,11 @@ class ExchangeAccount {
   get hasListeners() {
     return this.balanceListeners.size > 0 || this.positionListeners.size > 0 || this.assetListeners.size > 0;
   }
-  trackBalance(cb) {
-    const id = Math.random().toString(36).slice(2);
+  trackBalance(cb, id) {
+    id ??= Math.random().toString(36).slice(2);
     this.balanceListeners.set(id, cb);
     if (this.state.balance) {
-      try {
-        cb(this.state.balance);
-      } catch {
-      }
+      cb(this.state.balance);
     }
     return id;
   }
@@ -70,14 +67,11 @@ class ExchangeAccount {
   getBalance() {
     return this.state.balance;
   }
-  trackPositions(cb) {
-    const id = Math.random().toString(36).slice(2);
+  trackPositions(cb, id) {
+    id ??= Math.random().toString(36).slice(2);
     this.positionListeners.set(id, cb);
     if (this.state.initialized) {
-      try {
-        cb(Array.from(this.state.positions.values()));
-      } catch {
-      }
+      cb(Array.from(this.state.positions.values()));
     }
     return id;
   }
@@ -87,16 +81,12 @@ class ExchangeAccount {
   getPositions() {
     return Array.from(this.state.positions.values());
   }
-  trackAsset(coin, cb) {
-    const id = Math.random().toString(36).slice(2);
+  trackAsset(coin, cb, id) {
     this.assetListeners.set(id, { coin, cb });
     this.orchestrator?.trackAsset(coin);
     const existing = this.state.trackedAssets.get(coin);
     if (existing) {
-      try {
-        cb(existing);
-      } catch {
-      }
+      cb(existing);
     }
     return id;
   }
@@ -120,17 +110,6 @@ class ExchangeAccount {
     }
     return null;
   }
-  async setLeverage(symbol, leverage) {
-    if (!this.orchestrator) throw new Error("Not connected");
-    await this.orchestrator.setLeverage(symbol, leverage);
-  }
-  getState() {
-    return this.state;
-  }
-  getExchange() {
-    return this.exchange;
-  }
-  // --- private ---
   applyStateUpdate(update) {
     if (update.balance) {
       this.state.balance = update.balance;
@@ -151,10 +130,7 @@ class ExchangeAccount {
       }
       const positions = Array.from(this.state.positions.values());
       for (const cb of this.positionListeners.values()) {
-        try {
-          cb(positions);
-        } catch {
-        }
+        cb(positions);
       }
     }
     if (update.leverageSettings) {
@@ -167,10 +143,7 @@ class ExchangeAccount {
         this.state.trackedAssets.set(coin, info);
         for (const listener of this.assetListeners.values()) {
           if (listener.coin === coin) {
-            try {
-              listener.cb(info);
-            } catch {
-            }
+            listener.cb(info);
           }
         }
       }

package/dist/account/exchanges/base.d.ts

@@ -1,5 +1,7 @@
-import { SupportedCredentials, StateUpdate } from '../types.js';
+import { S as StateUpdate, g as SupportedCredentials } from '../../types-D2dbAtin.js';
 import '@pear-protocol/types';
+import './bybit/types.js';
+import './hyperliquid/types.js';
 
 type StateUpdateHandler = (update: StateUpdate) => void;
 type ErrorHandler = (error: Error) => void;
@@ -9,41 +11,37 @@ type OrchestratorConfig = {
     demo: boolean;
 };
 interface Orchestrator {
-    start: (credentials: SupportedCredentials) => Promise<void>;
-    stop: () => void;
+    stop: () => Promise<void>;
     isConnected: boolean;
     onAssetTracked: (coin: string) => void;
     onAssetUntracked: (coin: string) => void;
-    setLeverage: (symbol: string, leverage: string) => Promise<void>;
     trackAsset: (coin: string) => void;
     untrackAsset: (coin: string) => boolean;
     getTrackedCoins: () => ReadonlySet<string>;
+    start: () => Promise<void>;
 }
 declare abstract class BaseOrchestrator implements Orchestrator {
     protected onStateUpdate: StateUpdateHandler;
     protected onError: ErrorHandler;
     protected demo: boolean;
     protected credentials: SupportedCredentials | null;
-    protected manualClose: boolean;
-    protected reconnectAttempts: number;
-    protected reconnectTimer: ReturnType<typeof setTimeout> | null;
+    protected stopped: boolean;
     protected trackedCoins: Set<string>;
-    protected startGeneration: number;
-    private starting;
     constructor(config: OrchestratorConfig);
-    abstract start(credentials: SupportedCredentials): Promise<void>;
-    abstract stop(): void;
+    /** Awaitable first-time connection. Errors propagate to caller. */
+    start(): Promise<void>;
+    abstract stop(): Promise<void>;
     abstract get isConnected(): boolean;
     abstract onAssetTracked(coin: string): void;
     abstract onAssetUntracked(coin: string): void;
-    abstract setLeverage(symbol: string, leverage: string): Promise<void>;
+    /** Subclass implements the actual async init (REST fetches, WS connect, etc.) */
+    protected abstract initAsync(): Promise<void>;
+    /** Subclass cleans up connections on stop. */
+    protected abstract cleanupConnections(): void | Promise<void>;
     trackAsset(coin: string): void;
     untrackAsset(coin: string): boolean;
     getTrackedCoins(): ReadonlySet<string>;
     protected canUntrackAsset(_coin: string): boolean;
-    protected scheduleReconnect(): void;
-    protected clearReconnectTimer(): void;
-    private guardedStart;
 }
 
 export { BaseOrchestrator, type Orchestrator, type OrchestratorConfig };