dexbot 1.4.20 → 1.4.21

package/claw/modules/mcp_utils.ts

@@ -43,6 +43,106 @@ export function failure(id: any, code: any, message: any, data = undefined) {
   });
 }
 
+/**
+ * Build an Error that createJsonRpcToolsHandler maps to a JSON-RPC error
+ * response with the given code instead of the isError:true result convention.
+ * Use -32602 for caller-input problems (invalid params, unknown tool).
+ */
+export function jsonRpcError(code: number, message: string): Error & { statusCode: number } {
+  const err = new Error(message) as Error & { statusCode: number };
+  err.statusCode = code;
+  return err;
+}
+
+/**
+ * Shared JSON-RPC request shell for the claw/memu stdio servers: initialize
+ * handshake (echoing the client's protocolVersion), notifications/initialized,
+ * ping, tools/list (internal failures map to -32603), tools/call delegation,
+ * and method-not-found. `callTool(params, defaults)` returns the result value
+ * for a successful call; thrown Errors carrying a numeric `statusCode`
+ * become JSON-RPC errors, everything else becomes an isError:true result.
+ */
+export function createJsonRpcToolsHandler(options: {
+  serverName: string;
+  serverVersion?: string;
+  listTools: () => any[] | Promise<any[]>;
+  callTool: (params: any, defaults: any) => Promise<any>;
+}) {
+  const { serverName, listTools, callTool } = options;
+  const serverVersion = options.serverVersion || '0.1.0';
+
+  return async function handleRequest(message: any, defaults: any) {
+    const { id, method, params } = message;
+
+    switch (method) {
+      case 'initialize':
+        return success(id, {
+          // Echo the client's requested protocol version when provided, so a
+          // JSONL-speaking client can negotiate its own version.
+          protocolVersion: params?.protocolVersion || '2024-11-05',
+          capabilities: {
+            tools: {
+              listChanged: false
+            }
+          },
+          serverInfo: {
+            name: serverName,
+            version: serverVersion
+          }
+        });
+
+      case 'notifications/initialized':
+        return;
+
+      case 'ping':
+        return success(id, {});
+
+      case 'tools/list':
+        try {
+          return success(id, {
+            tools: await listTools()
+          });
+        } catch (error: any) {
+          // Catalog load failure is a server-side problem, not bad input.
+          return failure(id, -32603, `Failed to load tool catalog: ${error && error.message ? error.message : String(error)}`);
+        }
+
+      case 'tools/call': {
+        try {
+          const result = await callTool(params, defaults);
+          return success(id, {
+            content: [
+              {
+                type: 'text',
+                text: JSON.stringify(result, null, 2)
+              }
+            ],
+            structuredContent: result
+          });
+        } catch (error: any) {
+          if (error && typeof error.statusCode === 'number') {
+            return failure(id, error.statusCode, error.message);
+          }
+          return success(id, {
+            content: [
+              {
+                type: 'text',
+                text: error && error.stack ? error.stack : String(error)
+              }
+            ],
+            isError: true
+          });
+        }
+      }
+
+      default:
+        if (id !== undefined) {
+          return failure(id, -32601, `Method not found: ${method}`);
+        }
+    }
+  };
+}
+
 export function createMessageParser(onMessage: any, onDrain?: () => void) {
   if (!hasProcess()) {
     throw new Error('MCP stdio transport not available in this environment');
@@ -128,6 +228,7 @@ export async function runMcpServer(parseArgs: (argv: string[]) => Record<string,
     }
   });
   let lastQueue = Promise.resolve();
+  let finishInput: () => void = () => {};
 
   runtime.stdin!.on('data', (chunk) => {
     lastQueue = parser.push(chunk);
@@ -138,10 +239,18 @@ export async function runMcpServer(parseArgs: (argv: string[]) => Record<string,
       runtime.stdin!.pause();
     }
   });
