@gbozee/ultimate 0.0.2-200 → 0.0.2-202

package/dist/mcp-server.js

@@ -62809,7 +62809,6 @@ class Signal {
           let potentials = new_result.filter((x) => condition(x["entry"], i2["risk_sell"])).map((x) => x["entry"]);
           if (potentials.length && max_index) {
             if (kind === "long") {
-              console.log("slice: ", potentials.slice(0, max_index));
               i2["risk_sell"] = Math.max(...potentials.slice(0, max_index));
             } else {
               i2["risk_sell"] = Math.min(...potentials.slice(0, max_index));
@@ -62873,7 +62872,6 @@ class Signal {
   }) {
     const margin_zones = [this.support, this.resistance];
     const distribution = this.distribution ? this.distribution[kind] : "geometric";
-    console.log("margin_zones", { margin_zones, distribution });
     let _kind = distribution === "inverse-exponential" ? kind === "long" ? "short" : "long" : kind;
     const entries = distributions_default({
       margin_range: margin_zones,
@@ -63092,7 +63090,6 @@ class Signal {
             }
           });
           risk_to_use = theoretical_kelly * risk_per_trade / this.kelly_minimum_risk;
-          console.log({ risk_per_trade, theoretical_kelly });
         }
         const y = this.build_trade_dict({
           entry: x,
@@ -63592,7 +63589,6 @@ function buildConfig(app_config, {
   }
   const condition = (kind === "long" ? entry > app_config.support : entry >= app_config.support) && stop >= app_config.support * 0.999;
   if (kind === "short") {}
-  console.log({ entry, stop, condition, working_risk, config: config2 });
   const result = entry === stop ? [] : condition ? instance.build_entry({
     current_price: entry,
     stop_loss: stop,
@@ -64235,6 +64231,7 @@ function computeRiskReward(payload) {
     risk_per_trade,
     target_loss,
     distribution,
+    high_range,
     max_size
   } = payload;
   const kind = entry > stop ? "long" : "short";
@@ -64246,12 +64243,14 @@ function computeRiskReward(payload) {
     app_config,
     target_loss,
     distribution,
+    high_range,
     max_size
   });
   return result;
 }
 function getRiskReward(payload) {
   const {
+    high_range,
     max_size,
     entry,
     stop,
@@ -64275,6 +64274,7 @@ function getRiskReward(payload) {
     entry,
     stop,
     risk_per_trade: risk,
+    high_range,
     target_loss,
     distribution,
     max_size
@@ -65170,6 +65170,421 @@ class Strategy {
     };
   }
 }
+// src/helpers/compound.ts
+function buildTrades(payload) {
+  const { appConfig, settings, kind } = payload;
+  const kelly_config = settings.kelly;
+  const current_app_config = { ...appConfig[kind] };
+  const entryNum = parseFloat(settings.entry);
+  const stopNum = parseFloat(settings.stop);
+  current_app_config.entry = entryNum;
+  current_app_config.stop = stopNum;
+  current_app_config.risk_per_trade = parseFloat(settings.risk);
+  current_app_config.risk_reward = parseFloat(settings.risk_reward);
+  current_app_config.kind = kind;
+  current_app_config.kelly = kelly_config;
+  const options = {
+    take_profit: null,
+    entry: current_app_config.entry,
+    stop: current_app_config.stop,
+    raw_instance: null,
+    risk: current_app_config.risk_per_trade,
+    no_of_trades: undefined,
+    risk_reward: current_app_config.risk_reward,
+    kind: current_app_config.kind,
+    increase: true,
+    gap: current_app_config.gap,
+    rr: current_app_config.rr,
+    price_places: current_app_config.price_places,
+    decimal_places: current_app_config.decimal_places,
+    use_kelly: kelly_config?.use_kelly,
+    kelly_confidence_factor: kelly_config?.kelly_confidence_factor,
+    kelly_minimum_risk: kelly_config?.kelly_minimum_risk,
+    kelly_prediction_model: kelly_config?.kelly_prediction_model,
+    kelly_func: kelly_config?.kelly_func,
+    distribution: settings.distribution
+  };
+  if (kind === "long" && entryNum <= stopNum) {
+    return [];
+  }
+  if (kind === "short" && entryNum >= stopNum) {
+    return [];
+  }
+  try {
+    const generatedTrades = sortedBuildConfig(current_app_config, options);
+    return generatedTrades ?? [];
+  } catch (error) {
+    console.error("Error generating orders:", error);
+    return [];
+  }
+}
+function generateSummary({
+  trades,
+  fee_percent = 0.05,
+  anchor
+}) {
+  const avg_entry = trades[0].avg_entry;
+  const avg_size = trades[0].avg_size;
+  const expected_fee = avg_entry * avg_size * fee_percent / 100;
+  return {
+    first_entry: trades.at(-1).entry,
+    last_entry: trades[0].entry,
+    quantity: avg_size,
+    entry: avg_entry,
+    loss: trades[0].neg_pnl,
+    number_of_trades: trades.length,
+    fee: to_f(expected_fee, "%.2f"),
+    anchor_pnl: anchor?.target_pnl
+  };
+}
+function helperFuncToBuildTrades({
+  custom_b_config,
+  symbol_config,
+  app_config_kind,
+  appConfig,
+  force_exact_risk = true
+}) {
+  const risk = custom_b_config.risk * (custom_b_config.risk_factor || 1);
+  let result = getRiskReward({
+    entry: custom_b_config.entry,
+    stop: custom_b_config.stop,
+    risk,
+    global_config: symbol_config,
+    force_exact_risk,
+    target_loss: custom_b_config.risk * (custom_b_config.risk_factor || 1),
+    distribution: custom_b_config.distribution
+  });
+  if (!force_exact_risk) {
+    result = {
+      risk_reward: result,
+      risk
+    };
+  }
+  const trades = result.risk_reward ? buildTrades({
+    appConfig: { [app_config_kind]: appConfig },
+    kind: app_config_kind,
+    settings: {
+      entry: custom_b_config.entry,
+      stop: custom_b_config.stop,
+      risk: result.risk || custom_b_config.risk,
+      risk_reward: result.risk_reward,
+      distribution: custom_b_config.distribution
+    }
+  }) : [];
+  const summary = trades.length > 0 ? generateSummary({ trades }) : {};
+  return { trades, result, summary };
+}
+function constructAppConfig2({
+  config: config2,
+  global_config
+}) {
+  const options = {
+    entry: config2?.entry,
+    stop: config2?.stop,
+    risk_reward: config2?.risk_reward,
+    risk: config2?.risk,
+    symbol: config2.symbol
+  };
+  const { entries: _entries, ...appConfig } = buildAppConfig(global_config, options);
+  return appConfig;
+}
+function buildWithOptimumReward({
+  config: config2,
+  settings,
+  global_config,
+  force_exact
+}) {
+  const kind = config2.entry > config2.stop ? "long" : "short";
+  let stop = settings.stop;
+  let entry = settings.entry;
+  const risk = settings.risk;
+  const stop_ratio = settings.stop_ratio || 1;
+  const distribution = settings.distribution || config2?.distribution;
+  const custom_b_config = {
+    entry,
+    stop,
+    risk,
+    distribution
+  };
+  const appConfig = constructAppConfig2({
+    config: config2,
+    global_config
+  });
+  const { trades, summary, result } = helperFuncToBuildTrades({
+    custom_b_config,
+    app_config_kind: kind,
+    appConfig,
+    symbol_config: global_config,
+    force_exact_risk: force_exact
+  });
+  const adjusted_size = summary.quantity;
+  const symbol_config = global_config;
+  const entryDetails = {
+    entry: to_f(custom_b_config.entry, symbol_config.price_places),
+    stop: to_f(custom_b_config.stop, symbol_config.price_places),
+    risk: to_f(result.risk, "%.2f"),
+    risk_reward: result.risk_reward,
+    avg_entry: to_f(summary.entry, symbol_config.price_places),
+    avg_size: to_f(adjusted_size, symbol_config.decimal_places),
+    first_entry: to_f(summary.first_entry, symbol_config.price_places),
+    pnl: to_f(custom_b_config.risk, "%.2f"),
+    fee: to_f(summary.fee, "%.2f"),
+    loss: to_f(summary.loss, "%.2f"),
+    last_entry: to_f(summary.last_entry, symbol_config.price_places),
+    margin: to_f(summary.entry * adjusted_size / symbol_config.leverage, "%.2f")
+  };
+  return {
+    trades,
+    summary: entryDetails,
+    config: {
+      ...custom_b_config,
+      ...result,
+      stop_ratio
+    },
+    stop_order: {
+      quantity: entryDetails.avg_size * stop_ratio,
+      price: entryDetails.stop
+    },
+    kind
+  };
+}
+function generateOppositeOptimum({
+  config: config2,
+  global_config,
+  settings,
+  ratio = 1,
+  distribution,
+  risk_factor = 1
+}) {
+  const configKind = config2.entry > config2.stop ? "long" : "short";
+  if (configKind === "long" && config2.entry > config2.stop) {
+    if (settings.stop <= settings.entry) {
+      throw new Error("Invalid input: For long config positions, opposite settings must have stop > entry");
+    }
+  } else if (configKind === "short" && config2.entry < config2.stop) {
+    if (settings.stop >= settings.entry) {
+      throw new Error("Invalid input: For short config positions, opposite settings must have stop < entry");
+    }
+  }
+  const kind = config2.entry > config2.stop ? "long" : "short";
+  const app_config_kind = kind === "long" ? "short" : "long";
+  let risk = settings.risk;
+  const custom_b_config = {
+    entry: settings.entry,
+    stop: settings.stop,
+    risk: risk * ratio,
+    distribution: distribution || "inverse-exponential",
+    risk_factor
+  };
+  const appConfig = constructAppConfig2({
+    config: {
+      ...config2,
+      ...custom_b_config
+    },
+    global_config
+  });
+  const { result, trades, summary } = helperFuncToBuildTrades({
+    custom_b_config,
+    symbol_config: global_config,
+    app_config_kind,
+    appConfig
+  });
+  if (Object.keys(summary).length === 0) {
+    return {
+      trades,
+      summary,
+      config: custom_b_config,
+      kind: app_config_kind
+    };
+  }
+  const symbol_config = global_config;
+  const entryDetails = {
+    entry: to_f(custom_b_config.entry, symbol_config.price_places),
+    stop: to_f(custom_b_config.stop, symbol_config.price_places),
+    risk: to_f(result.risk, "%.2f"),
+    risk_reward: result.risk_reward,
+    avg_entry: to_f(summary.entry, symbol_config.price_places),
+    avg_size: to_f(summary.quantity, symbol_config.decimal_places),
+    first_entry: to_f(summary.first_entry, symbol_config.price_places),
+    pnl: to_f(custom_b_config.risk, "%.2f"),
+    fee: to_f(summary.fee, "%.2f"),
+    loss: to_f(summary.loss, "%.2f"),
+    last_entry: to_f(summary.last_entry, symbol_config.price_places),
+    defaultEntry: settings.entry ? to_f(settings.entry, symbol_config.price_places) : null
+  };
+  return {
+    trades,
+    summary: entryDetails,
+    config: {
+      ...custom_b_config,
+      ...result
+    },
+    kind: app_config_kind
+  };
+}
+function defaultTradeFromCurrentState({
+  config: config2,
+  global_config
+}) {
+  const kind = config2.entry > config2.stop ? "long" : "short";
+  const settings = {
+    entry: config2?.entry,
+    stop: config2?.stop,
+    risk: config2?.risk,
+    distribution: config2?.distribution,
+    risk_reward: config2?.risk_reward
+  };
+  const appConfig = constructAppConfig2({
+    config: config2,
+    global_config
+  });
+  const trades = buildTrades({
+    appConfig: { [kind]: appConfig },
+    kind,
+    settings
+  });
+  return {
+    trades,
+    summary: generateSummary({
+      trades,
+      fee_percent: global_config.fee_percent
+    })
+  };
+}
+function increaseTradeHelper({
+  increase_qty,
+  stop,
+  config: config2,
+  global_config,
+  style,
+  entry,
+  position: position2,
+  stop_ratio = 1,
+  distribution: default_distribution
+}) {
+  const symbol_config = global_config;
+  const kind = config2.entry > config2.stop ? "long" : "short";
+  const distribution = default_distribution || config2.distribution || "inverse-exponential";
+  const appConfig = constructAppConfig2({
+    config: config2,
+    global_config
+  });
+  const currentState = defaultTradeFromCurrentState({
+    config: config2,
+    global_config
+  });
+  const { optimal_risk, neg_pnl } = getOptimumStopAndRisk(appConfig, {
+    max_size: increase_qty,
+    target_stop: stop,
+    distribution
+  });
+  if (neg_pnl === 0) {
+    return {
+      trades: [],
+      summary: {},
+      config: {},
+      kind,
+      current: currentState
+    };
+  }
+  const custom_b_config = {
+    entry,
+    stop,
+    risk: style === "minimum" ? Math.abs(neg_pnl) : optimal_risk,
+    distribution
+  };
+  const { result, trades, summary } = helperFuncToBuildTrades({
+    custom_b_config,
+    symbol_config,
+    appConfig,
+    app_config_kind: kind
+  });
+  if (Object.keys(summary).length === 0) {
+    return {
+      trades,
+      summary,
+      config: {
+        ...custom_b_config,
+        ...result
+      },
+      kind,
+      current: currentState
+    };
+  }
+  const new_avg_values = determine_average_entry_and_size([
+    {
+      price: position2.entry,
+      quantity: position2.quantity
+    },
+    {
+      price: summary?.entry,
+      quantity: summary?.quantity
+    }
+  ], symbol_config.decimal_places, symbol_config.price_places);
+  summary.entry = new_avg_values.entry;
+  summary.quantity = new_avg_values.quantity;
+  const loss = Math.abs(summary.entry - custom_b_config.stop) * summary.quantity;
+  const entryDetails = {
+    entry: to_f(custom_b_config.entry, symbol_config.price_places),
+    stop: to_f(custom_b_config.stop, symbol_config.price_places),
+    risk: to_f(result.risk, symbol_config.price_places),
+    risk_reward: result.risk_reward,
+    avg_entry: to_f(summary.entry, symbol_config.price_places),
+    avg_size: to_f(summary.quantity, symbol_config.decimal_places),
+    first_entry: to_f(summary.first_entry, symbol_config.price_places),
+    pnl: to_f(custom_b_config.risk, "%.2f"),
+    fee: to_f(summary.fee, "%.2f"),
+    loss: to_f(loss, "%.2f"),
+    last_entry: to_f(summary.last_entry, symbol_config.price_places),
+    margin: to_f(summary.entry * summary.quantity / global_config.leverage, "%.2f")
+  };
+  return {
+    trades,
+    summary: entryDetails,
+    stop_order: {
+      quantity: entryDetails.avg_size * stop_ratio,
+      price: entryDetails.stop
+    },
+    config: {
+      ...custom_b_config,
+      ...result
+    },
+    kind,
+    current: currentState
+  };
+}
+function generatePositionIncreaseTrade({
+  account,
+  zoneAccount,
+  ratio = 0.1,
+  config: config2,
+  global_config,
+  style = "minimum",
+  distribution = "inverse-exponential"
+}) {
+  const kind = config2.entry > config2.stop ? "long" : "short";
+  const target_max_quantity = kind === "long" ? account.short.quantity : account.long.quantity;
+  const increase_qty = target_max_quantity * ratio;
+  const entry = zoneAccount.entry;
+  const stop = zoneAccount.stop;
+  return increaseTradeHelper({
+    config: config2,
+    position: account[kind],
+    global_config,
+    entry,
+    stop,
+    style,
+    increase_qty,
+    distribution
+  });
+}
+var compoundAPI = {
+  buildWithOptimumReward,
+  constructAppConfig: constructAppConfig2,
+  generateOppositeOptimum,
+  increaseTradeHelper,
+  generatePositionIncreaseTrade
+};
 // src/types/index.ts
 class BaseExchange {
   client;
@@ -71539,6 +71954,324 @@ server.tool("fetch_exchange_details", "Fetch exchange details for a symbol with
     };
   }
 });
+server.tool("buildWithOptimumReward", "Create trades with optimal risk/reward ratios. Calculates the best entry, stop, and take profit levels based on market conditions and risk parameters, including margin calculations.", {
+  config: z.object({
+    entry: z.number().optional().describe("Entry price"),
+    stop: z.number().optional().describe("Stop loss price"),
+    risk_reward: z.number().optional().describe("Risk to reward ratio"),
+    risk: z.number().optional().describe("Risk amount"),
+    symbol: z.string().optional().describe("Trading symbol"),
+    distribution: z.enum(["arithmetic", "geometric", "normal", "exponential", "inverse-exponential"]).optional().describe("Distribution type")
+  }).optional().describe("Base trading configuration"),
+  global_config: z.object({
+    profit_percent: z.number().optional().describe("Profit percentage target"),
+    symbol: z.string().optional().describe("Trading symbol"),
+    profit: z.number().optional().describe("Target profit amount"),
+    risk: z.number().optional().describe("Risk amount"),
+    stop_percent: z.number().optional().describe("Stop loss percentage"),
+    kind: z.enum(["long", "short"]).optional().describe("Position direction"),
+    reduce_percent: z.number().optional().describe("Position reduction percentage"),
+    support: z.number().optional().describe("Support price level"),
+    resistance: z.number().optional().describe("Resistance price level"),
+    price_places: z.string().optional().describe("Price decimal format"),
+    decimal_places: z.string().optional().describe("Quantity decimal format"),
+    min_size: z.number().optional().describe("Minimum trade size"),
+    accounts: z.array(z.object({
+      owner: z.string().optional().describe("Account owner"),
+      exchange: z.string().optional().describe("Exchange name")
+    })).optional().describe("Trading accounts"),
+    risk_reward: z.number().optional().describe("Risk to reward ratio"),
+    reverse_factor: z.number().optional().describe("Reverse factor for calculations"),
+    leverage: z.number().optional().describe("Leverage multiplier"),
+    max_quantity: z.number().optional().describe("Maximum quantity"),
+    fee_percent: z.number().optional().describe("Trading fee percentage")
+  }).optional().describe("Global configuration parameters"),
+  settings: z.object({
+    entry: z.number().optional().describe("Override entry price"),
+    stop: z.number().optional().describe("Override stop price"),
+    risk: z.number().optional().describe("Risk amount for this trade"),
+    stop_ratio: z.number().optional().describe("Stop order quantity ratio"),
+    risk_reward: z.number().optional().describe("Override risk/reward ratio"),
+    distribution: z.enum(["arithmetic", "geometric", "normal", "exponential", "inverse-exponential"]).optional().describe("Distribution type")
+  }).optional().describe("Trade-specific settings")
+}, async (args) => {
+  try {
+    const result = compoundAPI.buildWithOptimumReward(args);
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Optimum reward trade generated: ${JSON.stringify(result, null, 2)}`
+        }
+      ]
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Failed to build optimum reward trade: ${error.message}`
+        }
+      ],
+      isError: true
+    };
+  }
+});
+server.tool("constructAppConfig", "Build application configuration from trade parameters. Converts basic trade configuration into a comprehensive app config object with all necessary trading parameters.", {
+  config: z.object({
+    entry: z.number().optional().describe("Entry price"),
+    stop: z.number().optional().describe("Stop loss price"),
+    risk_reward: z.number().optional().describe("Risk to reward ratio"),
+    risk: z.number().optional().describe("Risk amount"),
+    symbol: z.string().optional().describe("Trading symbol"),
+    distribution: z.enum(["arithmetic", "geometric", "normal", "exponential", "inverse-exponential"]).optional().describe("Distribution type")
+  }).optional().describe("Basic trade configuration"),
+  global_config: z.object({
+    profit_percent: z.number().optional().describe("Profit percentage target"),
+    symbol: z.string().optional().describe("Trading symbol"),
+    profit: z.number().optional().describe("Target profit amount"),
+    risk: z.number().optional().describe("Risk amount"),
+    stop_percent: z.number().optional().describe("Stop loss percentage"),
+    kind: z.enum(["long", "short"]).optional().describe("Position direction"),
+    reduce_percent: z.number().optional().describe("Position reduction percentage"),
+    support: z.number().optional().describe("Support price level"),
+    resistance: z.number().optional().describe("Resistance price level"),
+    price_places: z.string().optional().describe("Price decimal format"),
+    decimal_places: z.string().optional().describe("Quantity decimal format"),
+    min_size: z.number().optional().describe("Minimum trade size"),
+    accounts: z.array(z.object({
+      owner: z.string().optional().describe("Account owner"),
+      exchange: z.string().optional().describe("Exchange name")
+    })).optional().describe("Trading accounts"),
+    risk_reward: z.number().optional().describe("Risk to reward ratio"),
+    reverse_factor: z.number().optional().describe("Reverse factor for calculations"),
+    leverage: z.number().optional().describe("Leverage multiplier"),
+    max_quantity: z.number().optional().describe("Maximum quantity"),
+    fee_percent: z.number().optional().describe("Trading fee percentage")
+  }).optional().describe("Global configuration parameters")
+}, async (args) => {
+  try {
+    const result = compoundAPI.constructAppConfig(args);
+    return {
+      content: [
+        {
+          type: "text",
+          text: `App configuration constructed: ${JSON.stringify(result, null, 2)}`
+        }
+      ]
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Failed to construct app config: ${error.message}`
+        }
+      ],
+      isError: true
+    };
+  }
+});
+server.tool("generateOppositeOptimum", "Create opposite position trades for hedging strategies. Generates optimal trades in the opposite direction to hedge existing positions, with configurable ratio and risk factors.", {
+  settings: z.object({
+    entry: z.number().optional().describe("Entry price for opposite position"),
+    stop: z.number().optional().describe("Stop loss price"),
+    take_profit: z.number().optional().describe("Take profit price"),
+    risk: z.number().optional().describe("Risk amount")
+  }).optional().describe("Opposite position settings"),
+  config: z.object({
+    entry: z.number().optional().describe("Original position entry price"),
+    stop: z.number().optional().describe("Original position stop price"),
+    risk_reward: z.number().optional().describe("Risk to reward ratio"),
+    risk: z.number().optional().describe("Original position risk"),
+    symbol: z.string().optional().describe("Trading symbol")
+  }).optional().describe("Original position configuration"),
+  global_config: z.object({
+    profit_percent: z.number().optional().describe("Profit percentage target"),
+    symbol: z.string().optional().describe("Trading symbol"),
+    profit: z.number().optional().describe("Target profit amount"),
+    risk: z.number().optional().describe("Risk amount"),
+    stop_percent: z.number().optional().describe("Stop loss percentage"),
+    kind: z.enum(["long", "short"]).optional().describe("Position direction"),
+    reduce_percent: z.number().optional().describe("Position reduction percentage"),
+    support: z.number().optional().describe("Support price level"),
+    resistance: z.number().optional().describe("Resistance price level"),
+    price_places: z.string().optional().describe("Price decimal format"),
+    decimal_places: z.string().optional().describe("Quantity decimal format"),
+    min_size: z.number().optional().describe("Minimum trade size"),
+    accounts: z.array(z.object({
+      owner: z.string().optional().describe("Account owner"),
+      exchange: z.string().optional().describe("Exchange name")
+    })).optional().describe("Trading accounts"),
+    risk_reward: z.number().optional().describe("Risk to reward ratio"),
+    reverse_factor: z.number().optional().describe("Reverse factor for calculations"),
+    leverage: z.number().optional().describe("Leverage multiplier"),
+    max_quantity: z.number().optional().describe("Maximum quantity"),
+    fee_percent: z.number().optional().describe("Trading fee percentage")
+  }).optional().describe("Global configuration parameters"),
+  entryToUse: z.number().optional().describe("Optimal entry price to use"),
+  stopToUse: z.number().optional().describe("Stop price to use"),
+  ratio: z.number().default(1).describe("Risk ratio multiplier (default 1)"),
+  distribution: z.enum(["arithmetic", "geometric", "normal", "exponential", "inverse-exponential"]).default("inverse-exponential").describe("Distribution type"),
+  risk_factor: z.number().default(1).describe("Risk factor multiplier")
+}, async (args) => {
+  try {
+    const result = compoundAPI.generateOppositeOptimum(args);
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Opposite optimum position generated: ${JSON.stringify(result, null, 2)}`
+        }
+      ]
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Failed to generate opposite optimum: ${error.message}`
+        }
+      ],
+      isError: true
+    };
+  }
+});
+server.tool("increaseTradeHelper", "Help increase existing positions incrementally. Calculates optimal trades to scale up existing positions based on current market conditions and available capital.", {
+  position: z.object({
+    entry: z.number().optional().describe("Current position entry price"),
+    quantity: z.number().optional().describe("Current position quantity")
+  }).optional().describe("Existing position details"),
+  entry: z.number().optional().describe("New entry price for scaling"),
+  stop: z.number().optional().describe("Stop loss price for scaled position"),
+  config: z.object({
+    entry: z.number().optional().describe("Original entry price"),
+    stop: z.number().optional().describe("Original stop price"),
+    risk_reward: z.number().optional().describe("Risk to reward ratio"),
+    risk: z.number().optional().describe("Risk amount"),
+    symbol: z.string().optional().describe("Trading symbol")
+  }).optional().describe("Base trading configuration"),
+  global_config: z.object({
+    profit_percent: z.number().optional().describe("Profit percentage target"),
+    symbol: z.string().optional().describe("Trading symbol"),
+    profit: z.number().optional().describe("Target profit amount"),
+    risk: z.number().optional().describe("Risk amount"),
+    stop_percent: z.number().optional().describe("Stop loss percentage"),
+    kind: z.enum(["long", "short"]).optional().describe("Position direction"),
+    reduce_percent: z.number().optional().describe("Position reduction percentage"),
+    support: z.number().optional().describe("Support price level"),
+    resistance: z.number().optional().describe("Resistance price level"),
+    price_places: z.string().optional().describe("Price decimal format"),
+    decimal_places: z.string().optional().describe("Quantity decimal format"),
+    min_size: z.number().optional().describe("Minimum trade size"),
+    accounts: z.array(z.object({
+      owner: z.string().optional().describe("Account owner"),
+      exchange: z.string().optional().describe("Exchange name")
+    })).optional().describe("Trading accounts"),
+    risk_reward: z.number().optional().describe("Risk to reward ratio"),
+    reverse_factor: z.number().optional().describe("Reverse factor for calculations"),
+    leverage: z.number().optional().describe("Leverage multiplier"),
+    max_quantity: z.number().optional().describe("Maximum quantity"),
+    fee_percent: z.number().optional().describe("Trading fee percentage")
+  }).optional().describe("Global configuration parameters"),
+  increase_qty: z.number().optional().describe("Maximum quantity to add to position"),
+  style: z.enum(["minimum", "optimum"]).optional().describe("Calculation style - minimum or optimum risk"),
+  stop_ratio: z.number().default(1).describe("Stop order quantity ratio"),
+  distribution: z.enum(["arithmetic", "geometric", "normal", "exponential", "inverse-exponential"]).optional().describe("Distribution type")
+}, async (args) => {
+  try {
+    const result = compoundAPI.increaseTradeHelper(args);
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Position increase trade calculated: ${JSON.stringify(result, null, 2)}`
+        }
+      ]
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Failed to calculate increase trade: ${error.message}`
+        }
+      ],
+      isError: true
+    };
+  }
+});
+server.tool("generatePositionIncreaseTrade", "Generate trades to increase positions based on trading zones. Analyzes account positions and zone parameters to determine optimal position scaling strategies.", {
+  account: z.object({
+    long: z.object({
+      entry: z.number().optional().describe("Long position entry price"),
+      quantity: z.number().optional().describe("Long position quantity")
+    }).optional().describe("Long position details"),
+    short: z.object({
+      entry: z.number().optional().describe("Short position entry price"),
+      quantity: z.number().optional().describe("Short position quantity")
+    }).optional().describe("Short position details")
+  }).optional().describe("Account position details"),
+  zoneAccount: z.object({
+    entry: z.number().optional().describe("Zone entry price"),
+    stop: z.number().optional().describe("Zone stop price")
+  }).optional().describe("Trading zone parameters"),
+  config: z.object({
+    entry: z.number().optional().describe("Base entry price"),
+    stop: z.number().optional().describe("Base stop price"),
+    risk_reward: z.number().optional().describe("Risk to reward ratio"),
+    risk: z.number().optional().describe("Risk amount"),
+    symbol: z.string().optional().describe("Trading symbol")
+  }).optional().describe("Base trading configuration"),
+  global_config: z.object({
+    profit_percent: z.number().optional().describe("Profit percentage target"),
+    symbol: z.string().optional().describe("Trading symbol"),
+    profit: z.number().optional().describe("Target profit amount"),
+    risk: z.number().optional().describe("Risk amount"),
+    stop_percent: z.number().optional().describe("Stop loss percentage"),
+    kind: z.enum(["long", "short"]).optional().describe("Position direction"),
+    reduce_percent: z.number().optional().describe("Position reduction percentage"),
+    support: z.number().optional().describe("Support price level"),
+    resistance: z.number().optional().describe("Resistance price level"),
+    price_places: z.string().optional().describe("Price decimal format"),
+    decimal_places: z.string().optional().describe("Quantity decimal format"),
+    min_size: z.number().optional().describe("Minimum trade size"),
+    accounts: z.array(z.object({
+      owner: z.string().optional().describe("Account owner"),
+      exchange: z.string().optional().describe("Exchange name")
+    })).optional().describe("Trading accounts"),
+    risk_reward: z.number().optional().describe("Risk to reward ratio"),
+    reverse_factor: z.number().optional().describe("Reverse factor for calculations"),
+    leverage: z.number().optional().describe("Leverage multiplier"),
+    max_quantity: z.number().optional().describe("Maximum quantity"),
+    fee_percent: z.number().optional().describe("Trading fee percentage")
+  }).optional().describe("Global configuration parameters"),
+  ratio: z.number().default(0.1).describe("Position increase ratio (default 0.1)"),
+  style: z.enum(["optimum", "minimum"]).default("minimum").describe("Calculation style"),
+  distribution: z.enum(["arithmetic", "geometric", "normal", "exponential", "inverse-exponential"]).default("inverse-exponential").describe("Distribution type")
+}, async (args) => {
+  try {
+    const result = compoundAPI.generatePositionIncreaseTrade(args);
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Zone-based position increase trade: ${JSON.stringify(result, null, 2)}`
+        }
+      ]
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Failed to generate position increase trade: ${error.message}`
+        }
+      ],
+      isError: true
+    };
+  }
+});
 async function main() {
   const transport = new StdioServerTransport;
   await server.connect(transport);