@adaptic/utils 0.0.962 → 0.0.964

package/dist/index.cjs

@@ -2366,7 +2366,9 @@ class AlpacaMarketDataAPI extends require$$0$1.EventEmitter {
             }
         });
         ws.on("close", (code) => {
-            log$l(`${streamType} stream disconnected (code: ${code})`, { type: "warn" });
+            log$l(`${streamType} stream disconnected (code: ${code})`, {
+                type: "warn",
+            });
             if (streamType === "stock") {
                 this.stockWs = null;
             }
@@ -3686,13 +3688,14 @@ class AlpacaTradingAPI {
      * @param side (string) - the side of the order
      * @param trailPercent100 (number) - the trail percent of the order (scale 100, i.e. 0.5 = 0.5%)
      * @param position_intent (string) - the position intent of the order
+     * @returns The created AlpacaOrder with order ID and details
      */
     async createTrailingStop(symbol, qty, side, trailPercent100, position_intent) {
         this.log(`Creating trailing stop ${side.toUpperCase()} ${qty} shares for ${symbol} with trail percent ${trailPercent100}%`, {
             symbol,
         });
         try {
-            await this.makeRequest(`/orders`, "POST", {
+            const order = await this.makeRequest(`/orders`, "POST", {
                 symbol,
                 qty: Math.abs(qty),
                 side,
@@ -3702,6 +3705,8 @@ class AlpacaTradingAPI {
                 trail_percent: trailPercent100, // Already in decimal form (e.g., 4 for 4%)
                 time_in_force: "gtc",
             });
+            this.log(`Trailing stop order created for ${symbol}: orderId=${order.id}, trailPercent=${trailPercent100}%`, { symbol });
+            return order;
         }
         catch (error) {
             this.log(`Error creating trailing stop: ${error}`, {
@@ -3783,6 +3788,7 @@ class AlpacaTradingAPI {
      * Update the trail percent for a trailing stop order
      * @param symbol (string) - the symbol of the order
      * @param trailPercent100 (number) - the trail percent of the order (scale 100, i.e. 0.5 = 0.5%)
+     * @returns The updated/replaced order from Alpaca, or null if no order found or no update needed
      */
     async updateTrailingStop(symbol, trailPercent100) {
         // First get all open orders for this symbol
@@ -3797,7 +3803,7 @@ class AlpacaTradingAPI {
                 type: "error",
                 symbol,
             });
-            return;
+            return null;
         }
         // Check if the trail_percent is already set to the desired value
         const currentTrailPercent = trailingStopOrder.trail_percent
@@ -3810,15 +3816,19 @@ class AlpacaTradingAPI {
             this.log(`Trailing stop for ${symbol} already set to ${trailPercent100}% (current: ${currentTrailPercent}%), skipping update`, {
                 symbol,
             });
-            return;
+            return null;
         }
-        this.log(`Updating trailing stop for ${symbol} from ${currentTrailPercent}% to ${trailPercent100}%`, {
+        const originalOrderId = trailingStopOrder.id;
+        this.log(`Updating trailing stop for ${symbol} from ${currentTrailPercent}% to ${trailPercent100}% (orderId=${originalOrderId})`, {
             symbol,
         });
         try {
-            await this.makeRequest(`/orders/${trailingStopOrder.id}`, "PATCH", {
-                trail: trailPercent100.toString(), // Changed from trail_percent to trail
+            const updatedOrder = await this.makeRequest(`/orders/${trailingStopOrder.id}`, "PATCH", {
+                trail: trailPercent100.toString(),
             });
+            // Log the replacement: Alpaca replaces orders on PATCH, so new ID is returned
+            this.log(`Trailing stop updated for ${symbol}: newOrderId=${updatedOrder.id}, replaces=${updatedOrder.replaces || originalOrderId}`, { symbol });
+            return updatedOrder;
         }
         catch (error) {
             this.log(`Error updating trailing stop: ${error}`, {
@@ -7847,24 +7857,27 @@ const rateLimiters = {
     /**
      * Alpaca API rate limiter
      *
-     * Configured for 200 requests per minute.
+     * Configured for 1000 requests per minute (paid tier).
+     * The token bucket allows burst up to maxTokens, then refills at the steady rate.
      * See: https://alpaca.markets/docs/api-references/trading-api/#rate-limit
      */
     alpaca: new TokenBucketRateLimiter({
-        maxTokens: 200,
-        refillRate: 200 / 60, // 200 requests per 60 seconds (~3.33/sec)
+        maxTokens: 1000,
+        refillRate: 1000 / 60, // 1000 requests per 60 seconds (~16.67/sec)
         label: "alpaca",
         timeoutMs: 60000,
     }),
     /**
      * Massive.com API rate limiter
      *
-     * Configured for 100 requests per second (paid tier — matches Massive.com recommended soft limit).
-     * See: https://massive.com/pricing
+     * Configured generously for paid unlimited tier. The bucket exists only as a
+     * safety net against runaway loops — the 1000 token burst and 500/sec refill
+     * should never be hit under normal operation. If the paid plan truly has no
+     * hard limit, this just prevents accidental self-DDoS.
      */
     massive: new TokenBucketRateLimiter({
-        maxTokens: 100,
-        refillRate: 100, // 100 requests per second (paid tier — matches Massive.com recommended soft limit)
+        maxTokens: 1000,
+        refillRate: 500, // 500 tokens/sec refill — effectively unlimited for paid tier
         label: "massive",
         timeoutMs: 30000,
     }),
@@ -58792,12 +58805,14 @@ async function getPositionSide(client, symbol) {
 async function closePosition(client, symbol, options) {
     // Normalize crypto symbols: Alpaca positions endpoint rejects hyphenated
     // format (e.g., "SOL-USD") but accepts concatenated form (e.g., "SOLUSD").
-    const isCrypto = symbol.includes("/") || symbol.includes("-") ||
+    const isCrypto = symbol.includes("/") ||
+        symbol.includes("-") ||
         /^[A-Z]{2,}USD[TC]?$/i.test(symbol);
-    const normalizedSymbol = isCrypto
-        ? symbol.replace(/[-/]/g, "")
-        : symbol;
-    log(`Closing position for ${normalizedSymbol}`, { type: "info", symbol: normalizedSymbol });
+    const normalizedSymbol = isCrypto ? symbol.replace(/[-/]/g, "") : symbol;
+    log(`Closing position for ${normalizedSymbol}`, {
+        type: "info",
+        symbol: normalizedSymbol,
+    });
     try {
         const sdk = client.getSDK();
         // Build query params for partial closes
@@ -58817,7 +58832,10 @@ async function closePosition(client, symbol, options) {
             });
         }
         else {
-            log(`Closing entire position for ${normalizedSymbol}`, { type: "info", symbol: normalizedSymbol });
+            log(`Closing entire position for ${normalizedSymbol}`, {
+                type: "info",
+                symbol: normalizedSymbol,
+            });
         }
         // Use sendRequest for parameterized close, closePosition for full close
         let order;
@@ -67339,7 +67357,8 @@ const RequireHumanApprovalSchema = objectType({
     closeAllOrdersAndPositions: booleanType().default(true),
     policyMutations: booleanType().default(true),
     advancedModelEscalations: booleanType().default(false),
-}).default({});
+})
+    .default({});
 /**
  * Schema for allowed trading session windows.
  * Controls which market sessions the system may trade during.
@@ -67350,7 +67369,8 @@ const AllowedSessionsSchema = objectType({
     afterHours: booleanType().default(false),
     overnight: booleanType().default(false),
     weekends: booleanType().default(false),
-}).default({});
+})
+    .default({});
 /**
  * Autonomy preferences schema (section 7.1).
  * Governs the level of automated decision-making, human approval gates,
@@ -67374,7 +67394,7 @@ const AutonomyPrefsObjectSchema = objectType({
 });
 const AutonomyPrefsSchema = AutonomyPrefsObjectSchema.default({});
 
-const DirectionSchema = enumType(['long_only', 'long_short', 'market_neutral']);
+const DirectionSchema = enumType(["long_only", "long_short", "market_neutral"]);
 /**
  * Asset universe preferences schema (section 7.2).
  * Defines which instruments, exchanges, sectors, and market segments
@@ -67384,10 +67404,10 @@ const DirectionSchema = enumType(['long_only', 'long_short', 'market_neutral']);
  * for use with `deepPartial()`, which requires a ZodObject (not ZodDefault).
  */
 const AssetUniversePrefsObjectSchema = objectType({
-    equitiesDirection: DirectionSchema.default('long_only'),
-    etfsDirection: enumType(['long_only', 'long_short']).default('long_only'),
-    cryptoDirection: enumType(['long_only', 'long_short']).default('long_only'),
-    optionsDirection: enumType(['long_only', 'long_short']).default('long_only'),
+    equitiesDirection: DirectionSchema.default("long_only"),
+    etfsDirection: enumType(["long_only", "long_short"]).default("long_only"),
+    cryptoDirection: enumType(["long_only", "long_short"]).default("long_only"),
+    optionsDirection: enumType(["long_only", "long_short"]).default("long_only"),
     allowedExchanges: arrayType(stringType()).default([]),
     deniedExchanges: arrayType(stringType()).default([]),
     allowedCountries: arrayType(stringType()).default([]),
@@ -67442,15 +67462,15 @@ const RiskBudgetPrefsObjectSchema = objectType({
     overnightExposureCapPct: numberType().min(0).max(100).default(50),
     weekendExposureCapPct: numberType().min(0).max(100).default(30),
     eventRiskExposureCapPct: numberType().min(0).max(100).default(40),
-    gapRiskSensitivity: enumType(['low', 'medium', 'high']).default('medium'),
+    gapRiskSensitivity: enumType(["low", "medium", "high"]).default("medium"),
     /** Per-trade equity allocation as % of account equity. Replaces legacy AlpacaAccount.tradeAllocationPct. */
     perTradeAllocationPct: numberType().min(0).max(100).default(5),
     /** Per-trade crypto allocation as % of account equity. Replaces legacy AlpacaAccount.cryptoTradeAllocationPct. */
     perTradeCryptoAllocationPct: numberType().min(0).max(100).default(5),
     /** Alpaca day-trading buying power check enforcement. Synced to Alpaca API. */
-    dtbpCheck: enumType(['both', 'entry', 'exit']).default('both'),
+    dtbpCheck: enumType(["both", "entry", "exit"]).default("both"),
     /** Alpaca pattern day trader rule enforcement. Synced to Alpaca API. */
-    pdtCheck: enumType(['both', 'entry', 'exit']).default('both'),
+    pdtCheck: enumType(["both", "entry", "exit"]).default("both"),
     /** Strict PDT enforcement — block all violations without exception. Synced to Alpaca API. */
     ptpNoExceptionEntry: booleanType().default(false),
 });
@@ -67492,14 +67512,21 @@ const SignalConsumptionPrefsObjectSchema = objectType({
     cooldownAfterFailedTradeSeconds: numberType().min(0).default(180),
     duplicateSignalSuppressionWindowSeconds: numberType().min(0).default(300),
     reversalHandlingPolicy: enumType([
-        'ignore_reversal', 'close_only', 'flatten_then_reverse', 'allow_full_reversal',
-    ]).default('close_only'),
+        "ignore_reversal",
+        "close_only",
+        "flatten_then_reverse",
+        "allow_full_reversal",
+    ])
+        .default("close_only"),
     conflictHandlingOpenOrders: enumType([
-        'cancel_conflicting', 'replace_existing', 'keep_existing_skip', 'escalate',
-    ]).default('cancel_conflicting'),
-    conflictHandlingOpposingPosition: enumType([
-        'reduce', 'close', 'flatten_then_reverse', 'hold',
-    ]).default('close'),
+        "cancel_conflicting",
+        "replace_existing",
+        "keep_existing_skip",
+        "escalate",
+    ])
+        .default("cancel_conflicting"),
+    conflictHandlingOpposingPosition: enumType(["reduce", "close", "flatten_then_reverse", "hold"])
+        .default("close"),
     minConvictionDeltaToModify: numberType().min(0).max(100).default(10),
     strategyPriorityRules: arrayType(StrategyPriorityRuleSchema).default([]),
     noTradeWindows: arrayType(NoTradeWindowSchema).default([]),
@@ -67513,7 +67540,13 @@ const SignalConsumptionPrefsObjectSchema = objectType({
 });
 const SignalConsumptionPrefsSchema = SignalConsumptionPrefsObjectSchema.default({});
 
-const OrderTypeEnum = enumType(['market', 'limit', 'stop', 'stop_limit', 'trailing_stop']);
+const OrderTypeEnum = enumType([
+    "market",
+    "limit",
+    "stop",
+    "stop_limit",
+    "trailing_stop",
+]);
 /**
  * Execution preferences schema (section 7.5).
  * Governs order routing behavior including order types, time-in-force,
@@ -67523,11 +67556,14 @@ const OrderTypeEnum = enumType(['market', 'limit', 'stop', 'stop_limit', 'traili
  * for use with `deepPartial()`, which requires a ZodObject (not ZodDefault).
  */
 const ExecutionPrefsObjectSchema = objectType({
-    allowedOrderTypes: arrayType(OrderTypeEnum).default(['market', 'limit', 'stop', 'trailing_stop']),
-    preferredOrderType: OrderTypeEnum.default('limit'),
-    preferredOrderTypeByAssetClass: recordType(stringType(), stringType()).default({ crypto: 'market' }),
-    defaultTimeInForce: enumType(['day', 'gtc', 'ioc', 'fok']).default('day'),
-    executionBias: enumType(['passive', 'neutral', 'aggressive']).default('neutral'),
+    allowedOrderTypes: arrayType(OrderTypeEnum)
+        .default(["market", "limit", "stop", "trailing_stop"]),
+    preferredOrderType: OrderTypeEnum.default("limit"),
+    preferredOrderTypeByAssetClass: recordType(stringType(), stringType())
+        .default({ crypto: "market" }),
+    defaultTimeInForce: enumType(["day", "gtc", "ioc", "fok"]).default("day"),
+    executionBias: enumType(["passive", "neutral", "aggressive"])
+        .default("neutral"),
     maxSlippageTolerancePct: numberType().min(0).max(100).default(1.0),
     priceCollarEnabled: booleanType().default(true),
     priceCollarPct: numberType().min(0).default(2),
@@ -67535,11 +67571,14 @@ const ExecutionPrefsObjectSchema = objectType({
     repriceMaxAttempts: numberType().min(0).default(3),
     repriceIntervalSeconds: numberType().min(0).default(30),
     cancelReplaceTimeoutSeconds: numberType().min(0).default(60),
-    partialFillPolicy: enumType(['accept_partial', 'cancel_remainder', 'replace_to_fill']).default('accept_partial'),
-    sizingMethod: enumType(['notional', 'quantity']).default('notional'),
-    lotRoundingBehavior: enumType(['round_down', 'round_nearest', 'round_up']).default('round_down'),
-    afterHoursExecutionBehavior: enumType(['limit_only', 'no_execution', 'normal']).default('limit_only'),
-    failureBehavior: enumType(['fail_safe', 'fail_open']).default('fail_safe'),
+    partialFillPolicy: enumType(["accept_partial", "cancel_remainder", "replace_to_fill"])
+        .default("accept_partial"),
+    sizingMethod: enumType(["notional", "quantity"]).default("notional"),
+    lotRoundingBehavior: enumType(["round_down", "round_nearest", "round_up"])
+        .default("round_down"),
+    afterHoursExecutionBehavior: enumType(["limit_only", "no_execution", "normal"])
+        .default("limit_only"),
+    failureBehavior: enumType(["fail_safe", "fail_open"]).default("fail_safe"),
 });
 const ExecutionPrefsSchema = ExecutionPrefsObjectSchema.default({});
 
@@ -67557,10 +67596,12 @@ const TrailingStopTighteningRuleSchema = objectType({
  * for use with `deepPartial()`, which requires a ZodObject (not ZodDefault).
  */
 const PositionManagementPrefsObjectSchema = objectType({
-    defaultStopLossMethod: enumType(['fixed_percent', 'atr_based', 'structure_based', 'trailing_stop']).default('trailing_stop'),
+    defaultStopLossMethod: enumType(["fixed_percent", "atr_based", "structure_based", "trailing_stop"])
+        .default("trailing_stop"),
     defaultStopLossPct: numberType().min(0).max(100).default(4),
     atrStopMultiplier: numberType().min(0).default(2),
-    defaultTakeProfitMethod: enumType(['fixed_percent', 'atr_based', 'risk_reward_ratio', 'none']).default('risk_reward_ratio'),
+    defaultTakeProfitMethod: enumType(["fixed_percent", "atr_based", "risk_reward_ratio", "none"])
+        .default("risk_reward_ratio"),
     defaultTakeProfitPct: numberType().min(0).max(100).default(3),
     defaultRiskRewardRatio: numberType().min(0).default(2),
     breakEvenStopEnabled: booleanType().default(true),
@@ -67581,7 +67622,8 @@ const PositionManagementPrefsObjectSchema = objectType({
     addToLosersAllowed: booleanType().default(false),
     stopWideningAllowed: booleanType().default(false),
     trailingStopTighteningEnabled: booleanType().default(true),
-    trailingStopTighteningRules: arrayType(TrailingStopTighteningRuleSchema).default([
+    trailingStopTighteningRules: arrayType(TrailingStopTighteningRuleSchema)
+        .default([
         { profitThresholdPct: 3, newTrailPct: 2.0 },
         { profitThresholdPct: 6, newTrailPct: 1.5 },
         { profitThresholdPct: 10, newTrailPct: 1.0 },
@@ -67620,13 +67662,21 @@ const PortfolioConstructionPrefsObjectSchema = objectType({
     targetAllocationByAssetClass: recordType(stringType(), numberType()).default({}),
     tacticalAllocationBands: recordType(stringType(), TacticalBandSchema).default({}),
     driftThresholdPct: numberType().min(0).max(100).default(5),
-    rebalanceTrigger: enumType(['threshold', 'calendar', 'both']).default('threshold'),
+    rebalanceTrigger: enumType(["threshold", "calendar", "both"])
+        .default("threshold"),
     rebalanceFrequencyDays: numberType().min(0).default(30),
     autonomousRebalancing: booleanType().default(false),
     rebalanceDuringRiskOff: booleanType().default(false),
     maxTurnoverPerRebalancePct: numberType().min(0).max(100).default(20),
-    preferredWeighting: enumType(['equal_weight', 'risk_based', 'conviction_weighted', 'target_allocation']).default('equal_weight'),
-    strategySleeveBudgets: recordType(stringType(), StrategySleeveBudgetSchema).default({}),
+    preferredWeighting: enumType([
+        "equal_weight",
+        "risk_based",
+        "conviction_weighted",
+        "target_allocation",
+    ])
+        .default("equal_weight"),
+    strategySleeveBudgets: recordType(stringType(), StrategySleeveBudgetSchema)
+        .default({}),
     cashTargetPct: numberType().min(0).max(100).default(10),
     defensiveCashEscalationEnabled: booleanType().default(false),
     defensiveCashEscalationRules: arrayType(DefensiveCashRuleSchema).default([]),
@@ -67673,7 +67723,8 @@ const OverlayResponseConfigSchema = objectType({
  * for use with `deepPartial()`, which requires a ZodObject (not ZodDefault).
  */
 const OverlayResponsePrefsObjectSchema = objectType({
-    overlayResponses: recordType(nativeEnumType(exports.OverlayType), OverlayResponseConfigSchema).default({}),
+    overlayResponses: recordType(nativeEnumType(exports.OverlayType), OverlayResponseConfigSchema)
+        .default({}),
 });
 const OverlayResponsePrefsSchema = OverlayResponsePrefsObjectSchema.default({});
 
@@ -67709,14 +67760,16 @@ const ModelPrefsObjectSchema = objectType({
     latencyTargetMs: numberType().min(0).default(5000),
     timeoutMs: numberType().min(0).default(30000),
     maxRetries: numberType().min(0).default(2),
-    toolUsePermissionsByTier: recordType(stringType(), ToolUsePermissionsSchema).default({
+    toolUsePermissionsByTier: recordType(stringType(), ToolUsePermissionsSchema)
+        .default({
         mini: { readTools: true, writeTools: false },
         normal: { readTools: true, writeTools: false },
         advanced: { readTools: true, writeTools: true },
     }),
     memorySummaryCadenceMinutes: numberType().min(0).default(60),
     maxMemorySummariesRetained: numberType().min(0).default(50),
-    excludedProvidersForWorkflows: recordType(stringType(), arrayType(stringType())).default({}),
+    excludedProvidersForWorkflows: recordType(stringType(), arrayType(stringType()))
+        .default({}),
     quantModelWeight: numberType().min(0).max(1).default(0.7),
 });
 const ModelPrefsSchema = ModelPrefsObjectSchema.default({});
@@ -67736,16 +67789,18 @@ const AuditNotificationPrefsObjectSchema = objectType({
     notifyOnPolicyMutation: booleanType().default(true),
     dailySummaryEnabled: booleanType().default(true),
     eventSummaryEnabled: booleanType().default(true),
-    auditDetailLevel: enumType(['minimal', 'standard', 'verbose']).default('standard'),
+    auditDetailLevel: enumType(["minimal", "standard", "verbose"])
+        .default("standard"),
     saveRationaleSummaries: booleanType().default(true),
     saveToolCallTraces: booleanType().default(false),
     saveContextSnapshots: booleanType().default(true),
-    incidentAlertChannel: enumType(['email', 'slack', 'discord', 'webhook', 'none']).default('none'),
-    incidentAlertEndpoint: stringType().default(''),
+    incidentAlertChannel: enumType(["email", "slack", "discord", "webhook", "none"])
+        .default("none"),
+    incidentAlertEndpoint: stringType().default(""),
     requirePostActionExplanation: booleanType().default(true),
     retainDecisionArtifactsDays: numberType().min(0).default(90),
     /** Trade confirmation email preference. Synced to Alpaca API. */
-    tradeConfirmEmail: enumType(['all', 'none']).default('all'),
+    tradeConfirmEmail: enumType(["all", "none"]).default("all"),
 });
 const AuditNotificationPrefsSchema = AuditNotificationPrefsObjectSchema.default({});
 
@@ -67795,7 +67850,8 @@ const PolicyMutationSchema = objectType({
     overlayResponsePrefs: OverlayResponsePrefsObjectSchema.deepPartial().optional(),
     modelPrefs: ModelPrefsObjectSchema.deepPartial().optional(),
     auditNotificationPrefs: AuditNotificationPrefsObjectSchema.deepPartial().optional(),
-}).passthrough();
+})
+    .passthrough();
 
 /**
  * Effective trading policy schema representing the fully-resolved policy