+  // Without an 'error' listener an EPIPE/EIO on stdin emits an unhandled
+  // 'error' event and crashes the MCP server mid-session. Treat it as EOF.
+  runtime.stdin!.on('error', (err: any) => {
+    runtime.stderr.write(`[mcp] stdin error: ${err && err.stack ? err.stack : String(err)}\n`);
+    // The 'end' event never fires after a stream error; unblock the wait.
+    finishInput();
+  });
   runtime.stdin!.resume();
 
   await new Promise<void>((resolve) => {
     runtime.stdin!.on('end', () => resolve());
+    finishInput = resolve;
   });
   await lastQueue;
 }

package/claw/modules/memu_bridge.ts

@@ -41,17 +41,7 @@ const DEXBOT_VERSION = (() => {
 })();
 
 function resolveMemuScript() {
-  const candidates = [
-    PATHS.CLAW.MEMU_RUNNER_SCRIPT,
-  ];
-
-  for (const candidate of candidates) {
-    if (storage.exists(candidate)) {
-      return candidate;
-    }
-  }
-
-  return candidates[0];
+  return PATHS.CLAW.MEMU_RUNNER_SCRIPT;
 }
 
 function ensureMemuDir(dir: any) {
@@ -132,6 +122,11 @@ function runMemuPython(args: string[], options: Record<string, any> = {}) {
     });
 
     if (options.stdin) {
+      // The child may exit before it drains stdin (bad args, crash); without
+      // an 'error' listener the resulting EPIPE crashes the host process.
+      child.stdin.on('error', () => {
+        // Best-effort write; the close handler reports the real exit status.
+      });
       child.stdin.write(JSON.stringify(options.stdin));
       child.stdin.end();
     }
@@ -431,26 +426,78 @@ function describeMemuBridge(options: Record<string, any> = {}) {
   };
 }
 
