opentool 0.10.1 → 0.10.4

package/dist/index.js

@@ -1,9 +1,9 @@
-import * as path6 from 'path';
-import { fileURLToPath, pathToFileURL } from 'url';
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { ListToolsRequestSchema, CallToolRequestSchema } from '@modelcontextprotocol/sdk/types.js';
-import * as fs2 from 'fs';
+import * as fs4 from 'fs';
+import * as path5 from 'path';
+import { fileURLToPath, pathToFileURL } from 'url';
 import { zodToJsonSchema } from '@alcyone-labs/zod-to-json-schema';
 import { z } from 'zod';
 import { zeroAddress, createWalletClient, http, createPublicClient, parseUnits, encodeFunctionData, erc20Abi } from 'viem';
@@ -25,8 +25,6 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
   if (typeof require !== "undefined") return require.apply(this, arguments);
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
-var getFilename = () => fileURLToPath(import.meta.url);
-var __filename$1 = /* @__PURE__ */ getFilename();
 var X402_VERSION = 1;
 var HEADER_X402 = "X-PAYMENT";
 var HEADER_PAYMENT_RESPONSE = "X-PAYMENT-RESPONSE";
@@ -331,295 +329,8 @@ function ensureTrailingSlash(url) {
   return url.endsWith("/") ? url : `${url}/`;
 }
 var PAYMENT_HEADERS = [HEADER_X402, HEADER_PAYMENT_RESPONSE];
-var X402Client = class {
-  constructor(config) {
-    this.account = privateKeyToAccount(config.privateKey);
-    const chain = baseSepolia;
-    this.walletClient = createWalletClient({
-      account: this.account,
-      chain,
-      transport: http(config.rpcUrl)
-    });
-  }
-  async pay(request) {
-    try {
-      const initialResponse = await fetch(request.url, {
-        method: request.method ?? "POST",
-        headers: {
-          "Content-Type": "application/json",
-          ...request.headers
-        },
-        ...request.body ? { body: JSON.stringify(request.body) } : {}
-      });
-      if (initialResponse.status !== 402) {
-        return {
-          success: initialResponse.ok,
-          response: initialResponse
-        };
-      }
-      const paymentRequirements = await initialResponse.json();
-      const x402Requirements = paymentRequirements.x402?.accepts?.[0];
-      if (!x402Requirements) {
-        return {
-          success: false,
-          error: "No x402 payment requirements found in 402 response"
-        };
-      }
-      const authorization = await this.signTransferAuthorization({
-        from: this.account.address,
-        to: x402Requirements.payTo,
-        value: BigInt(x402Requirements.maxAmountRequired),
-        validAfter: BigInt(Math.floor(Date.now() / 1e3)),
-        validBefore: BigInt(Math.floor(Date.now() / 1e3) + 900),
-        // 15 min
-        nonce: `0x${Array.from(
-          { length: 32 },
-          () => Math.floor(Math.random() * 256).toString(16).padStart(2, "0")
-        ).join("")}`,
-        tokenAddress: x402Requirements.asset
-      });
-      const paymentProof = {
-        x402Version: 1,
-        scheme: x402Requirements.scheme,
-        network: x402Requirements.network,
-        correlationId: "",
-        payload: {
-          signature: authorization.signature,
-          authorization: {
-            from: authorization.from,
-            to: authorization.to,
-            value: authorization.value.toString(),
-            validAfter: authorization.validAfter.toString(),
-            validBefore: authorization.validBefore.toString(),
-            nonce: authorization.nonce
-          }
-        }
-      };
-      const paymentHeader = Buffer.from(JSON.stringify(paymentProof)).toString("base64");
-      const paidResponse = await fetch(request.url, {
-        method: request.method ?? "POST",
-        headers: {
-          "Content-Type": "application/json",
-          "X-PAYMENT": paymentHeader,
-          ...request.headers
-        },
-        ...request.body ? { body: JSON.stringify(request.body) } : {}
-      });
-      return {
-        success: paidResponse.ok,
-        response: paidResponse,
-        paymentDetails: {
-          amount: x402Requirements.maxAmountRequired,
-          currency: x402Requirements.extra?.currencyCode ?? "USDC",
-          network: x402Requirements.network,
-          signature: authorization.signature
-        }
-      };
-    } catch (error) {
-      return {
-        success: false,
-        error: error instanceof Error ? error.message : String(error)
-      };
-    }
-  }
-  async signTransferAuthorization(params) {
-    if (!this.walletClient.chain) {
-      throw new Error("Wallet client chain not configured");
-    }
-    const domain = {
-      name: "USD Coin",
-      version: "2",
-      chainId: this.walletClient.chain.id,
-      verifyingContract: params.tokenAddress
-    };
-    const types = {
-      TransferWithAuthorization: [
-        { name: "from", type: "address" },
-        { name: "to", type: "address" },
-        { name: "value", type: "uint256" },
-        { name: "validAfter", type: "uint256" },
-        { name: "validBefore", type: "uint256" },
-        { name: "nonce", type: "bytes32" }
-      ]
-    };
-    const message = {
-      from: params.from,
-      to: params.to,
-      value: params.value,
-      validAfter: params.validAfter,
-      validBefore: params.validBefore,
-      nonce: params.nonce
-    };
-    const signature = await this.walletClient.signTypedData({
-      account: this.account,
-      domain,
-      types,
-      primaryType: "TransferWithAuthorization",
-      message
-    });
-    return {
-      signature,
-      from: params.from,
-      to: params.to,
-      value: params.value,
-      validAfter: params.validAfter,
-      validBefore: params.validBefore,
-      nonce: params.nonce
-    };
-  }
-  getAddress() {
-    return this.account.address;
-  }
-};
-async function payX402(config) {
-  const client = new X402Client({
-    privateKey: config.privateKey,
-    ...config.rpcUrl ? { rpcUrl: config.rpcUrl } : {}
-  });
-  return client.pay({
-    url: config.url,
-    body: config.body
-  });
-}
-var X402BrowserClient = class {
-  constructor(config) {
-    this.walletClient = config.walletClient;
-    this.chainId = config.chainId;
-  }
-  async pay(request) {
-    try {
-      const initialResponse = await fetch(request.url, {
-        method: request.method ?? "POST",
-        headers: {
-          "Content-Type": "application/json",
-          ...request.headers
-        },
-        ...request.body ? { body: JSON.stringify(request.body) } : {}
-      });
-      if (initialResponse.status !== 402) {
-        return {
-          success: initialResponse.ok,
-          response: initialResponse
-        };
-      }
-      const paymentRequirements = await initialResponse.json();
-      const x402Requirements = paymentRequirements.x402?.accepts?.[0];
-      if (!x402Requirements) {
-        return {
-          success: false,
-          error: "No x402 payment requirements found in 402 response"
-        };
-      }
-      const account = this.walletClient.account;
-      if (!account) {
-        return {
-          success: false,
-          error: "No account connected to wallet"
-        };
-      }
-      const authorization = {
-        from: account.address,
-        to: x402Requirements.payTo,
-        value: BigInt(x402Requirements.maxAmountRequired),
-        validAfter: BigInt(Math.floor(Date.now() / 1e3)),
-        validBefore: BigInt(Math.floor(Date.now() / 1e3) + 900),
-        nonce: `0x${Array.from(
-          { length: 32 },
-          () => Math.floor(Math.random() * 256).toString(16).padStart(2, "0")
-        ).join("")}`
-      };
-      const signature = await this.signTransferAuthorization(
-        authorization,
-        x402Requirements.asset
-      );
-      const paymentProof = {
-        x402Version: 1,
-        scheme: x402Requirements.scheme,
-        network: x402Requirements.network,
-        correlationId: "",
-        payload: {
-          signature,
-          authorization: {
-            from: authorization.from,
-            to: authorization.to,
-            value: authorization.value.toString(),
-            validAfter: authorization.validAfter.toString(),
-            validBefore: authorization.validBefore.toString(),
-            nonce: authorization.nonce
-          }
-        }
-      };
-      const paymentHeader = btoa(JSON.stringify(paymentProof));
-      const paidResponse = await fetch(request.url, {
-        method: request.method ?? "POST",
-        headers: {
-          "Content-Type": "application/json",
-          "X-PAYMENT": paymentHeader,
-          ...request.headers
-        },
-        ...request.body ? { body: JSON.stringify(request.body) } : {}
-      });
-      return {
-        success: paidResponse.ok,
-        response: paidResponse,
-        paymentDetails: {
-          amount: x402Requirements.maxAmountRequired,
-          currency: x402Requirements.extra?.currencyCode ?? "USDC",
-          network: x402Requirements.network,
-          signature
-        }
-      };
-    } catch (error) {
-      return {
-        success: false,
-        error: error instanceof Error ? error.message : String(error)
-      };
-    }
-  }
-  async signTransferAuthorization(authorization, tokenAddress) {
-    const account = this.walletClient.account;
-    if (!account) {
-      throw new Error("No account connected to wallet");
-    }
-    const domain = {
-      name: "USD Coin",
-      version: "2",
-      chainId: this.chainId,
-      verifyingContract: tokenAddress
-    };
-    const types = {
-      TransferWithAuthorization: [
-        { name: "from", type: "address" },
-        { name: "to", type: "address" },
-        { name: "value", type: "uint256" },
-        { name: "validAfter", type: "uint256" },
-        { name: "validBefore", type: "uint256" },
-        { name: "nonce", type: "bytes32" }
-      ]
-    };
-    const message = {
-      from: authorization.from,
-      to: authorization.to,
-      value: authorization.value,
-      validAfter: authorization.validAfter,
-      validBefore: authorization.validBefore,
-      nonce: authorization.nonce
-    };
-    return await this.walletClient.signTypedData({
-      account,
-      domain,
-      types,
-      primaryType: "TransferWithAuthorization",
-      message
-    });
-  }
-};
-async function payX402WithWallet(walletClient, chainId, request) {
-  const client = new X402BrowserClient({ walletClient, chainId });
-  return client.pay(request);
-}
 