+/**
+ * Required-argument spec shared by runMemuCommand, the memU MCP server, and
+ * the claw bridge's memu-* commands, so every surface rejects bad input with
+ * the same message instead of maintaining three copies of the checks.
+ */
+const MEMU_REQUIRED_ARGS: Record<string, { groups: string[][]; message: string }> = {
+  'memorize': {
+    groups: [['resourceUrl'], ['modality']],
+    message: 'memorize requires resourceUrl and modality'
+  },
+  'retrieve': {
+    groups: [['queries']],
+    message: 'retrieve requires queries'
+  },
+  'create-item': {
+    groups: [['categoryId', 'categoryName', 'category'], ['summary']],
+    message: 'create-item requires categoryId or categoryName, plus summary'
+  },
+  'update-item': {
+    groups: [['itemId'], ['updates']],
+    message: 'update-item requires itemId and updates'
+  },
+  'delete-item': {
+    groups: [['itemId']],
+    message: 'delete-item requires itemId'
+  },
+  'memorize-conversation': {
+    groups: [['messages']],
+    message: 'memorize-conversation requires messages array'
+  },
+  'memorize-trading-context': {
+    groups: [['context']],
+    message: 'memorize-trading-context requires context'
+  },
+  'retrieve-trading-context': {
+    groups: [['query']],
+    message: 'retrieve-trading-context requires query'
+  }
+};
+
+/**
+ * Throw when a memU command is missing required arguments.
+ * Each group lists acceptable alternative field names; every group must be
+ * satisfied by at least one present (truthy) field.
+ */
+function validateMemuCommandArgs(command: string, options: Record<string, any>) {
+  const spec = MEMU_REQUIRED_ARGS[command];
+  if (!spec) {
+    return;
+  }
+
+  const satisfied = spec.groups.every(
+    (group) => group.some((field) => options[field])
+  );
+  if (!satisfied) {
+    throw new Error(spec.message);
+  }
+}
+
 async function runMemuCommand(command: string, options: Record<string, any> = {}) {
+  validateMemuCommandArgs(command, options);
   const bridge = createMemuBridge(options);
 
   switch (command) {
     case 'manifest':
       return describeMemuBridge(options);
 
-    case 'memorize': {
-      if (!options.resourceUrl || !options.modality) {
-        throw new Error('memorize requires resourceUrl and modality');
-      }
+    case 'memorize':
       return bridge.memorize(options.resourceUrl, options.modality, options.user);
-    }
 
-    case 'retrieve': {
-      if (!options.queries) {
-        throw new Error('retrieve requires queries');
-      }
+    case 'retrieve':
       return bridge.retrieve(options.queries, options.where, options.method || 'rag');
-    }
 
     case 'list-categories':
       return bridge.listCategories(normalizeScopeWhere(options.where, options.user));
@@ -458,32 +505,19 @@ async function runMemuCommand(command: string, options: Record<string, any> = {}
     case 'list-items':
       return bridge.listItems(normalizeScopeWhere(options.where, options.user));
 
-    case 'create-item': {
-      const categoryRef = options.categoryId || options.categoryName || options.category;
-      if (!categoryRef || !options.summary) {
-        throw new Error('create-item requires categoryId or categoryName, plus summary');
-      }
+    case 'create-item':
       return bridge.createMemoryItem(
-        categoryRef,
+        options.categoryId || options.categoryName || options.category,
         options.summary,
         options.memoryType || 'knowledge',
         options.user
       );
-    }
 
-    case 'update-item': {
-      if (!options.itemId || !options.updates) {
-        throw new Error('update-item requires itemId and updates');
-      }
+    case 'update-item':
       return bridge.updateMemoryItem(options.itemId, options.updates);
-    }
 
-    case 'delete-item': {
-      if (!options.itemId) {
-        throw new Error('delete-item requires itemId');
-      }
+    case 'delete-item':
       return bridge.deleteMemoryItem(options.itemId);
-    }
 
     case 'clear':
       return bridge.clearMemory(normalizeScopeWhere(options.where, options.user));
@@ -491,31 +525,19 @@ async function runMemuCommand(command: string, options: Record<string, any> = {}
     case 'status':
       return bridge.getStatus(normalizeScopeWhere(options.where, options.user));
 
-    case 'memorize-conversation': {
-      if (!options.messages) {
-        throw new Error('memorize-conversation requires messages array');
-      }
+    case 'memorize-conversation':
       return bridge.memorizeConversation(options.messages, options.user);
-    }
 
-    case 'memorize-trading-context': {
-      if (!options.context) {
-        throw new Error('memorize-trading-context requires context');
-      }
+    case 'memorize-trading-context':
       return bridge.memorizeTradingContext(options.context, options.user);
-    }
 
-    case 'retrieve-trading-context': {
-      if (!options.query) {
-        throw new Error('retrieve-trading-context requires query');
-      }
+    case 'retrieve-trading-context':
       return bridge.retrieveTradingContext(options.query, options.user);
-    }
 
     default:
       throw new Error(`Unsupported memU command: ${command}`);
   }
 }
 
-export { createMemuBridge, describeMemuBridge, runMemuCommand, resolveMemuScript, DEFAULT_MEMU_DIR }
+export { createMemuBridge, describeMemuBridge, runMemuCommand, validateMemuCommandArgs }
 

package/claw/modules/mpa_utils.ts

@@ -5,7 +5,7 @@ import { loadDexbotOrderUtils } from './dexbot_bridge.js';
 
 const CORE_SYMBOL = 'BTS';
 
-async function requireBtsBackedMpa(mpaSymbolOrId: any) {
+async function requireBtsBackedMpa(mpaSymbolOrId: any, hint?: string) {
   const mpaAsset = await getAsset(mpaSymbolOrId);
   if (!mpaAsset) {
     throw new Error(`Asset not found: ${mpaSymbolOrId}`);
@@ -19,7 +19,8 @@ async function requireBtsBackedMpa(mpaSymbolOrId: any) {
     throw new Error(`Could not resolve backing asset for ${mpaSymbolOrId}`);
   }
   if (backingAsset.symbol !== CORE_SYMBOL) {
-    throw new Error(`${mpaAsset.symbol || mpaSymbolOrId} is backed by ${backingAsset.symbol}, not ${CORE_SYMBOL}`);
+    const hintSuffix = hint ? `; ${hint}` : '';
+    throw new Error(`${mpaAsset.symbol || mpaSymbolOrId} is backed by ${backingAsset.symbol}, not ${CORE_SYMBOL}${hintSuffix}`);
   }
 
   return {
@@ -62,5 +63,27 @@ function computeBtsPerMpa(settlementPrice: any, mpaAsset: any, backingAsset: any
   return null;
 }
 
-export { CORE_SYMBOL, computeBtsPerMpa, requireBtsBackedMpa }
+/**
+ * Compute the normalized debt/collateral figures for a raw call order.
+ * Canonical implementation shared by position discovery and the position
+ * manager so both surfaces report identical amounts and ratios.
+ */
+function computeCallOrderAmounts(callOrder: any, mpaAsset: any, backingAsset: any, bitassetData: any) {
+  const blockchainToFloat = getBlockchainToFloat();
+  const debtAmount = blockchainToFloat(callOrder.debt, mpaAsset.precision);
+  const collateralAmount = blockchainToFloat(callOrder.collateral, backingAsset.precision);
+  const btsPerMpa = computeBtsPerMpa(bitassetData?.current_feed?.settlement_price, mpaAsset, backingAsset);
+  const debtValueInBts = debtAmount && btsPerMpa ? debtAmount * btsPerMpa : 0;
+  const collateralRatio = debtValueInBts > 0 ? collateralAmount / debtValueInBts : null;
+
+  return {
+    btsPerMpa,
+    collateralAmount: collateralAmount || 0,
+    collateralRatio,
+    debtAmount: debtAmount || 0,
+    debtValueInBts
+  };
+}
+
+export { CORE_SYMBOL, computeBtsPerMpa, computeCallOrderAmounts, getBlockchainToFloat, requireBtsBackedMpa }
 

package/claw/modules/position_discovery.ts

@@ -9,16 +9,11 @@
  */
 
 
-import { loadDexbotOrderUtils } from './dexbot_bridge.js';
-import { computeBtsPerMpa } from './mpa_utils.js';
 import { roundTo } from '../../modules/order/utils/math.js';
 'use strict';
 
 import { getAsset, getBackingAsset, getBitassetData, getFullAccount } from './chain_queries.js';
-
-function getBlockchainToFloat() {
-  return loadDexbotOrderUtils().blockchainToFloat;
-}
+import { computeCallOrderAmounts } from './mpa_utils.js';
 
 /**
  * Normalize a raw call order into a position object compatible with
@@ -31,13 +26,7 @@ function getBlockchainToFloat() {
  * @returns {Object} Normalized position
  */
 function normalizeCallOrder(callOrder: any, mpaAsset: any, backingAsset: any, bitassetData: any) {
-  const blockchainToFloat = getBlockchainToFloat();
-  const debtAmount = blockchainToFloat(callOrder.debt, mpaAsset.precision);
-  const collateralAmount = blockchainToFloat(callOrder.collateral, backingAsset.precision);
-  const settlement = bitassetData?.current_feed?.settlement_price;
-  const btsPerMpa = computeBtsPerMpa(settlement, mpaAsset, backingAsset);
-  const debtValueInBts = debtAmount && btsPerMpa ? debtAmount * btsPerMpa : 0;
-  const collateralRatio = debtValueInBts > 0 ? collateralAmount / debtValueInBts : null;
+  const amounts = computeCallOrderAmounts(callOrder, mpaAsset, backingAsset, bitassetData);
 
   return {
     id: callOrder.id,
@@ -48,11 +37,11 @@ function normalizeCallOrder(callOrder: any, mpaAsset: any, backingAsset: any, bi
     backingSymbol: backingAsset.symbol,
     onChain: {
       callOrderId: callOrder.id,
-      collateralAmount: collateralAmount || 0,
-      collateralRatio,
-      debtAmount: debtAmount || 0,
-      debtValueInBts,
-      btsPerMpa,
+      collateralAmount: amounts.collateralAmount,
+      collateralRatio: amounts.collateralRatio,
+      debtAmount: amounts.debtAmount,
+      debtValueInBts: amounts.debtValueInBts,
+      btsPerMpa: amounts.btsPerMpa,
       feedPublicationTime: bitassetData?.current_feed_publication_time || null,
     },
   };
@@ -76,21 +65,21 @@ async function discoverPositions(accountName: string) {
     callOrders.map((co: any) => co?.call_price?.quote?.asset_id).filter(Boolean)
   )];
 
-  // Resolve all assets in parallel
+  // Resolve every debt asset's MPA/backing/bitasset triple in parallel.
   const assetCache = new Map();
   const bitassetCache = new Map();
 
-  for (const assetId of debtAssetIds) {
-    const mpaAsset = await getAsset(assetId);
-    if (!mpaAsset) continue;
-    assetCache.set(assetId, mpaAsset);
+  await Promise.all(debtAssetIds.map(async (assetId) => {
+    const [mpaAsset, backingAsset, bitassetData] = await Promise.all([
+      getAsset(assetId).catch(() => null),
+      getBackingAsset(assetId).catch(() => null),
+      getBitassetData(assetId).catch(() => null)
+    ]);
 
-    const backingAsset = await getBackingAsset(assetId);
+    if (mpaAsset) assetCache.set(assetId, mpaAsset);
     if (backingAsset) assetCache.set(`backing:${assetId}`, backingAsset);
-
-    const bitassetData = await getBitassetData(assetId);
     if (bitassetData) bitassetCache.set(assetId, bitassetData);
-  }
+  }));
 
   // Normalize each call order
   const positions: any[] = [];

package/claw/modules/position_manager.ts

@@ -3,11 +3,10 @@ import { getStorage } from '../../modules/storage/index.js';
 import { path } from '../../modules/path_api.js';
 import { PATHS } from '../../modules/paths.js';
 import { Config } from '../../modules/config.js';
-import { requireBtsBackedMpa, computeBtsPerMpa } from './mpa_utils.js';
+import { requireBtsBackedMpa, computeCallOrderAmounts, getBlockchainToFloat } from './mpa_utils.js';
 import { listenForFills } from './chain_actions.js';
 import { writeJsonFileAtomic } from './dexbot_profiles.js';
-import { loadDexbotOrderUtils } from './dexbot_bridge.js';
-import { clone } from './utils.js';
+import { clone, requirePositiveNumber } from './utils.js';
 const storage = getStorage();
 import { closeShortOnBts, openShortOnBts, placeTakeProfitBuyOrderOnBts } from './short_mpa_strategy.js';
 import { getAsset, getBackingAsset, getBalances, getBitassetData, getFullAccount } from './chain_queries.js';
@@ -15,10 +14,6 @@ import { getErrorMessage } from '../../modules/utils/errors.js';
 
 import type { ShortPositionOptions, PositionManagerOptions } from './types.js';
 
-function getBlockchainToFloat() {
-  return loadDexbotOrderUtils().blockchainToFloat;
-}
-
 const DEFAULT_STATE_PATH = PATHS.CLAW.POSITIONS_FILE;
 const STRATEGY_NAME = 'short-mpa-bts';
 
@@ -38,14 +33,6 @@ function requireString(value: any, fieldName: string) {
   return value.trim();
 }
 
-function requirePositiveNumber(value: any, fieldName: string) {
-  const numericValue = Number(value);
-  if (!Number.isFinite(numericValue) || numericValue <= 0) {
-    throw new Error(`${fieldName} must be a positive number`);
-  }
-  return numericValue;
-}
-
 function almostZero(value: any, epsilon: number = 1e-12) {
   return Math.abs(Number(value) || 0) <= epsilon;
 }
@@ -116,18 +103,6 @@ function toTrackedAsset(asset: any) {
   return asset ? { id: asset.id, precision: asset.precision, symbol: asset.symbol } : null;
 }
 
-function resolvePositionAssets(position: any) {
-  const tracked = position?.assets || {};
-  return {
-    collateral: tracked.collateral || null,
-    mpa: tracked.mpa || null
-  };
-}
-
-function getOrderTracking(position: any, side: string) {
-  return side === 'entry' ? position.entry : position.exit;
-}
-
 function getAssetPrecisionFromTracking(orderTracking: any, assetId: string) {
   if (orderTracking?.sellAsset?.id === assetId) {
     return orderTracking.sellAsset.precision;
@@ -265,7 +240,7 @@ function refreshPositionPnl(position: any) {
 }
 
 function normalizeCallPosition(callOrder: any, mpaAsset: any, backingAsset: any, bitassetData: any) {
-  if (!callOrder) {
+  if (!callOrder || !mpaAsset || !backingAsset) {
     return {
       collateralAmount: 0,
       collateralRatio: null,
@@ -276,18 +251,13 @@ function normalizeCallPosition(callOrder: any, mpaAsset: any, backingAsset: any,
     };
   }
 
-  const blockchainToFloat = getBlockchainToFloat();
-  const debtAmount = blockchainToFloat(callOrder.debt, mpaAsset.precision);
-  const collateralAmount = blockchainToFloat(callOrder.collateral, backingAsset.precision);
-  const btsPerMpa = computeBtsPerMpa(bitassetData?.current_feed?.settlement_price, mpaAsset, backingAsset);
-  const debtValueInBts = debtAmount && btsPerMpa ? debtAmount * btsPerMpa : 0;
-  const collateralRatio = debtValueInBts > 0 ? collateralAmount / debtValueInBts : null;
+  const amounts = computeCallOrderAmounts(callOrder, mpaAsset, backingAsset, bitassetData);
 
   return {
-    collateralAmount: collateralAmount || 0,
-    collateralRatio,
-    debtAmount: debtAmount || 0,
-    debtValueInBts,
+    collateralAmount: amounts.collateralAmount,
+    collateralRatio: amounts.collateralRatio,
+    debtAmount: amounts.debtAmount,
+    debtValueInBts: amounts.debtValueInBts,
     exists: true,
     feedPublicationTime: bitassetData?.current_feed_publication_time || null
   };
@@ -560,7 +530,14 @@ class PositionManager {
     });
     position.lastCloseTx = result?.repayResult?.raw || null;
 
-    await this.syncPosition(positionId);
+    // Persist before syncing: syncPosition can throw (network failure, asset
+    // resolution), and losing the close event/tx record after a successful
+    // on-chain repay would corrupt the position history. Mirrors openShort.
+    await this.saveState();
+
+    await this.syncPosition(positionId).catch((syncErr: any) => {
+      console.warn(`[POSITION] Post-close sync failed for ${positionId}: ${getErrorMessage(syncErr)}`);
+    });
     return this.getPosition(positionId);
   }
 
@@ -577,7 +554,15 @@ class PositionManager {
     const mpaAsset = await getAsset(position.debt.asset);
     const backingAsset = await getBackingAsset(position.debt.asset);
     const bitassetData = await getBitassetData(position.debt.asset);
-    const callOrder = callOrders.find((entry: any) => entry?.call_price?.quote?.asset_id === mpaAsset?.id) || null;
+    // Only match a call order when the debt asset resolved; matching against
+    // an undefined id could pair the position with an unrelated call order,
+    // and normalizing without asset precision would crash.
+    if (!mpaAsset) {
+      console.warn(`[POSITION] Could not resolve debt asset ${position.debt.asset} for ${positionId}; skipping on-chain debt sync`);
+    }
+    const callOrder = mpaAsset
+      ? callOrders.find((entry: any) => entry?.call_price?.quote?.asset_id === mpaAsset.id) || null
+      : null;
     const debtState = normalizeCallPosition(callOrder, mpaAsset, backingAsset, bitassetData);
     const openOrderIds = openOrders.map((entry: any) => entry?.id).filter(Boolean);
     const entryOrderOpen = position.entry.orderId ? openOrderIds.includes(position.entry.orderId) : false;
@@ -692,8 +677,14 @@ class PositionManager {
           });
           changed = true;
 
+          // Isolate user callback failures: a rejected onFill must not abort
+          // this handler before saveState()/post-fill syncs persist the fill.
           if (typeof onFill === 'function') {
-            await onFill(clone(position), fill);
+            try {
+              await onFill(clone(position), fill);
+            } catch (err: any) {
+              console.error(`[POSITION] onFill callback failed for ${position.id}: ${getErrorMessage(err)}`);
+            }
           }
         }
       }

package/claw/modules/position_manager_watch.ts

@@ -1,6 +1,5 @@
 
 import { getStorage } from '../../modules/storage/index.js';
-import { path } from '../../modules/path_api.js';
 import { PATHS } from '../../modules/paths.js';
 import { PositionManager, DEFAULT_STATE_PATH } from './position_manager.js';
 import * as client from './bitshares_client.js';
@@ -178,12 +177,14 @@ function createPositionManagerWatcher(options: Record<string, any> = {}) {
       throw new Error('accountName is required. Pass --account or set BITSHARES_ACCOUNT.');
     }
 
-    running = true;
     logger.info(`[position-manager-watch] starting for ${resolvedOptions.accountName}`);
 
+    // Only flag running once the connection succeeded: a failed start must
+    // leave the watcher non-running (and re-startable) with healthy=false.
     await waitForConnected().catch((err: any) => {
       throw new Error(`BitShares connection not ready: ${getErrorMessage(err)}`);
     });
+    running = true;
 
     await manager.syncAllPositions()
       .then(() => recordSyncSuccess())

package/claw/modules/short_mpa_strategy.ts

@@ -2,15 +2,7 @@
 import { Config } from '../../modules/config.js';
 import { borrowMpa, createLimitOrder, repayMpaDebt } from './chain_actions.js';
 import { requireBtsBackedMpa } from './mpa_utils.js';
-
-function requirePositiveNumber(value: any, fieldName: string) {
-  const numericValue = Number(value);
-  if (!Number.isFinite(numericValue) || numericValue <= 0) {
-    throw new Error(`${fieldName} must be a positive number`);
-  }
-
-  return numericValue;
-}
+import { requirePositiveNumber } from './utils.js';
 
 function requireNonNegativeNumber(value: any, fieldName: string) {
   const numericValue = Number(value);

package/claw/modules/skill_utils.ts

@@ -42,11 +42,13 @@ export function tomlString(value: any) {
 }
 
 export function buildSkillTomlLines(skillName: string, description: string, tags: string[], tools: any[]) {
+  // name/description go through tomlString so embedded quotes/backslashes
+  // produce valid escaped TOML basic strings.
   const lines = [
     '[skill]',
-    `name = "${skillName}"`,
-    `description = "${description}"`,
-    `version = "${DEXBOT_VERSION}"`,
+    `name = ${tomlString(skillName)}`,
+    `description = ${tomlString(description)}`,
+    `version = ${tomlString(DEXBOT_VERSION)}`,
     `tags = [${tags.map(t => JSON.stringify(t)).join(', ')}]`
   ];
 

package/claw/modules/utils.ts

@@ -5,5 +5,13 @@ function clone(value: any) {
   return JSON.parse(JSON.stringify(value));
 }
 
-export { clone }
+function requirePositiveNumber(value: any, fieldName: string) {
+  const numericValue = Number(value);
+  if (!Number.isFinite(numericValue) || numericValue <= 0) {
+    throw new Error(`${fieldName} must be a positive number`);
+  }
+  return numericValue;
+}
+
+export { clone, requirePositiveNumber }
 

package/claw/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dexbot2-claw",
-  "version": "1.4.20",
+  "version": "1.4.21",
   "private": true,
   "description": "Claw bridge and runtime integration layer for BitShares and DEXBot2.",
   "type": "module",