-// src/x402/index.ts
+// src/x402/payment.ts
 var PAYMENT_CONTEXT_SYMBOL = /* @__PURE__ */ Symbol.for("opentool.x402.context");
 var X402PaymentRequiredError = class extends Error {
   constructor(response, verification) {
@@ -988,16 +699,16 @@ function buildAdapters(tools) {
 }
 async function loadToolsFromDirectory(metadataMap) {
   const tools = [];
-  const toolsDir = path6.join(process.cwd(), "tools");
-  if (!fs2.existsSync(toolsDir)) {
+  const toolsDir = path5.join(process.cwd(), "tools");
+  if (!fs4.existsSync(toolsDir)) {
     return tools;
   }
-  const files = fs2.readdirSync(toolsDir);
+  const files = fs4.readdirSync(toolsDir);
   for (const file of files) {
     if (!isSupportedToolFile(file)) {
       continue;
     }
-    const toolPath = path6.join(toolsDir, file);
+    const toolPath = path5.join(toolsDir, file);
     try {
       const exportsObject = __require(toolPath);
       const candidate = resolveModuleCandidate(exportsObject);
@@ -1061,12 +772,12 @@ async function loadToolsFromDirectory(metadataMap) {
   return tools;
 }
 function loadMetadata() {
-  const metadataPath = path6.join(process.cwd(), "metadata.json");
-  if (!fs2.existsSync(metadataPath)) {
+  const metadataPath = path5.join(process.cwd(), "metadata.json");
+  if (!fs4.existsSync(metadataPath)) {
     return null;
   }
   try {
-    const contents = fs2.readFileSync(metadataPath, "utf8");
+    const contents = fs4.readFileSync(metadataPath, "utf8");
     return JSON.parse(contents);
   } catch (error) {
     console.warn(`Failed to parse metadata.json: ${error}`);
@@ -1147,47 +858,334 @@ function normalizeInputSchema(schema) {
   }
   return clone;
 }
-function normalizeRuntimeMcpConfig(rawConfig) {
-  if (isPlainObject(rawConfig) && rawConfig.enabled === true) {
-    let normalizedMode;
-    if (typeof rawConfig.mode === "string") {
-      const candidate = rawConfig.mode.toLowerCase();
-      if (candidate === "stdio" || candidate === "lambda" || candidate === "dual") {
-        normalizedMode = candidate;
-      } else {
-        throw new Error('mcp.mode must be one of "stdio", "lambda", or "dual"');
+function normalizeRuntimeMcpConfig(rawConfig) {
+  if (isPlainObject(rawConfig) && rawConfig.enabled === true) {
+    let normalizedMode;
+    if (typeof rawConfig.mode === "string") {
+      const candidate = rawConfig.mode.toLowerCase();
+      if (candidate === "stdio" || candidate === "lambda" || candidate === "dual") {
+        normalizedMode = candidate;
+      } else {
+        throw new Error('mcp.mode must be one of "stdio", "lambda", or "dual"');
+      }
+    }
+    const metadataOverrides = isPlainObject(rawConfig.metadataOverrides) ? rawConfig.metadataOverrides : void 0;
+    const config = { enabled: true };
+    if (normalizedMode) {
+      config.mode = normalizedMode;
+    }
+    if (typeof rawConfig.defaultMethod === "string") {
+      config.defaultMethod = rawConfig.defaultMethod.toUpperCase();
+    }
+    if (metadataOverrides) {
+      config.metadataOverrides = metadataOverrides;
+    }
+    return config;
+  }
+  return null;
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isMcpEnabled(tool) {
+  return Boolean(tool.mcpConfig?.enabled);
+}
+function resolveRuntimePath(value) {
+  if (value.startsWith("file://")) {
+    return fileURLToPath(value);
+  }
+  return path5.resolve(value);
+}
+
+// src/types/index.ts
+var HTTP_METHODS2 = ["GET", "HEAD", "POST", "PUT", "DELETE", "PATCH", "OPTIONS"];
+var X402Client = class {
+  constructor(config) {
+    this.account = privateKeyToAccount(config.privateKey);
+    const chain = baseSepolia;
+    this.walletClient = createWalletClient({
+      account: this.account,
+      chain,
+      transport: http(config.rpcUrl)
+    });
+  }
+  async pay(request) {
+    try {
+      const initialResponse = await fetch(request.url, {
+        method: request.method ?? "POST",
+        headers: {
+          "Content-Type": "application/json",
+          ...request.headers
+        },
+        ...request.body ? { body: JSON.stringify(request.body) } : {}
+      });
+      if (initialResponse.status !== 402) {
+        return {
+          success: initialResponse.ok,
+          response: initialResponse
+        };
+      }
+      const paymentRequirements = await initialResponse.json();
+      const x402Requirements = paymentRequirements.x402?.accepts?.[0];
+      if (!x402Requirements) {
+        return {
+          success: false,
+          error: "No x402 payment requirements found in 402 response"
+        };
+      }
+      const authorization = await this.signTransferAuthorization({
+        from: this.account.address,
+        to: x402Requirements.payTo,
+        value: BigInt(x402Requirements.maxAmountRequired),
+        validAfter: BigInt(Math.floor(Date.now() / 1e3)),
+        validBefore: BigInt(Math.floor(Date.now() / 1e3) + 900),
+        // 15 min
+        nonce: `0x${Array.from(
+          { length: 32 },
+          () => Math.floor(Math.random() * 256).toString(16).padStart(2, "0")
+        ).join("")}`,
+        tokenAddress: x402Requirements.asset
+      });
+      const paymentProof = {
+        x402Version: 1,
+        scheme: x402Requirements.scheme,
+        network: x402Requirements.network,
+        correlationId: "",
+        payload: {
+          signature: authorization.signature,
+          authorization: {
+            from: authorization.from,
+            to: authorization.to,
+            value: authorization.value.toString(),
+            validAfter: authorization.validAfter.toString(),
+            validBefore: authorization.validBefore.toString(),
+            nonce: authorization.nonce
+          }
+        }
+      };
+      const paymentHeader = Buffer.from(JSON.stringify(paymentProof)).toString("base64");
+      const paidResponse = await fetch(request.url, {
+        method: request.method ?? "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "X-PAYMENT": paymentHeader,
+          ...request.headers
+        },
+        ...request.body ? { body: JSON.stringify(request.body) } : {}
+      });
+      return {
+        success: paidResponse.ok,
+        response: paidResponse,
+        paymentDetails: {
+          amount: x402Requirements.maxAmountRequired,
+          currency: x402Requirements.extra?.currencyCode ?? "USDC",
+          network: x402Requirements.network,
+          signature: authorization.signature
+        }
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  async signTransferAuthorization(params) {
+    if (!this.walletClient.chain) {
+      throw new Error("Wallet client chain not configured");
+    }
+    const domain = {
+      name: "USD Coin",
+      version: "2",
+      chainId: this.walletClient.chain.id,
+      verifyingContract: params.tokenAddress
+    };
+    const types = {
+      TransferWithAuthorization: [
+        { name: "from", type: "address" },
+        { name: "to", type: "address" },
+        { name: "value", type: "uint256" },
+        { name: "validAfter", type: "uint256" },
+        { name: "validBefore", type: "uint256" },
+        { name: "nonce", type: "bytes32" }
+      ]
+    };
+    const message = {
+      from: params.from,
+      to: params.to,
+      value: params.value,
+      validAfter: params.validAfter,
+      validBefore: params.validBefore,
+      nonce: params.nonce
+    };
+    const signature = await this.walletClient.signTypedData({
+      account: this.account,
+      domain,
+      types,
+      primaryType: "TransferWithAuthorization",
+      message
+    });
+    return {
+      signature,
+      from: params.from,
+      to: params.to,
+      value: params.value,
+      validAfter: params.validAfter,
+      validBefore: params.validBefore,
+      nonce: params.nonce
+    };
+  }
+  getAddress() {
+    return this.account.address;
+  }
+};
+async function payX402(config) {
+  const client = new X402Client({
+    privateKey: config.privateKey,
+    ...config.rpcUrl ? { rpcUrl: config.rpcUrl } : {}
+  });
+  return client.pay({
+    url: config.url,
+    body: config.body
+  });
+}
+var X402BrowserClient = class {
+  constructor(config) {
+    this.walletClient = config.walletClient;
+    this.chainId = config.chainId;
+  }
+  async pay(request) {
+    try {
+      const initialResponse = await fetch(request.url, {
+        method: request.method ?? "POST",
+        headers: {
+          "Content-Type": "application/json",
+          ...request.headers
+        },
+        ...request.body ? { body: JSON.stringify(request.body) } : {}
+      });
+      if (initialResponse.status !== 402) {
+        return {
+          success: initialResponse.ok,
+          response: initialResponse
+        };
       }
+      const paymentRequirements = await initialResponse.json();
+      const x402Requirements = paymentRequirements.x402?.accepts?.[0];
+      if (!x402Requirements) {
+        return {
+          success: false,
+          error: "No x402 payment requirements found in 402 response"
+        };
+      }
+      const account = this.walletClient.account;
+      if (!account) {
+        return {
+          success: false,
+          error: "No account connected to wallet"
+        };
+      }
+      const authorization = {
+        from: account.address,
+        to: x402Requirements.payTo,
+        value: BigInt(x402Requirements.maxAmountRequired),
+        validAfter: BigInt(Math.floor(Date.now() / 1e3)),
+        validBefore: BigInt(Math.floor(Date.now() / 1e3) + 900),
+        nonce: `0x${Array.from(
+          { length: 32 },
+          () => Math.floor(Math.random() * 256).toString(16).padStart(2, "0")
+        ).join("")}`
+      };
+      const signature = await this.signTransferAuthorization(
+        authorization,
+        x402Requirements.asset
+      );
+      const paymentProof = {
+        x402Version: 1,
+        scheme: x402Requirements.scheme,
+        network: x402Requirements.network,
+        correlationId: "",
+        payload: {
+          signature,
+          authorization: {
+            from: authorization.from,
+            to: authorization.to,
+            value: authorization.value.toString(),
+            validAfter: authorization.validAfter.toString(),
+            validBefore: authorization.validBefore.toString(),
+            nonce: authorization.nonce
+          }
+        }
+      };
+      const paymentHeader = btoa(JSON.stringify(paymentProof));
+      const paidResponse = await fetch(request.url, {
+        method: request.method ?? "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "X-PAYMENT": paymentHeader,
+          ...request.headers
+        },
+        ...request.body ? { body: JSON.stringify(request.body) } : {}
+      });
+      return {
+        success: paidResponse.ok,
+        response: paidResponse,
+        paymentDetails: {
+          amount: x402Requirements.maxAmountRequired,
+          currency: x402Requirements.extra?.currencyCode ?? "USDC",
+          network: x402Requirements.network,
+          signature
+        }
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
     }
-    const metadataOverrides = isPlainObject(rawConfig.metadataOverrides) ? rawConfig.metadataOverrides : void 0;
-    const config = { enabled: true };
-    if (normalizedMode) {
-      config.mode = normalizedMode;
-    }
-    if (typeof rawConfig.defaultMethod === "string") {
-      config.defaultMethod = rawConfig.defaultMethod.toUpperCase();
-    }
-    if (metadataOverrides) {
-      config.metadataOverrides = metadataOverrides;
-    }
-    return config;
   }
-  return null;
-}
-function isPlainObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function isMcpEnabled(tool) {
-  return Boolean(tool.mcpConfig?.enabled);
-}
-function resolveRuntimePath(value) {
-  if (value.startsWith("file://")) {
-    return fileURLToPath(value);
+  async signTransferAuthorization(authorization, tokenAddress) {
+    const account = this.walletClient.account;
+    if (!account) {
+      throw new Error("No account connected to wallet");
+    }
+    const domain = {
+      name: "USD Coin",
+      version: "2",
+      chainId: this.chainId,
+      verifyingContract: tokenAddress
+    };
+    const types = {
+      TransferWithAuthorization: [
+        { name: "from", type: "address" },
+        { name: "to", type: "address" },
+        { name: "value", type: "uint256" },
+        { name: "validAfter", type: "uint256" },
+        { name: "validBefore", type: "uint256" },
+        { name: "nonce", type: "bytes32" }
+      ]
+    };
+    const message = {
+      from: authorization.from,
+      to: authorization.to,
+      value: authorization.value,
+      validAfter: authorization.validAfter,
+      validBefore: authorization.validBefore,
+      nonce: authorization.nonce
+    };
+    return await this.walletClient.signTypedData({
+      account,
+      domain,
+      types,
+      primaryType: "TransferWithAuthorization",
+      message
+    });
   }
-  return path6.resolve(value);
+};
+async function payX402WithWallet(walletClient, chainId, request) {
+  const client = new X402BrowserClient({ walletClient, chainId });
+  return client.pay(request);
 }
-
-// src/types/index.ts
-var HTTP_METHODS2 = ["GET", "HEAD", "POST", "PUT", "DELETE", "PATCH", "OPTIONS"];
 var BASE_ALCHEMY_HOST = "https://base-mainnet.g.alchemy.com/v2/";
 var ETHEREUM_ALCHEMY_HOST = "https://eth-mainnet.g.alchemy.com/v2/";
 var BASE_SEPOLIA_ALCHEMY_HOST = "https://base-sepolia.g.alchemy.com/v2/";
@@ -1734,8 +1732,8 @@ async function store(input, options) {
     );
   }
   const { baseUrl, apiKey, fetchFn } = resolveConfig(options);
-  const path8 = mode === "backtest" ? "/apps/backtests/tx" : "/apps/positions/tx";
-  const url = `${baseUrl}${path8}`;
+  const path7 = mode === "backtest" ? "/apps/backtests/tx" : "/apps/positions/tx";
+  const url = `${baseUrl}${path7}`;
   let response;
   try {
     response = await fetchFn(url, {
@@ -1775,8 +1773,8 @@ async function store(input, options) {
 async function retrieve(params, options) {
   const { baseUrl, apiKey, fetchFn } = resolveConfig(options);
   const mode = params?.mode ?? "live";
-  const path8 = mode === "backtest" ? "/apps/backtests/tx" : "/apps/positions/tx";
-  const url = new URL(`${baseUrl}${path8}`);
+  const path7 = mode === "backtest" ? "/apps/backtests/tx" : "/apps/positions/tx";
+  const url = new URL(`${baseUrl}${path7}`);
   if (params?.source) url.searchParams.set("source", params.source);
   if (params?.walletAddress) url.searchParams.set("walletAddress", params.walletAddress);
   if (params?.symbol) url.searchParams.set("symbol", params.symbol);
@@ -3427,6 +3425,9 @@ function resolveHyperliquidPair(value) {
   }
   return null;
 }
+function resolveHyperliquidLeverageMode(symbol) {
+  return symbol.includes(":") ? "isolated" : "cross";
+}
 function resolveHyperliquidProfileChain(environment) {
   return environment === "testnet" ? "hyperliquid-testnet" : "hyperliquid";
 }
@@ -3527,6 +3528,175 @@ function resolveHyperliquidSymbol(asset, override) {
   const baseNoPair = base2.split("/")[0] ?? base2;
   return baseNoPair.trim().toUpperCase();
 }
+function resolveHyperliquidPerpSymbol(asset) {
+  const raw = asset.trim();
+  if (!raw) return raw;
+  const dex = extractHyperliquidDex(raw);
+  const base2 = normalizeHyperliquidBaseSymbol(raw) ?? raw.toUpperCase();
+  return dex ? `${dex}:${base2}` : base2;
+}
+function resolveHyperliquidSpotSymbol(asset, defaultQuote = "USDC") {
+  const quote = defaultQuote.trim().toUpperCase() || "USDC";
+  const raw = asset.trim().toUpperCase();
+  if (!raw) {
+    return { symbol: raw, base: raw, quote };
+  }
+  const pair = resolveHyperliquidPair(raw);
+  if (pair) {
+    const [base3, pairQuote] = pair.split("/");
+    return {
+      symbol: pair,
+      base: base3?.trim() ?? raw,
+      quote: pairQuote?.trim() ?? quote
+    };
+  }
+  const base2 = normalizeHyperliquidBaseSymbol(raw) ?? raw;
+  return { symbol: `${base2}/${quote}`, base: base2, quote };
+}
+
+// src/adapters/hyperliquid/strategy.ts
+function clampDcaWeight(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) return 0;
+  return Math.min(1e6, Math.max(0, value));
+}
+function resolveHyperliquidBudgetUsd(params) {
+  const { config, accountValue } = params;
+  if (config.allocationMode === "fixed") {
+    const desiredUsd = config.amountUsd ?? 0;
+    if (!Number.isFinite(desiredUsd) || desiredUsd <= 0) {
+      throw new Error("fixed allocation requires amountUsd");
+    }
+    return desiredUsd;
+  }
+  if (!Number.isFinite(accountValue ?? Number.NaN)) {
+    throw new Error("percent allocation requires accountValue");
+  }
+  const rawUsd = accountValue * (config.percentOfEquity / 100);
+  const maxPercentUsd = accountValue * (config.maxPercentOfEquity / 100);
+  return Math.min(rawUsd, maxPercentUsd);
+}
+function resolveHyperliquidDcaSymbolEntries(inputs, fallbackSymbol) {
+  const entries = [];
+  const values = Array.isArray(inputs) ? inputs : [];
+  for (const input of values) {
+    if (typeof input === "string") {
+      const trimmed = input.trim();
+      if (!trimmed) continue;
+      const [rawSymbol, rawWeight] = trimmed.split(":");
+      const symbol2 = rawSymbol?.trim();
+      if (!symbol2) continue;
+      const parsedWeight2 = typeof rawWeight === "string" && rawWeight.trim().length > 0 ? Number.parseFloat(rawWeight.trim()) : 1;
+      const weight2 = Number.isFinite(parsedWeight2) && parsedWeight2 > 0 ? parsedWeight2 : 1;
+      entries.push({ symbol: symbol2, weight: weight2 });
+      continue;
+    }
+    if (!input || typeof input !== "object") continue;
+    const symbol = input.symbol?.trim();
+    if (!symbol) continue;
+    const parsedWeight = typeof input.weight === "number" && Number.isFinite(input.weight) ? input.weight : 1;
+    const weight = parsedWeight > 0 ? parsedWeight : 1;
+    entries.push({ symbol, weight });
+  }
+  if (entries.length > 0) {
+    return entries;
+  }
+  return [{ symbol: fallbackSymbol, weight: 1 }];
+}
+function normalizeHyperliquidDcaEntries(params) {
+  const map = /* @__PURE__ */ new Map();
+  const entries = Array.isArray(params.entries) ? params.entries : [];
+  for (const entry of entries) {
+    if (!entry || typeof entry !== "object") continue;
+    const symbol = typeof entry.symbol === "string" ? entry.symbol.trim() : "";
+    if (!symbol) continue;
+    const key = symbol.toUpperCase();
+    const weight = clampDcaWeight(entry.weight);
+    if (weight <= 0) continue;
+    const existing = map.get(key);
+    if (existing) {
+      existing.weight += weight;
+    } else {
+      map.set(key, { symbol, weight });
+    }
+  }
+  if (map.size === 0) {
+    map.set(params.fallbackSymbol.toUpperCase(), {
+      symbol: params.fallbackSymbol,
+      weight: 1
+    });
+  }
+  const entriesList = Array.from(map.values());
+  const totalWeight = entriesList.reduce((sum, entry) => sum + entry.weight, 0);
+  if (!Number.isFinite(totalWeight) || totalWeight <= 0) {
+    return [];
+  }
+  return entriesList.map((entry) => ({
+    symbol: entry.symbol,
+    weight: entry.weight,
+    normalizedWeight: entry.weight / totalWeight
+  }));
+}
+function resolveHyperliquidMaxPerRunUsd(targetNotionalUsd, hedgeRatio) {
+  if (!Number.isFinite(targetNotionalUsd) || targetNotionalUsd <= 0) return 0;
+  const ratio = Number.isFinite(hedgeRatio) && hedgeRatio > 0 ? hedgeRatio : 1;
+  return Math.max(targetNotionalUsd, targetNotionalUsd * ratio);
+}
+function clampHyperliquidAbs(value, limit) {
+  if (!Number.isFinite(value) || !Number.isFinite(limit) || limit <= 0) return 0;
+  const capped = Math.min(Math.abs(value), limit);
+  return Math.sign(value) * capped;
+}
+function resolveHyperliquidTargetSize(params) {
+  const { config, execution, accountValue, currentPrice } = params;
+  if (execution.size && Number.isFinite(execution.size)) {
+    return { targetSize: execution.size, budgetUsd: execution.size * currentPrice };
+  }
+  if (config.allocationMode === "fixed") {
+    const budgetUsd2 = resolveHyperliquidBudgetUsd({
+      config,
+      accountValue
+    });
+    return { targetSize: budgetUsd2 / currentPrice, budgetUsd: budgetUsd2 };
+  }
+  const budgetUsd = resolveHyperliquidBudgetUsd({
+    config,
+    accountValue
+  });
+  return { targetSize: budgetUsd / currentPrice, budgetUsd };
+}
+function planHyperliquidTrade(params) {
+  const { signal, mode, currentSize, targetSize } = params;
+  if (signal === "hold" || signal === "unknown") return null;
+  if (signal === "buy") {
+    const desired2 = mode === "long-short" ? targetSize : Math.max(targetSize, 0);
+    const delta2 = desired2 - currentSize;
+    if (delta2 <= 0) return null;
+    return {
+      side: "buy",
+      size: delta2,
+      reduceOnly: false,
+      targetSize: desired2
+    };
+  }
+  if (mode === "long-only") {
+    if (currentSize <= 0) return null;
+    return {
+      side: "sell",
+      size: currentSize,
+      reduceOnly: true,
+      targetSize: 0
+    };
+  }
+  const desired = -Math.abs(targetSize);
+  const delta = currentSize - desired;
+  if (delta <= 0) return null;
+  return {
+    side: "sell",
+    size: delta,
+    reduceOnly: false,
+    targetSize: desired
+  };
+}
 
 // src/adapters/hyperliquid/order-utils.ts
 var MAX_HYPERLIQUID_PRICE_DECIMALS = 8;
@@ -3872,9 +4042,10 @@ function readHyperliquidSpotAccountValue(params) {
 
 // src/adapters/hyperliquid/market-data.ts
 var META_CACHE_TTL_MS = 5 * 60 * 1e3;
+var DEFAULT_OPENPOND_GATEWAY_URL = "https://gateway.openpond.dev";
 var allMidsCache = /* @__PURE__ */ new Map();
 function resolveGatewayBase(override) {
-  const value = override ?? process.env.OPENPOND_GATEWAY_URL ?? null;
+  const value = override ?? process.env.OPENPOND_GATEWAY_URL ?? DEFAULT_OPENPOND_GATEWAY_URL;
   if (typeof value !== "string") {
     return null;
   }
@@ -4043,6 +4214,25 @@ async function fetchHyperliquidBars(params) {
     return typeof record.close === "number" && Number.isFinite(record.close) && typeof record.time === "number" && Number.isFinite(record.time);
   });
 }
+function normalizeHyperliquidIndicatorBars(bars) {
+  return bars.filter(
+    (bar) => bar && typeof bar === "object" && typeof bar.time === "number" && Number.isFinite(bar.time) && typeof bar.close === "number" && Number.isFinite(bar.close)
+  ).map((bar) => {
+    const close = bar.close;
+    const open = typeof bar.open === "number" && Number.isFinite(bar.open) ? bar.open : close;
+    const high = typeof bar.high === "number" && Number.isFinite(bar.high) ? bar.high : close;
+    const low = typeof bar.low === "number" && Number.isFinite(bar.low) ? bar.low : close;
+    const volume = typeof bar.volume === "number" && Number.isFinite(bar.volume) ? bar.volume : 0;
+    return {
+      time: bar.time,
+      open,
+      high,
+      low,
+      close,
+      volume
+    };
+  });
+}
 async function fetchHyperliquidTickSize(params) {
   return fetchHyperliquidTickSizeForCoin(params.environment, params.symbol);
 }
@@ -4252,6 +4442,78 @@ var __hyperliquidMarketDataInternals = {
   formatScaledInt
 };
 
+// src/adapters/hyperliquid/utils.ts
+var DEFAULT_HYPERLIQUID_CADENCE_CRON = {
+  daily: "0 8 * * *",
+  hourly: "0 * * * *",
+  weekly: "0 8 * * 1",
+  "twice-weekly": "0 8 * * 1,4",
+  monthly: "0 8 1 * *"
+};
+function parseHyperliquidJson(raw) {
+  if (!raw) return null;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function clampHyperliquidInt(value, min, max, fallback) {
+  if (value == null) return fallback;
+  if (typeof value === "string" && value.trim().length === 0) return fallback;
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed)) return fallback;
+  const numeric = Math.trunc(parsed);
+  if (!Number.isFinite(numeric)) return fallback;
+  return Math.min(max, Math.max(min, numeric));
+}
+function clampHyperliquidFloat(value, min, max, fallback) {
+  if (value == null) return fallback;
+  if (typeof value === "string" && value.trim().length === 0) return fallback;
+  const numeric = Number(value);
+  if (!Number.isFinite(numeric)) return fallback;
+  return Math.min(max, Math.max(min, numeric));
+}
+function resolveHyperliquidScheduleEvery(input, options) {
+  const min = options?.min ?? 1;
+  const max = options?.max ?? 59;
+  const fallback = options?.fallback ?? 1;
+  return clampHyperliquidInt(input, min, max, fallback);
+}
+function resolveHyperliquidScheduleUnit(input, fallback = "hours") {
+  if (input === "minutes") return "minutes";
+  if (input === "hours") return "hours";
+  return fallback;
+}
+function resolveHyperliquidIntervalCron(every, unit) {
+  if (unit === "minutes") {
+    return every === 1 ? "* * * * *" : `*/${every} * * * *`;
+  }
+  return every === 1 ? "0 * * * *" : `0 */${every} * * *`;
+}
+function resolveHyperliquidHourlyInterval(input, fallback = 1) {
+  return clampHyperliquidInt(input, 1, 24, fallback);
+}
+function resolveHyperliquidCadenceCron(cadence, hourlyInterval, cadenceToCron = DEFAULT_HYPERLIQUID_CADENCE_CRON) {
+  if (cadence !== "hourly") {
+    return cadenceToCron[cadence];
+  }
+  const interval = resolveHyperliquidHourlyInterval(hourlyInterval, 1);
+  return interval === 1 ? cadenceToCron.hourly : `0 */${interval} * * *`;
+}
+function resolveHyperliquidCadenceFromResolution(resolution) {
+  if (resolution === "60") {
+    return { cadence: "hourly", hourlyInterval: 1 };
+  }
+  if (resolution === "240") {
+    return { cadence: "hourly", hourlyInterval: 4 };
+  }
+  if (resolution === "1W") {
+    return { cadence: "weekly" };
+  }
+  return { cadence: "daily" };
+}
+
 // src/adapters/hyperliquid/index.ts
 function assertPositiveDecimalInput(value, label) {
   if (typeof value === "number") {
@@ -4803,9 +5065,9 @@ function parseOptionalDate(value) {
 function buildHmacSignature(args) {
   const timestamp2 = args.timestamp.toString();
   const method = args.method.toUpperCase();
-  const path8 = args.path;
+  const path7 = args.path;
   const body = args.body == null ? "" : typeof args.body === "string" ? args.body : JSON.stringify(args.body);
-  const payload = `${timestamp2}${method}${path8}${body}`;
+  const payload = `${timestamp2}${method}${path7}${body}`;
   const key = Buffer.from(args.secret, "base64");
   return createHmac("sha256", key).update(payload).digest("hex");
 }
@@ -6158,9 +6420,9 @@ function assignIfDefined(target, key, value) {
     target[key] = value;
   }
 }
-function buildUrl(baseUrl, path8) {
+function buildUrl(baseUrl, path7) {
   const sanitizedBase = baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
-  return `${sanitizedBase}${path8}`;
+  return `${sanitizedBase}${path7}`;
 }
 function createAbortBundle(upstreamSignal, timeoutMs) {
   const controller = new AbortController();
@@ -6249,8 +6511,9 @@ function toAbortError(reason) {
   }
   return new AIAbortError(String(reason ?? "AI request aborted"));
 }
+var BACKTEST_DECISION_MODE = "backtest_decisions";
 var backtestDecisionRequestSchema = z.object({
-  mode: z.literal("backtest_decisions"),
+  mode: z.literal(BACKTEST_DECISION_MODE),
   source: z.string().min(1).optional(),
   symbol: z.string().min(1).optional(),
   lookbackDays: z.number().positive().optional(),
@@ -6312,6 +6575,57 @@ function estimateCountBack(params) {
   }
   return fallback;
 }
+function resolveBacktestMode(value) {
+  if (typeof value !== "string") return null;
+  const normalized = value.trim().toLowerCase();
+  return normalized === BACKTEST_DECISION_MODE ? BACKTEST_DECISION_MODE : null;
+}
+function resolveBacktestWindow(params) {
+  const fromSeconds = parseTimeToSeconds(params.from) ?? parseTimeToSeconds(params.timeframeStart);
+  const toSeconds = parseTimeToSeconds(params.to) ?? parseTimeToSeconds(params.timeframeEnd);
+  const hasWindow = fromSeconds != null && toSeconds != null && Number.isFinite(fromSeconds) && Number.isFinite(toSeconds) && toSeconds > fromSeconds;
+  const resolvedFrom = hasWindow ? fromSeconds : void 0;
+  const resolvedTo = hasWindow ? toSeconds : void 0;
+  const lookbackDays = typeof params.lookbackDays === "number" && Number.isFinite(params.lookbackDays) ? params.lookbackDays : void 0;
+  const countBack = estimateCountBack({
+    fallback: params.fallbackCountBack,
+    resolution: params.resolution,
+    ...lookbackDays != null ? { lookbackDays } : {},
+    ...resolvedFrom != null ? { fromSeconds: resolvedFrom } : {},
+    ...resolvedTo != null ? { toSeconds: resolvedTo } : {},
+    ...typeof params.minCountBack === "number" ? { minCountBack: params.minCountBack } : {},
+    ...typeof params.bufferBars === "number" ? { bufferBars: params.bufferBars } : {}
+  });
+  return {
+    ...resolvedFrom != null ? { fromSeconds: resolvedFrom } : {},
+    ...resolvedTo != null ? { toSeconds: resolvedTo } : {},
+    countBack
+  };
+}
+function resolveBacktestAccountValueUsd(value) {
+  if (typeof value === "number" && Number.isFinite(value) && value > 0) {
+    return value;
+  }
+  if (typeof value === "string" && value.trim().length > 0) {
+    const parsed = Number.parseFloat(value.trim());
+    if (Number.isFinite(parsed) && parsed > 0) {
+      return parsed;
+    }
+  }
+  return void 0;
+}
+function buildBacktestDecisionSeriesInput(request) {
+  const accountValueUsd = resolveBacktestAccountValueUsd(request.initialEquityUsd);
+  return {
+    ...request.symbol ? { symbol: request.symbol } : {},
+    ...request.timeframeStart ? { timeframeStart: request.timeframeStart } : {},
+    ...request.timeframeEnd ? { timeframeEnd: request.timeframeEnd } : {},
+    ...request.from != null ? { from: request.from } : {},
+    ...request.to != null ? { to: request.to } : {},
+    ...request.lookbackDays != null ? { lookbackDays: request.lookbackDays } : {},
+    ...accountValueUsd != null ? { accountValueUsd } : {}
+  };
+}
 var METADATA_SPEC_VERSION = "1.1.0";
 var McpAnnotationsSchema = z.object({
   title: z.string().optional(),
@@ -6430,8 +6744,8 @@ var BuildMetadataSchema = z.object({
   chains: z.array(z.union([z.string(), z.number()])).optional()
 }).strict();
 function resolveTsconfig(projectRoot) {
-  const candidate = path6.join(projectRoot, "tsconfig.json");
-  if (fs2.existsSync(candidate)) {
+  const candidate = path5.join(projectRoot, "tsconfig.json");
+  if (fs4.existsSync(candidate)) {
     return candidate;
   }
   return void 0;
@@ -6441,9 +6755,9 @@ async function transpileWithEsbuild(options) {
     throw new Error("No entry points provided for esbuild transpilation");
   }
   const projectRoot = options.projectRoot;
-  const tempBase = options.outDir ?? fs2.mkdtempSync(path6.join(tmpdir(), "opentool-"));
-  if (!fs2.existsSync(tempBase)) {
-    fs2.mkdirSync(tempBase, { recursive: true });
+  const tempBase = options.outDir ?? fs4.mkdtempSync(path5.join(tmpdir(), "opentool-"));
+  if (!fs4.existsSync(tempBase)) {
+    fs4.mkdirSync(tempBase, { recursive: true });
   }
   const tsconfig = resolveTsconfig(projectRoot);
   const buildOptions = {
@@ -6474,6 +6788,9 @@ async function transpileWithEsbuild(options) {
   if (options.external && options.external.length > 0) {
     buildOptions.external = options.external;
   }
+  if (options.nodePaths && options.nodePaths.length > 0) {
+    buildOptions.nodePaths = options.nodePaths;
+  }
   if (options.outBase) {
     buildOptions.outbase = options.outBase;
   }
@@ -6485,25 +6802,25 @@ async function transpileWithEsbuild(options) {
   }
   await build(buildOptions);
   if (options.format === "esm") {
-    const packageJsonPath = path6.join(tempBase, "package.json");
-    if (!fs2.existsSync(packageJsonPath)) {
-      fs2.writeFileSync(packageJsonPath, JSON.stringify({ type: "module" }), "utf8");
+    const packageJsonPath = path5.join(tempBase, "package.json");
+    if (!fs4.existsSync(packageJsonPath)) {
+      fs4.writeFileSync(packageJsonPath, JSON.stringify({ type: "module" }), "utf8");
     }
   }
   const cleanup = () => {
     if (options.outDir) {
       return;
     }
-    fs2.rmSync(tempBase, { recursive: true, force: true });
+    fs4.rmSync(tempBase, { recursive: true, force: true });
   };
   return { outDir: tempBase, cleanup };
 }
 createRequire(
-  typeof __filename$1 !== "undefined" ? __filename$1 : import.meta.url
+  typeof __filename !== "undefined" ? __filename : import.meta.url
 );
 function resolveCompiledPath(outDir, originalFile, extension = ".js") {
-  const baseName = path6.basename(originalFile).replace(/\.[^.]+$/, "");
-  return path6.join(outDir, `${baseName}${extension}`);
+  const baseName = path5.basename(originalFile).replace(/\.[^.]+$/, "");
+  return path5.join(outDir, `${baseName}${extension}`);
 }
 async function importFresh(modulePath) {
   const fileUrl = pathToFileURL(modulePath).href;
@@ -6515,16 +6832,16 @@ async function importFresh(modulePath) {
 // src/cli/shared/metadata.ts
 var METADATA_ENTRY = "metadata.ts";
 async function loadMetadata2(projectRoot) {
-  const absPath = path6.join(projectRoot, METADATA_ENTRY);
-  if (!fs2.existsSync(absPath)) {
+  const absPath = path5.join(projectRoot, METADATA_ENTRY);
+  if (!fs4.existsSync(absPath)) {
     return {
       metadata: MetadataSchema.parse({}),
       sourcePath: "smart defaults (metadata.ts missing)"
     };
   }
-  const tempDir = path6.join(projectRoot, ".opentool-temp");
-  if (fs2.existsSync(tempDir)) {
-    fs2.rmSync(tempDir, { recursive: true, force: true });
+  const tempDir = path5.join(projectRoot, ".opentool-temp");
+  if (fs4.existsSync(tempDir)) {
+    fs4.rmSync(tempDir, { recursive: true, force: true });
   }
   const { outDir, cleanup } = await transpileWithEsbuild({
     entryPoints: [absPath],
@@ -6540,8 +6857,8 @@ async function loadMetadata2(projectRoot) {
     return { metadata: parsed, sourcePath: absPath };
   } finally {
     cleanup();
-    if (fs2.existsSync(tempDir)) {
-      fs2.rmSync(tempDir, { recursive: true, force: true });
+    if (fs4.existsSync(tempDir)) {
+      fs4.rmSync(tempDir, { recursive: true, force: true });
     }
   }
 }
@@ -6563,12 +6880,12 @@ function extractMetadataExport(moduleExports) {
   return moduleExports;
 }
 function readPackageJson(projectRoot) {
-  const packagePath = path6.join(projectRoot, "package.json");
-  if (!fs2.existsSync(packagePath)) {
+  const packagePath = path5.join(projectRoot, "package.json");
+  if (!fs4.existsSync(packagePath)) {
     return {};
   }
   try {
-    const content = fs2.readFileSync(packagePath, "utf8");
+    const content = fs4.readFileSync(packagePath, "utf8");
     return JSON.parse(content);
   } catch (error) {
     throw new Error(`Failed to read package.json: ${error}`);
@@ -6579,7 +6896,7 @@ async function buildMetadataArtifact(options) {
   const packageInfo = readPackageJson(projectRoot);
   const { metadata: authored, sourcePath } = await loadMetadata2(projectRoot);
   const defaultsApplied = [];
-  const folderName = path6.basename(projectRoot);
+  const folderName = path5.basename(projectRoot);
   const name = resolveField(
     "name",
     authored.name,
@@ -6791,6 +7108,8 @@ function validateCronTokens(fields, context) {
 
 // src/cli/validate.ts
 var SUPPORTED_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"];
+var OPENTOOL_ROOT = path5.resolve(path5.dirname(fileURLToPath(import.meta.url)), "../..");
+var OPENTOOL_NODE_MODULES = path5.join(OPENTOOL_ROOT, "node_modules");
 var MIN_TEMPLATE_CONFIG_VERSION = 2;
 var TEMPLATE_PREVIEW_TITLE_MAX = 80;
 var TEMPLATE_PREVIEW_SUBTITLE_MAX = 120;
@@ -6877,37 +7196,37 @@ function normalizeTemplatePreview(value, file, toolName, requirePreview) {
   };
 }
 async function validateCommand(options) {
-  console.log("\u{1F50D} Validating OpenTool metadata...");
+  console.log("\u{1F50D} Validating OpenTool project...");
   try {
-    const toolsDir = path6.resolve(options.input);
-    if (!fs2.existsSync(toolsDir)) {
+    const toolsDir = path5.resolve(options.input);
+    if (!fs4.existsSync(toolsDir)) {
       throw new Error(`Tools directory not found: ${toolsDir}`);
     }
-    const projectRoot = path6.dirname(toolsDir);
+    const projectRoot = path5.dirname(toolsDir);
     const tools = await loadAndValidateTools(toolsDir, { projectRoot });
     if (tools.length === 0) {
-      throw new Error("No valid tools found - metadata validation aborted");
+      throw new Error("No valid tools found - validation aborted");
     }
     const { metadata, defaultsApplied, sourceMetadataPath } = await buildMetadataArtifact({
       projectRoot,
       tools
     });
     logMetadataSummary(metadata, defaultsApplied, sourceMetadataPath);
-    console.log("\n\u2705 Metadata validation passed!\n");
+    console.log("\n\u2705 OpenTool validation passed!\n");
   } catch (error) {
-    console.error("\u274C Metadata validation failed:", error);
+    console.error("\u274C OpenTool validation failed:", error);
     process.exit(1);
   }
 }
 async function loadAndValidateTools(toolsDir, options = {}) {
-  const files = fs2.readdirSync(toolsDir).filter((file) => SUPPORTED_EXTENSIONS.includes(path6.extname(file)));
+  const files = fs4.readdirSync(toolsDir).filter((file) => SUPPORTED_EXTENSIONS.includes(path5.extname(file)));
   if (files.length === 0) {
     return [];
   }
-  const projectRoot = options.projectRoot ?? path6.dirname(toolsDir);
-  const tempDir = path6.join(toolsDir, ".opentool-temp");
-  if (fs2.existsSync(tempDir)) {
-    fs2.rmSync(tempDir, { recursive: true, force: true });
+  const projectRoot = options.projectRoot ?? path5.dirname(toolsDir);
+  const tempDir = path5.join(toolsDir, ".opentool-temp");
+  if (fs4.existsSync(tempDir)) {
+    fs4.rmSync(tempDir, { recursive: true, force: true });
   }
   const kebabCase = /^[a-z0-9]+(?:-[a-z0-9]+)*\.[a-z]+$/;
   for (const f of files) {
@@ -6915,20 +7234,23 @@ async function loadAndValidateTools(toolsDir, options = {}) {
       throw new Error(`Tool filename must be kebab-case: ${f}`);
     }
   }
-  const entryPoints = files.map((file) => path6.join(toolsDir, file));
+  const entryPoints = files.map((file) => path5.join(toolsDir, file));
+  const fallbackNodePaths = [OPENTOOL_NODE_MODULES].filter((dir) => fs4.existsSync(dir));
   const { outDir, cleanup } = await transpileWithEsbuild({
     entryPoints,
     projectRoot,
     format: "esm",
     outDir: tempDir,
     bundle: true,
-    external: ["opentool", "opentool/*"]
+    external: ["opentool", "opentool/*"],
+    ...fallbackNodePaths.length > 0 ? { nodePaths: fallbackNodePaths } : {}
   });
   const tools = [];
   try {
+    ensureLocalRuntimeLinks(tempDir);
     for (const file of files) {
       const compiledPath = resolveCompiledPath(outDir, file);
-      if (!fs2.existsSync(compiledPath)) {
+      if (!fs4.existsSync(compiledPath)) {
         throw new Error(`Failed to compile ${file}`);
       }
       const moduleExports = await importFresh(compiledPath);
@@ -7079,11 +7401,6 @@ async function loadAndValidateTools(toolsDir, options = {}) {
         if (!schema) {
           throw new Error(`${file}: POST tools must export a Zod schema as 'schema'`);
         }
-        if (schedule && typeof schedule.cron === "string") {
-          throw new Error(
-            `${file}: POST tools must not define profile.schedule; use GET + cron for scheduled tasks.`
-          );
-        }
       }
       const httpHandlers = [...httpHandlersRaw];
       if (httpHandlers.length === 0) {
@@ -7131,7 +7448,7 @@ async function loadAndValidateTools(toolsDir, options = {}) {
         httpHandlers,
         mcpConfig: normalizeMcpConfig(toolModule.mcp, file),
         filename: toBaseName(file),
-        sourcePath: path6.join(toolsDir, file),
+        sourcePath: path5.join(toolsDir, file),
         handler: async (params) => adapter(params),
         payment: paymentExport ?? null,
         schedule: normalizedSchedule,
@@ -7144,12 +7461,30 @@ async function loadAndValidateTools(toolsDir, options = {}) {
     }
   } finally {
     cleanup();
-    if (fs2.existsSync(tempDir)) {
-      fs2.rmSync(tempDir, { recursive: true, force: true });
+    if (fs4.existsSync(tempDir)) {
+      fs4.rmSync(tempDir, { recursive: true, force: true });
     }
   }
   return tools;
 }
+function ensureLocalRuntimeLinks(tempDir) {
+  const nodeModulesDir = path5.join(tempDir, "node_modules");
+  fs4.mkdirSync(nodeModulesDir, { recursive: true });
+  const packageLinks = [
+    { name: "opentool", target: OPENTOOL_ROOT },
+    { name: "zod", target: path5.join(OPENTOOL_NODE_MODULES, "zod") }
+  ];
+  for (const { name, target } of packageLinks) {
+    if (!fs4.existsSync(target)) {
+      continue;
+    }
+    const linkPath = path5.join(nodeModulesDir, name);
+    if (fs4.existsSync(linkPath)) {
+      continue;
+    }
+    fs4.symlinkSync(target, linkPath, "junction");
+  }
+}
 function extractToolModule(exportsObject, filename) {
   const candidates = [exportsObject, exportsObject?.default];
   for (const candidate of candidates) {
@@ -7347,18 +7682,18 @@ async function generateMetadataCommand(options) {
   }
 }
 async function generateMetadata(options) {
-  const toolsDir = path6.resolve(options.input);
-  if (!fs2.existsSync(toolsDir)) {
+  const toolsDir = path5.resolve(options.input);
+  if (!fs4.existsSync(toolsDir)) {
     throw new Error(`Tools directory not found: ${toolsDir}`);
   }
-  const projectRoot = path6.dirname(toolsDir);
+  const projectRoot = path5.dirname(toolsDir);
   const tools = await loadAndValidateTools(toolsDir, { projectRoot });
   const { metadata, defaultsApplied } = await buildMetadataArtifact({
     projectRoot,
     tools
   });
-  const outputPath = options.output ? path6.resolve(options.output) : path6.join(projectRoot, "metadata.json");
-  fs2.writeFileSync(outputPath, JSON.stringify(metadata, null, 2));
+  const outputPath = options.output ? path5.resolve(options.output) : path5.join(projectRoot, "metadata.json");
+  fs4.writeFileSync(outputPath, JSON.stringify(metadata, null, 2));
   return {
     metadata,
     defaultsApplied,
@@ -7370,6 +7705,6 @@ function timestamp() {
   return (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 19);
 }
 
-export { AIAbortError, AIError, AIFetchError, AIResponseError, DEFAULT_BASE_URL, DEFAULT_CHAIN, DEFAULT_FACILITATOR, DEFAULT_HYPERLIQUID_MARKET_SLIPPAGE_BPS, DEFAULT_MODEL, DEFAULT_TIMEOUT_MS, DEFAULT_TOKENS, HTTP_METHODS2 as HTTP_METHODS, HyperliquidApiError, HyperliquidBuilderApprovalError, HyperliquidExchangeClient, HyperliquidGuardError, HyperliquidInfoClient, HyperliquidTermsError, PAYMENT_HEADERS, POLYMARKET_CHAIN_ID, POLYMARKET_CLOB_AUTH_DOMAIN, POLYMARKET_CLOB_DOMAIN, POLYMARKET_ENDPOINTS, POLYMARKET_EXCHANGE_ADDRESSES, PolymarketApiError, PolymarketAuthError, PolymarketExchangeClient, PolymarketInfoClient, SUPPORTED_CURRENCIES, StoreError, WEBSEARCH_TOOL_DEFINITION, WEBSEARCH_TOOL_NAME, X402BrowserClient, X402Client, X402PaymentRequiredError, __hyperliquidInternals, __hyperliquidMarketDataInternals, approveHyperliquidBuilderFee, backtestDecisionRequestSchema, batchModifyHyperliquidOrders, buildHmacSignature, buildHyperliquidMarketIdentity, buildHyperliquidProfileAssets, buildHyperliquidSpotUsdPriceMap, buildL1Headers, buildL2Headers, buildPolymarketOrderAmounts, buildSignedOrderPayload, cancelAllHyperliquidOrders, cancelAllPolymarketOrders, cancelHyperliquidOrders, cancelHyperliquidOrdersByCloid, cancelHyperliquidTwapOrder, cancelMarketPolymarketOrders, cancelPolymarketOrder, cancelPolymarketOrders, chains, computeHyperliquidMarketIocLimitPrice, createAIClient, createDevServer, createHyperliquidSubAccount, createMcpAdapter, createMonotonicNonceFactory, createPolymarketApiKey, createStdioServer, defineX402Payment, depositToHyperliquidBridge, derivePolymarketApiKey, ensureTextContent, estimateCountBack, executeTool, extractHyperliquidDex, extractHyperliquidOrderIds, fetchHyperliquidAllMids, fetchHyperliquidAssetCtxs, fetchHyperliquidBars, fetchHyperliquidClearinghouseState, fetchHyperliquidFrontendOpenOrders, fetchHyperliquidHistoricalOrders, fetchHyperliquidMeta, fetchHyperliquidMetaAndAssetCtxs, fetchHyperliquidOpenOrders, fetchHyperliquidOrderStatus, fetchHyperliquidPerpMarketInfo, fetchHyperliquidPreTransferCheck, fetchHyperliquidSizeDecimals, fetchHyperliquidSpotAccountValue, fetchHyperliquidSpotAssetCtxs, fetchHyperliquidSpotClearinghouseState, fetchHyperliquidSpotMarketInfo, fetchHyperliquidSpotMeta, fetchHyperliquidSpotMetaAndAssetCtxs, fetchHyperliquidSpotTickSize, fetchHyperliquidSpotUsdPriceMap, fetchHyperliquidTickSize, fetchHyperliquidUserFills, fetchHyperliquidUserFillsByTime, fetchHyperliquidUserRateLimit, fetchPolymarketMarket, fetchPolymarketMarkets, fetchPolymarketMidpoint, fetchPolymarketOrderbook, fetchPolymarketPrice, fetchPolymarketPriceHistory, flattenMessageContent, formatHyperliquidMarketablePrice, formatHyperliquidOrderSize, formatHyperliquidPrice, formatHyperliquidSize, generateMetadata, generateMetadataCommand, generateText, getHyperliquidMaxBuilderFee, getModelConfig, getMyPerformance, getMyTools, getRpcUrl, getX402PaymentContext, isHyperliquidSpotSymbol, isStreamingSupported, isToolCallingSupported, listModels, loadAndValidateTools, modifyHyperliquidOrder, normalizeHyperliquidBaseSymbol, normalizeHyperliquidMetaSymbol, normalizeModelName, normalizeNumberArrayish, normalizeSpotTokenName2 as normalizeSpotTokenName, normalizeStringArrayish, parseSpotPairSymbol, parseTimeToSeconds, payX402, payX402WithWallet, placeHyperliquidOrder, placeHyperliquidTwapOrder, placePolymarketOrder, postAgentDigest, readHyperliquidAccountValue, readHyperliquidNumber, readHyperliquidPerpPosition, readHyperliquidPerpPositionSize, readHyperliquidSpotAccountValue, readHyperliquidSpotBalance, readHyperliquidSpotBalanceSize, recordHyperliquidBuilderApproval, recordHyperliquidTermsAcceptance, registry, requireX402Payment, reserveHyperliquidRequestWeight, resolutionToSeconds, resolveConfig2 as resolveConfig, resolveExchangeAddress, resolveHyperliquidAbstractionFromMode, resolveHyperliquidChain, resolveHyperliquidChainConfig, resolveHyperliquidErrorDetail, resolveHyperliquidOrderRef, resolveHyperliquidOrderSymbol, resolveHyperliquidPair, resolveHyperliquidProfileChain, resolveHyperliquidRpcEnvVar, resolveHyperliquidStoreNetwork, resolveHyperliquidSymbol, resolvePolymarketBaseUrl, resolveRuntimePath, resolveSpotMidCandidates, resolveSpotTokenCandidates, resolveToolset, responseToToolResponse, retrieve, roundHyperliquidPriceToTick, scheduleHyperliquidCancel, sendHyperliquidSpot, setHyperliquidAccountAbstractionMode, setHyperliquidDexAbstraction, setHyperliquidPortfolioMargin, store, streamText, tokens, transferHyperliquidSubAccount, updateHyperliquidIsolatedMargin, updateHyperliquidLeverage, validateCommand, wallet, walletToolkit, withX402Payment, withdrawFromHyperliquid };
+export { AIAbortError, AIError, AIFetchError, AIResponseError, BACKTEST_DECISION_MODE, DEFAULT_BASE_URL, DEFAULT_CHAIN, DEFAULT_FACILITATOR, DEFAULT_HYPERLIQUID_CADENCE_CRON, DEFAULT_HYPERLIQUID_MARKET_SLIPPAGE_BPS, DEFAULT_MODEL, DEFAULT_TIMEOUT_MS, DEFAULT_TOKENS, HTTP_METHODS2 as HTTP_METHODS, HyperliquidApiError, HyperliquidBuilderApprovalError, HyperliquidExchangeClient, HyperliquidGuardError, HyperliquidInfoClient, HyperliquidTermsError, PAYMENT_HEADERS, POLYMARKET_CHAIN_ID, POLYMARKET_CLOB_AUTH_DOMAIN, POLYMARKET_CLOB_DOMAIN, POLYMARKET_ENDPOINTS, POLYMARKET_EXCHANGE_ADDRESSES, PolymarketApiError, PolymarketAuthError, PolymarketExchangeClient, PolymarketInfoClient, SUPPORTED_CURRENCIES, StoreError, WEBSEARCH_TOOL_DEFINITION, WEBSEARCH_TOOL_NAME, X402BrowserClient, X402Client, X402PaymentRequiredError, __hyperliquidInternals, __hyperliquidMarketDataInternals, approveHyperliquidBuilderFee, backtestDecisionRequestSchema, batchModifyHyperliquidOrders, buildBacktestDecisionSeriesInput, buildHmacSignature, buildHyperliquidMarketIdentity, buildHyperliquidProfileAssets, buildHyperliquidSpotUsdPriceMap, buildL1Headers, buildL2Headers, buildPolymarketOrderAmounts, buildSignedOrderPayload, cancelAllHyperliquidOrders, cancelAllPolymarketOrders, cancelHyperliquidOrders, cancelHyperliquidOrdersByCloid, cancelHyperliquidTwapOrder, cancelMarketPolymarketOrders, cancelPolymarketOrder, cancelPolymarketOrders, chains, clampHyperliquidAbs, clampHyperliquidFloat, clampHyperliquidInt, computeHyperliquidMarketIocLimitPrice, createAIClient, createDevServer, createHyperliquidSubAccount, createMcpAdapter, createMonotonicNonceFactory, createPolymarketApiKey, createStdioServer, defineX402Payment, depositToHyperliquidBridge, derivePolymarketApiKey, ensureTextContent, estimateCountBack, executeTool, extractHyperliquidDex, extractHyperliquidOrderIds, fetchHyperliquidAllMids, fetchHyperliquidAssetCtxs, fetchHyperliquidBars, fetchHyperliquidClearinghouseState, fetchHyperliquidFrontendOpenOrders, fetchHyperliquidHistoricalOrders, fetchHyperliquidMeta, fetchHyperliquidMetaAndAssetCtxs, fetchHyperliquidOpenOrders, fetchHyperliquidOrderStatus, fetchHyperliquidPerpMarketInfo, fetchHyperliquidPreTransferCheck, fetchHyperliquidSizeDecimals, fetchHyperliquidSpotAccountValue, fetchHyperliquidSpotAssetCtxs, fetchHyperliquidSpotClearinghouseState, fetchHyperliquidSpotMarketInfo, fetchHyperliquidSpotMeta, fetchHyperliquidSpotMetaAndAssetCtxs, fetchHyperliquidSpotTickSize, fetchHyperliquidSpotUsdPriceMap, fetchHyperliquidTickSize, fetchHyperliquidUserFills, fetchHyperliquidUserFillsByTime, fetchHyperliquidUserRateLimit, fetchPolymarketMarket, fetchPolymarketMarkets, fetchPolymarketMidpoint, fetchPolymarketOrderbook, fetchPolymarketPrice, fetchPolymarketPriceHistory, flattenMessageContent, formatHyperliquidMarketablePrice, formatHyperliquidOrderSize, formatHyperliquidPrice, formatHyperliquidSize, generateMetadata, generateMetadataCommand, generateText, getHyperliquidMaxBuilderFee, getModelConfig, getMyPerformance, getMyTools, getRpcUrl, getX402PaymentContext, isHyperliquidSpotSymbol, isStreamingSupported, isToolCallingSupported, listModels, loadAndValidateTools, modifyHyperliquidOrder, normalizeHyperliquidBaseSymbol, normalizeHyperliquidDcaEntries, normalizeHyperliquidIndicatorBars, normalizeHyperliquidMetaSymbol, normalizeModelName, normalizeNumberArrayish, normalizeSpotTokenName2 as normalizeSpotTokenName, normalizeStringArrayish, parseHyperliquidJson, parseSpotPairSymbol, parseTimeToSeconds, payX402, payX402WithWallet, placeHyperliquidOrder, placeHyperliquidTwapOrder, placePolymarketOrder, planHyperliquidTrade, postAgentDigest, readHyperliquidAccountValue, readHyperliquidNumber, readHyperliquidPerpPosition, readHyperliquidPerpPositionSize, readHyperliquidSpotAccountValue, readHyperliquidSpotBalance, readHyperliquidSpotBalanceSize, recordHyperliquidBuilderApproval, recordHyperliquidTermsAcceptance, registry, requireX402Payment, reserveHyperliquidRequestWeight, resolutionToSeconds, resolveBacktestAccountValueUsd, resolveBacktestMode, resolveBacktestWindow, resolveConfig2 as resolveConfig, resolveExchangeAddress, resolveHyperliquidAbstractionFromMode, resolveHyperliquidBudgetUsd, resolveHyperliquidCadenceCron, resolveHyperliquidCadenceFromResolution, resolveHyperliquidChain, resolveHyperliquidChainConfig, resolveHyperliquidDcaSymbolEntries, resolveHyperliquidErrorDetail, resolveHyperliquidHourlyInterval, resolveHyperliquidIntervalCron, resolveHyperliquidLeverageMode, resolveHyperliquidMaxPerRunUsd, resolveHyperliquidOrderRef, resolveHyperliquidOrderSymbol, resolveHyperliquidPair, resolveHyperliquidPerpSymbol, resolveHyperliquidProfileChain, resolveHyperliquidRpcEnvVar, resolveHyperliquidScheduleEvery, resolveHyperliquidScheduleUnit, resolveHyperliquidSpotSymbol, resolveHyperliquidStoreNetwork, resolveHyperliquidSymbol, resolveHyperliquidTargetSize, resolvePolymarketBaseUrl, resolveRuntimePath, resolveSpotMidCandidates, resolveSpotTokenCandidates, resolveToolset, responseToToolResponse, retrieve, roundHyperliquidPriceToTick, scheduleHyperliquidCancel, sendHyperliquidSpot, setHyperliquidAccountAbstractionMode, setHyperliquidDexAbstraction, setHyperliquidPortfolioMargin, store, streamText, tokens, transferHyperliquidSubAccount, updateHyperliquidIsolatedMargin, updateHyperliquidLeverage, validateCommand, wallet, walletToolkit, withX402Payment, withdrawFromHyperliquid };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map