@compass-labs/api-sdk 1.0.10 → 1.0.12

package/bin/mcp-server.js

@@ -34264,9 +34264,9 @@ var init_config = __esm(() => {
   SDK_METADATA = {
     language: "typescript",
     openapiDocVersion: "0.0.1",
-    sdkVersion: "1.0.10",
+    sdkVersion: "1.0.12",
     genVersion: "2.681.1",
-    userAgent: "speakeasy-sdk/typescript 1.0.10 2.681.1 0.0.1 @compass-labs/api-sdk"
+    userAgent: "speakeasy-sdk/typescript 1.0.12 2.681.1 0.0.1 @compass-labs/api-sdk"
   };
 });
 
@@ -40815,6 +40815,50 @@ var init_markettokens = __esm(() => {
   })(MarketTokens$ ||= {});
 });
 
+// src/models/components/metamaskdelegatorrequest.ts
+var MetamaskDelegatorRequestChain, MetamaskDelegatorRequestChain$inboundSchema, MetamaskDelegatorRequestChain$outboundSchema, MetamaskDelegatorRequestChain$, MetamaskDelegatorRequest$inboundSchema, MetamaskDelegatorRequest$outboundSchema, MetamaskDelegatorRequest$;
+var init_metamaskdelegatorrequest = __esm(() => {
+  init_zod();
+  init_primitives();
+  init_signedauthorization();
+  init_useroperation();
+  MetamaskDelegatorRequestChain = {
+    Arbitrum: "arbitrum",
+    Base: "base",
+    Ethereum: "ethereum"
+  };
+  MetamaskDelegatorRequestChain$inboundSchema = nativeEnumType(MetamaskDelegatorRequestChain);
+  MetamaskDelegatorRequestChain$outboundSchema = MetamaskDelegatorRequestChain$inboundSchema;
+  ((MetamaskDelegatorRequestChain$) => {
+    MetamaskDelegatorRequestChain$.inboundSchema = MetamaskDelegatorRequestChain$inboundSchema;
+    MetamaskDelegatorRequestChain$.outboundSchema = MetamaskDelegatorRequestChain$outboundSchema;
+  })(MetamaskDelegatorRequestChain$ ||= {});
+  MetamaskDelegatorRequest$inboundSchema = objectType({
+    chain: MetamaskDelegatorRequestChain$inboundSchema,
+    sender: stringType(),
+    signed_authorization: nullableType(SignedAuthorization$inboundSchema).optional(),
+    actions: arrayType(UserOperation$inboundSchema)
+  }).transform((v2) => {
+    return remap(v2, {
+      signed_authorization: "signedAuthorization"
+    });
+  });
+  MetamaskDelegatorRequest$outboundSchema = objectType({
+    chain: MetamaskDelegatorRequestChain$outboundSchema,
+    sender: stringType(),
+    signedAuthorization: nullableType(SignedAuthorization$outboundSchema).optional(),
+    actions: arrayType(UserOperation$outboundSchema)
+  }).transform((v2) => {
+    return remap(v2, {
+      signedAuthorization: "signed_authorization"
+    });
+  });
+  ((MetamaskDelegatorRequest$) => {
+    MetamaskDelegatorRequest$.inboundSchema = MetamaskDelegatorRequest$inboundSchema;
+    MetamaskDelegatorRequest$.outboundSchema = MetamaskDelegatorRequest$outboundSchema;
+  })(MetamaskDelegatorRequest$ ||= {});
+});
+
 // src/models/components/morphoborrowrequest.ts
 var MorphoBorrowRequestChain, MorphoBorrowRequestAmount$inboundSchema, MorphoBorrowRequestAmount$outboundSchema, MorphoBorrowRequestAmount$, MorphoBorrowRequestChain$inboundSchema, MorphoBorrowRequestChain$outboundSchema, MorphoBorrowRequestChain$, MorphoBorrowRequest$inboundSchema, MorphoBorrowRequest$outboundSchema, MorphoBorrowRequest$;
 var init_morphoborrowrequest = __esm(() => {
@@ -41622,6 +41666,53 @@ var init_odosswaprequest = __esm(() => {
   })(OdosSwapRequest$ ||= {});
 });
 
+// src/models/components/odostransactionresponse.ts
+var OdosTransactionResponseTransaction$inboundSchema, OdosTransactionResponseTransaction$outboundSchema, OdosTransactionResponseTransaction$, OdosTransactionResponse$inboundSchema, OdosTransactionResponse$outboundSchema, OdosTransactionResponse$;
+var init_odostransactionresponse = __esm(() => {
+  init_zod();
+  init_primitives();
+  init_unsignedtransaction();
+  init_useroperationresponse();
+  OdosTransactionResponseTransaction$inboundSchema = unionType([
+    UnsignedTransaction$inboundSchema,
+    UserOperationResponse$inboundSchema
+  ]);
+  OdosTransactionResponseTransaction$outboundSchema = unionType([
+    UnsignedTransaction$outboundSchema,
+    UserOperationResponse$outboundSchema
+  ]);
+  ((OdosTransactionResponseTransaction$) => {
+    OdosTransactionResponseTransaction$.inboundSchema = OdosTransactionResponseTransaction$inboundSchema;
+    OdosTransactionResponseTransaction$.outboundSchema = OdosTransactionResponseTransaction$outboundSchema;
+  })(OdosTransactionResponseTransaction$ ||= {});
+  OdosTransactionResponse$inboundSchema = objectType({
+    transaction: unionType([
+      UnsignedTransaction$inboundSchema,
+      UserOperationResponse$inboundSchema
+    ]),
+    amount_out_quote: stringType()
+  }).transform((v2) => {
+    return remap(v2, {
+      amount_out_quote: "amountOutQuote"
+    });
+  });
+  OdosTransactionResponse$outboundSchema = objectType({
+    transaction: unionType([
+      UnsignedTransaction$outboundSchema,
+      UserOperationResponse$outboundSchema
+    ]),
+    amountOutQuote: stringType()
+  }).transform((v2) => {
+    return remap(v2, {
+      amountOutQuote: "amount_out_quote"
+    });
+  });
+  ((OdosTransactionResponse$) => {
+    OdosTransactionResponse$.inboundSchema = OdosTransactionResponse$inboundSchema;
+    OdosTransactionResponse$.outboundSchema = OdosTransactionResponse$outboundSchema;
+  })(OdosTransactionResponse$ ||= {});
+});
+
 // src/models/components/openposition.ts
 var OpenPosition$inboundSchema, OpenPosition$outboundSchema, OpenPosition$;
 var init_openposition = __esm(() => {
@@ -43775,6 +43866,7 @@ var init_components = __esm(() => {
   init_market();
   init_marketposition();
   init_markettokens();
+  init_metamaskdelegatorrequest();
   init_morphoborrowparams();
   init_morphoborrowrequest();
   init_morphocheckmarketpositionresponse();
@@ -43800,6 +43892,7 @@ var init_components = __esm(() => {
   init_multicallexecuterequest();
   init_odosswapparams();
   init_odosswaprequest();
+  init_odostransactionresponse();
   init_openposition();
   init_pendlegetmarketresponse();
   init_pendlelistmarketsresponse();
@@ -52750,7 +52843,7 @@ async function $do54(client, request, options) {
   const responseFields = {
     HttpMeta: { Response: response, Request: req }
   };
-  const [result] = await match(json(200, TransactionResponse$inboundSchema), jsonErr(422, HTTPValidationError$inboundSchema), fail("4XX"), fail("5XX"))(response, req, { extraFields: responseFields });
+  const [result] = await match(json(200, OdosTransactionResponse$inboundSchema), jsonErr(422, HTTPValidationError$inboundSchema), fail("4XX"), fail("5XX"))(response, req, { extraFields: responseFields });
   if (!result.ok) {
     return [result, { status: "complete", request: req, response }];
   }
@@ -53569,11 +53662,115 @@ prevent replay attacks.`,
   };
 });
 
-// src/funcs/uniswapV3UniswapLiquidityProvisionIncrease.ts
-function uniswapV3UniswapLiquidityProvisionIncrease(client, request, options) {
+// src/funcs/transactionBundlerTransactionBundlerMetamaskExecute.ts
+function transactionBundlerTransactionBundlerMetamaskExecute(client, request, options) {
   return new APIPromise($do62(client, request, options));
 }
 async function $do62(client, request, options) {
+  const parsed = safeParse(request, (value) => MetamaskDelegatorRequest$outboundSchema.parse(value), "Input validation failed");
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = encodeJSON("body", payload, { explode: true });
+  const path = pathToFunc("/v1/transaction_bundler/metamask/execute")();
+  const headers = new Headers(compactMap({
+    "Content-Type": "application/json",
+    Accept: "application/json"
+  }));
+  const secConfig = await extractSecurity(client._options.apiKeyAuth);
+  const securityInput = secConfig == null ? {} : { apiKeyAuth: secConfig };
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    options: client._options,
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "v1_transaction_bundler_metamask_execute",
+    oAuth2Scopes: [],
+    resolvedSecurity: requestSecurity,
+    securitySource: client._options.apiKeyAuth,
+    retryConfig: options?.retries || client._options.retryConfig || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"]
+  };
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "POST",
+    baseURL: options?.serverURL,
+    path,
+    headers,
+    body,
+    userAgent: client._options.userAgent,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req = requestRes.value;
+  const doResult = await client._do(req, {
+    context,
+    errorCodes: ["422", "4XX", "5XX"],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+  const responseFields = {
+    HttpMeta: { Response: response, Request: req }
+  };
+  const [result] = await match(json(200, BundlerTransactionResponse$inboundSchema), jsonErr(422, HTTPValidationError$inboundSchema), fail("4XX"), fail("5XX"))(response, req, { extraFields: responseFields });
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+  return [result, { status: "complete", request: req, response }];
+}
+var init_transactionBundlerTransactionBundlerMetamaskExecute = __esm(() => {
+  init_encodings();
+  init_matchers();
+  init_primitives();
+  init_schemas();
+  init_security();
+  init_url();
+  init_components();
+  init_errors2();
+  init_async();
+});
+
+// src/mcp-server/tools/transactionBundlerTransactionBundlerMetamaskExecute.ts
+var args62, tool$transactionBundlerTransactionBundlerMetamaskExecute;
+var init_transactionBundlerTransactionBundlerMetamaskExecute2 = __esm(() => {
+  init_transactionBundlerTransactionBundlerMetamaskExecute();
+  init_components();
+  init_tools();
+  args62 = {
+    request: MetamaskDelegatorRequest$inboundSchema
+  };
+  tool$transactionBundlerTransactionBundlerMetamaskExecute = {
+    name: "transaction-bundler-transaction-bundler-metamask-execute",
+    description: `Construct Bundled Transaction
+
+Bundle arbitrary transactions together into a single metamask delegator
+transaction.`,
+    args: args62,
+    tool: async (client, args63, ctx) => {
+      const [result, apiCall] = await transactionBundlerTransactionBundlerMetamaskExecute(client, args63.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true
+        };
+      }
+      const value = result.value;
+      return formatResult(value, apiCall);
+    }
+  };
+});
+
+// src/funcs/uniswapV3UniswapLiquidityProvisionIncrease.ts
+function uniswapV3UniswapLiquidityProvisionIncrease(client, request, options) {
+  return new APIPromise($do63(client, request, options));
+}
+async function $do63(client, request, options) {
   const parsed = safeParse(request, (value) => UniswapIncreaseLiquidityProvisionRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -53644,12 +53841,12 @@ var init_uniswapV3UniswapLiquidityProvisionIncrease = __esm(() => {
 });
 
 // src/mcp-server/tools/uniswapV3UniswapLiquidityProvisionIncrease.ts
-var args62, tool$uniswapV3UniswapLiquidityProvisionIncrease;
+var args63, tool$uniswapV3UniswapLiquidityProvisionIncrease;
 var init_uniswapV3UniswapLiquidityProvisionIncrease2 = __esm(() => {
   init_uniswapV3UniswapLiquidityProvisionIncrease();
   init_components();
   init_tools();
-  args62 = {
+  args63 = {
     request: UniswapIncreaseLiquidityProvisionRequest$inboundSchema
   };
   tool$uniswapV3UniswapLiquidityProvisionIncrease = {
@@ -53673,9 +53870,9 @@ process.
                      - \`AerodromeSlipstreamRouter\`
                     </Info>
                 `,
-    args: args62,
-    tool: async (client, args63, ctx) => {
-      const [result, apiCall] = await uniswapV3UniswapLiquidityProvisionIncrease(client, args63.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args63,
+    tool: async (client, args64, ctx) => {
+      const [result, apiCall] = await uniswapV3UniswapLiquidityProvisionIncrease(client, args64.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -53690,9 +53887,9 @@ process.
 
 // src/funcs/uniswapV3UniswapLiquidityProvisionInRange.ts
 function uniswapV3UniswapLiquidityProvisionInRange(client, request, options) {
-  return new APIPromise($do63(client, request, options));
+  return new APIPromise($do64(client, request, options));
 }
-async function $do63(client, request, options) {
+async function $do64(client, request, options) {
   const parsed = safeParse(request, (value) => V1UniswapLiquidityProvisionInRangeRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -53768,12 +53965,12 @@ var init_uniswapV3UniswapLiquidityProvisionInRange = __esm(() => {
 });
 
 // src/mcp-server/tools/uniswapV3UniswapLiquidityProvisionInRange.ts
-var args63, tool$uniswapV3UniswapLiquidityProvisionInRange;
+var args64, tool$uniswapV3UniswapLiquidityProvisionInRange;
 var init_uniswapV3UniswapLiquidityProvisionInRange2 = __esm(() => {
   init_uniswapV3UniswapLiquidityProvisionInRange();
   init_operations();
   init_tools();
-  args63 = {
+  args64 = {
     request: V1UniswapLiquidityProvisionInRangeRequest$inboundSchema
   };
   tool$uniswapV3UniswapLiquidityProvisionInRange = {
@@ -53788,9 +53985,9 @@ position is currently within the tick range where trading occurs. this informati
 is essential for users to monitor the status of their lp positions and ensure that
 they are actively participating in the trading activities within the liquidity pool
 and earning trading fees.`,
-    args: args63,
-    tool: async (client, args64, ctx) => {
-      const [result, apiCall] = await uniswapV3UniswapLiquidityProvisionInRange(client, args64.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args64,
+    tool: async (client, args65, ctx) => {
+      const [result, apiCall] = await uniswapV3UniswapLiquidityProvisionInRange(client, args65.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -53805,9 +54002,9 @@ and earning trading fees.`,
 
 // src/funcs/uniswapV3UniswapLiquidityProvisionMint.ts
 function uniswapV3UniswapLiquidityProvisionMint(client, request, options) {
-  return new APIPromise($do64(client, request, options));
+  return new APIPromise($do65(client, request, options));
 }
-async function $do64(client, request, options) {
+async function $do65(client, request, options) {
   const parsed = safeParse(request, (value) => UniswapMintLiquidityProvisionRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -53878,12 +54075,12 @@ var init_uniswapV3UniswapLiquidityProvisionMint = __esm(() => {
 });
 
 // src/mcp-server/tools/uniswapV3UniswapLiquidityProvisionMint.ts
-var args64, tool$uniswapV3UniswapLiquidityProvisionMint;
+var args65, tool$uniswapV3UniswapLiquidityProvisionMint;
 var init_uniswapV3UniswapLiquidityProvisionMint2 = __esm(() => {
   init_uniswapV3UniswapLiquidityProvisionMint();
   init_components();
   init_tools();
-  args64 = {
+  args65 = {
     request: UniswapMintLiquidityProvisionRequest$inboundSchema
   };
   tool$uniswapV3UniswapLiquidityProvisionMint = {
@@ -53907,9 +54104,9 @@ needed for the minting process.
                      - \`UniswapV3NFTPositionManager\`
                     </Info>
                 `,
-    args: args64,
-    tool: async (client, args65, ctx) => {
-      const [result, apiCall] = await uniswapV3UniswapLiquidityProvisionMint(client, args65.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args65,
+    tool: async (client, args66, ctx) => {
+      const [result, apiCall] = await uniswapV3UniswapLiquidityProvisionMint(client, args66.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -53924,9 +54121,9 @@ needed for the minting process.
 
 // src/funcs/uniswapV3UniswapLiquidityProvisionPositions.ts
 function uniswapV3UniswapLiquidityProvisionPositions(client, request, options) {
-  return new APIPromise($do65(client, request, options));
+  return new APIPromise($do66(client, request, options));
 }
-async function $do65(client, request, options) {
+async function $do66(client, request, options) {
   const parsed = safeParse(request, (value) => V1UniswapLiquidityProvisionPositionsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -54002,12 +54199,12 @@ var init_uniswapV3UniswapLiquidityProvisionPositions = __esm(() => {
 });
 
 // src/mcp-server/tools/uniswapV3UniswapLiquidityProvisionPositions.ts
-var args65, tool$uniswapV3UniswapLiquidityProvisionPositions;
+var args66, tool$uniswapV3UniswapLiquidityProvisionPositions;
 var init_uniswapV3UniswapLiquidityProvisionPositions2 = __esm(() => {
   init_uniswapV3UniswapLiquidityProvisionPositions();
   init_operations();
   init_tools();
-  args65 = {
+  args66 = {
     request: V1UniswapLiquidityProvisionPositionsRequest$inboundSchema
   };
   tool$uniswapV3UniswapLiquidityProvisionPositions = {
@@ -54021,9 +54218,9 @@ Users can query this endpoint to obtain detailed information about their LP
 positions, including the total number of positions and relevant metadata. This
 information is crucial for users to manage and analyze their liquidity provision
 activities effectively.`,
-    args: args65,
-    tool: async (client, args66, ctx) => {
-      const [result, apiCall] = await uniswapV3UniswapLiquidityProvisionPositions(client, args66.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args66,
+    tool: async (client, args67, ctx) => {
+      const [result, apiCall] = await uniswapV3UniswapLiquidityProvisionPositions(client, args67.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -54038,9 +54235,9 @@ activities effectively.`,
 
 // src/funcs/uniswapV3UniswapLiquidityProvisionWithdraw.ts
 function uniswapV3UniswapLiquidityProvisionWithdraw(client, request, options) {
-  return new APIPromise($do66(client, request, options));
+  return new APIPromise($do67(client, request, options));
 }
-async function $do66(client, request, options) {
+async function $do67(client, request, options) {
   const parsed = safeParse(request, (value) => UniswapWithdrawLiquidityProvisionRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -54111,12 +54308,12 @@ var init_uniswapV3UniswapLiquidityProvisionWithdraw = __esm(() => {
 });
 
 // src/mcp-server/tools/uniswapV3UniswapLiquidityProvisionWithdraw.ts
-var args66, tool$uniswapV3UniswapLiquidityProvisionWithdraw;
+var args67, tool$uniswapV3UniswapLiquidityProvisionWithdraw;
 var init_uniswapV3UniswapLiquidityProvisionWithdraw2 = __esm(() => {
   init_uniswapV3UniswapLiquidityProvisionWithdraw();
   init_components();
   init_tools();
-  args66 = {
+  args67 = {
     request: UniswapWithdrawLiquidityProvisionRequest$inboundSchema
   };
   tool$uniswapV3UniswapLiquidityProvisionWithdraw = {
@@ -54141,9 +54338,9 @@ before initiating a withdrawal to avoid potential issues or penalties.
                      - \`UniswapV3NFTPositionManager\`
                     </Info>
                 `,
-    args: args66,
-    tool: async (client, args67, ctx) => {
-      const [result, apiCall] = await uniswapV3UniswapLiquidityProvisionWithdraw(client, args67.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args67,
+    tool: async (client, args68, ctx) => {
+      const [result, apiCall] = await uniswapV3UniswapLiquidityProvisionWithdraw(client, args68.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -54158,9 +54355,9 @@ before initiating a withdrawal to avoid potential issues or penalties.
 
 // src/funcs/uniswapV3UniswapPoolPrice.ts
 function uniswapV3UniswapPoolPrice(client, request, options) {
-  return new APIPromise($do67(client, request, options));
+  return new APIPromise($do68(client, request, options));
 }
-async function $do67(client, request, options) {
+async function $do68(client, request, options) {
   const parsed = safeParse(request, (value) => V1UniswapPoolPriceRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -54238,12 +54435,12 @@ var init_uniswapV3UniswapPoolPrice = __esm(() => {
 });
 
 // src/mcp-server/tools/uniswapV3UniswapPoolPrice.ts
-var args67, tool$uniswapV3UniswapPoolPrice;
+var args68, tool$uniswapV3UniswapPoolPrice;
 var init_uniswapV3UniswapPoolPrice2 = __esm(() => {
   init_uniswapV3UniswapPoolPrice();
   init_operations();
   init_tools();
-  args67 = {
+  args68 = {
     request: V1UniswapPoolPriceRequest$inboundSchema
   };
   tool$uniswapV3UniswapPoolPrice = {
@@ -54253,9 +54450,9 @@ var init_uniswapV3UniswapPoolPrice2 = __esm(() => {
 This endpoint calculates the price of a token in a Uniswap pool.
 
 The price is calculated based on the current pool state and the specified fee tier.`,
-    args: args67,
-    tool: async (client, args68, ctx) => {
-      const [result, apiCall] = await uniswapV3UniswapPoolPrice(client, args68.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args68,
+    tool: async (client, args69, ctx) => {
+      const [result, apiCall] = await uniswapV3UniswapPoolPrice(client, args69.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -54270,9 +54467,9 @@ The price is calculated based on the current pool state and the specified fee ti
 
 // src/funcs/uniswapV3UniswapQuoteBuyExactly.ts
 function uniswapV3UniswapQuoteBuyExactly(client, request, options) {
-  return new APIPromise($do68(client, request, options));
+  return new APIPromise($do69(client, request, options));
 }
-async function $do68(client, request, options) {
+async function $do69(client, request, options) {
   const parsed = safeParse(request, (value) => V1UniswapQuoteBuyExactlyRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -54351,12 +54548,12 @@ var init_uniswapV3UniswapQuoteBuyExactly = __esm(() => {
 });
 
 // src/mcp-server/tools/uniswapV3UniswapQuoteBuyExactly.ts
-var args68, tool$uniswapV3UniswapQuoteBuyExactly;
+var args69, tool$uniswapV3UniswapQuoteBuyExactly;
 var init_uniswapV3UniswapQuoteBuyExactly2 = __esm(() => {
   init_uniswapV3UniswapQuoteBuyExactly();
   init_operations();
   init_tools();
-  args68 = {
+  args69 = {
     request: V1UniswapQuoteBuyExactlyRequest$inboundSchema
   };
   tool$uniswapV3UniswapQuoteBuyExactly = {
@@ -54368,9 +54565,9 @@ specified amount of output tokens from a Uniswap pool.
 
 It also provides the resulting price after the transaction. The calculation takes
 into account the current pool state and the specified fee tier.`,
-    args: args68,
-    tool: async (client, args69, ctx) => {
-      const [result, apiCall] = await uniswapV3UniswapQuoteBuyExactly(client, args69.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args69,
+    tool: async (client, args70, ctx) => {
+      const [result, apiCall] = await uniswapV3UniswapQuoteBuyExactly(client, args70.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -54385,9 +54582,9 @@ into account the current pool state and the specified fee tier.`,
 
 // src/funcs/uniswapV3UniswapQuoteSellExactly.ts
 function uniswapV3UniswapQuoteSellExactly(client, request, options) {
-  return new APIPromise($do69(client, request, options));
+  return new APIPromise($do70(client, request, options));
 }
-async function $do69(client, request, options) {
+async function $do70(client, request, options) {
   const parsed = safeParse(request, (value) => V1UniswapQuoteSellExactlyRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -54466,12 +54663,12 @@ var init_uniswapV3UniswapQuoteSellExactly = __esm(() => {
 });
 
 // src/mcp-server/tools/uniswapV3UniswapQuoteSellExactly.ts
-var args69, tool$uniswapV3UniswapQuoteSellExactly;
+var args70, tool$uniswapV3UniswapQuoteSellExactly;
 var init_uniswapV3UniswapQuoteSellExactly2 = __esm(() => {
   init_uniswapV3UniswapQuoteSellExactly();
   init_operations();
   init_tools();
-  args69 = {
+  args70 = {
     request: V1UniswapQuoteSellExactlyRequest$inboundSchema
   };
   tool$uniswapV3UniswapQuoteSellExactly = {
@@ -54483,9 +54680,9 @@ specified amount of output tokens from a Uniswap pool.
 
 It also provides the resulting price after the transaction. The calculation takes
 into account the current pool state and the specified fee tier.`,
-    args: args69,
-    tool: async (client, args70, ctx) => {
-      const [result, apiCall] = await uniswapV3UniswapQuoteSellExactly(client, args70.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args70,
+    tool: async (client, args71, ctx) => {
+      const [result, apiCall] = await uniswapV3UniswapQuoteSellExactly(client, args71.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -54500,9 +54697,9 @@ into account the current pool state and the specified fee tier.`,
 
 // src/funcs/uniswapV3UniswapSwapBuyExactly.ts
 function uniswapV3UniswapSwapBuyExactly(client, request, options) {
-  return new APIPromise($do70(client, request, options));
+  return new APIPromise($do71(client, request, options));
 }
-async function $do70(client, request, options) {
+async function $do71(client, request, options) {
   const parsed = safeParse(request, (value) => UniswapBuyExactlyRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -54573,12 +54770,12 @@ var init_uniswapV3UniswapSwapBuyExactly = __esm(() => {
 });
 
 // src/mcp-server/tools/uniswapV3UniswapSwapBuyExactly.ts
-var args70, tool$uniswapV3UniswapSwapBuyExactly;
+var args71, tool$uniswapV3UniswapSwapBuyExactly;
 var init_uniswapV3UniswapSwapBuyExactly2 = __esm(() => {
   init_uniswapV3UniswapSwapBuyExactly();
   init_components();
   init_tools();
-  args70 = {
+  args71 = {
     request: UniswapBuyExactlyRequest$inboundSchema
   };
   tool$uniswapV3UniswapSwapBuyExactly = {
@@ -54600,9 +54797,9 @@ needs to be wrapped, the appropriate amount will be wrapped automatically.
                      - \`UniswapV3Router\`
                     </Info>
                 `,
-    args: args70,
-    tool: async (client, args71, ctx) => {
-      const [result, apiCall] = await uniswapV3UniswapSwapBuyExactly(client, args71.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args71,
+    tool: async (client, args72, ctx) => {
+      const [result, apiCall] = await uniswapV3UniswapSwapBuyExactly(client, args72.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -54617,9 +54814,9 @@ needs to be wrapped, the appropriate amount will be wrapped automatically.
 
 // src/funcs/uniswapV3UniswapSwapSellExactly.ts
 function uniswapV3UniswapSwapSellExactly(client, request, options) {
-  return new APIPromise($do71(client, request, options));
+  return new APIPromise($do72(client, request, options));
 }
-async function $do71(client, request, options) {
+async function $do72(client, request, options) {
   const parsed = safeParse(request, (value) => UniswapSellExactlyRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -54690,12 +54887,12 @@ var init_uniswapV3UniswapSwapSellExactly = __esm(() => {
 });
 
 // src/mcp-server/tools/uniswapV3UniswapSwapSellExactly.ts
-var args71, tool$uniswapV3UniswapSwapSellExactly;
+var args72, tool$uniswapV3UniswapSwapSellExactly;
 var init_uniswapV3UniswapSwapSellExactly2 = __esm(() => {
   init_uniswapV3UniswapSwapSellExactly();
   init_components();
   init_tools();
-  args71 = {
+  args72 = {
     request: UniswapSellExactlyRequest$inboundSchema
   };
   tool$uniswapV3UniswapSwapSellExactly = {
@@ -54717,9 +54914,9 @@ wrapped, the appropriate amount will be wrapped automatically.
                      - \`UniswapV3Router\`
                     </Info>
                 `,
-    args: args71,
-    tool: async (client, args72, ctx) => {
-      const [result, apiCall] = await uniswapV3UniswapSwapSellExactly(client, args72.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args72,
+    tool: async (client, args73, ctx) => {
+      const [result, apiCall] = await uniswapV3UniswapSwapSellExactly(client, args73.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -54734,9 +54931,9 @@ wrapped, the appropriate amount will be wrapped automatically.
 
 // src/funcs/universalGenericAllowance.ts
 function universalGenericAllowance(client, request, options) {
-  return new APIPromise($do72(client, request, options));
+  return new APIPromise($do73(client, request, options));
 }
-async function $do72(client, request, options) {
+async function $do73(client, request, options) {
   const parsed = safeParse(request, (value) => V1GenericAllowanceRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -54814,12 +55011,12 @@ var init_universalGenericAllowance = __esm(() => {
 });
 
 // src/mcp-server/tools/universalGenericAllowance.ts
-var args72, tool$universalGenericAllowance;
+var args73, tool$universalGenericAllowance;
 var init_universalGenericAllowance2 = __esm(() => {
   init_universalGenericAllowance();
   init_operations();
   init_tools();
-  args72 = {
+  args73 = {
     request: V1GenericAllowanceRequest$inboundSchema
   };
   tool$universalGenericAllowance = {
@@ -54833,9 +55030,9 @@ tokens on their behalf.
 This is a crucial step before engaging in any transactions or operations within
 these protocols, ensuring that the protocol has the necessary permissions to manage
 the user's tokens securely and efficiently.`,
-    args: args72,
-    tool: async (client, args73, ctx) => {
-      const [result, apiCall] = await universalGenericAllowance(client, args73.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args73,
+    tool: async (client, args74, ctx) => {
+      const [result, apiCall] = await universalGenericAllowance(client, args74.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -54850,9 +55047,9 @@ the user's tokens securely and efficiently.`,
 
 // src/funcs/universalGenericAllowanceSet.ts
 function universalGenericAllowanceSet(client, request, options) {
-  return new APIPromise($do73(client, request, options));
+  return new APIPromise($do74(client, request, options));
 }
-async function $do73(client, request, options) {
+async function $do74(client, request, options) {
   const parsed = safeParse(request, (value) => SetAllowanceRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -54923,12 +55120,12 @@ var init_universalGenericAllowanceSet = __esm(() => {
 });
 
 // src/mcp-server/tools/universalGenericAllowanceSet.ts
-var args73, tool$universalGenericAllowanceSet;
+var args74, tool$universalGenericAllowanceSet;
 var init_universalGenericAllowanceSet2 = __esm(() => {
   init_universalGenericAllowanceSet();
   init_components();
   init_tools();
-  args73 = {
+  args74 = {
     request: SetAllowanceRequest$inboundSchema
   };
   tool$universalGenericAllowanceSet = {
@@ -54943,9 +55140,9 @@ authorize a protocol to spend a specified amount of tokens on behalf of the user
 This operation is crucial for ensuring that the protocol can manage the user's
 tokens securely and efficiently, enabling seamless transactions and operations
 within the DeFi ecosystem.`,
-    args: args73,
-    tool: async (client, args74, ctx) => {
-      const [result, apiCall] = await universalGenericAllowanceSet(client, args74.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args74,
+    tool: async (client, args75, ctx) => {
+      const [result, apiCall] = await universalGenericAllowanceSet(client, args75.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -54960,9 +55157,9 @@ within the DeFi ecosystem.`,
 
 // src/funcs/universalGenericEns.ts
 function universalGenericEns(client, request, options) {
-  return new APIPromise($do74(client, request, options));
+  return new APIPromise($do75(client, request, options));
 }
-async function $do74(client, request, options) {
+async function $do75(client, request, options) {
   const parsed = safeParse(request, (value) => V1GenericEnsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -55038,12 +55235,12 @@ var init_universalGenericEns = __esm(() => {
 });
 
 // src/mcp-server/tools/universalGenericEns.ts
-var args74, tool$universalGenericEns;
+var args75, tool$universalGenericEns;
 var init_universalGenericEns2 = __esm(() => {
   init_universalGenericEns();
   init_operations();
   init_tools();
-  args74 = {
+  args75 = {
     request: V1GenericEnsRequest$inboundSchema
   };
   tool$universalGenericEns = {
@@ -55054,9 +55251,9 @@ An ENS name is a string ending in \`.eth\`.
 
 E.g. \`vitalik.eth\`. This endpoint can be used to
 query the actual ethereum wallet address behind the ENS name.`,
-    args: args74,
-    tool: async (client, args75, ctx) => {
-      const [result, apiCall] = await universalGenericEns(client, args75.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args75,
+    tool: async (client, args76, ctx) => {
+      const [result, apiCall] = await universalGenericEns(client, args76.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -55071,9 +55268,9 @@ query the actual ethereum wallet address behind the ENS name.`,
 
 // src/funcs/universalGenericPortfolio.ts
 function universalGenericPortfolio(client, request, options) {
-  return new APIPromise($do75(client, request, options));
+  return new APIPromise($do76(client, request, options));
 }
-async function $do75(client, request, options) {
+async function $do76(client, request, options) {
   const parsed = safeParse(request, (value) => V1GenericPortfolioRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -55149,12 +55346,12 @@ var init_universalGenericPortfolio = __esm(() => {
 });
 
 // src/mcp-server/tools/universalGenericPortfolio.ts
-var args75, tool$universalGenericPortfolio;
+var args76, tool$universalGenericPortfolio;
 var init_universalGenericPortfolio2 = __esm(() => {
   init_universalGenericPortfolio();
   init_operations();
   init_tools();
-  args75 = {
+  args76 = {
     request: V1GenericPortfolioRequest$inboundSchema
   };
   tool$universalGenericPortfolio = {
@@ -55165,9 +55362,9 @@ Fetch the detailed portfolio of a specific wallet address on a given blockchain.
 
 This includes the total value of the portfolio in USD and a breakdown of token
 balances, including their respective values and quantities.`,
-    args: args75,
-    tool: async (client, args76, ctx) => {
-      const [result, apiCall] = await universalGenericPortfolio(client, args76.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args76,
+    tool: async (client, args77, ctx) => {
+      const [result, apiCall] = await universalGenericPortfolio(client, args77.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -55182,9 +55379,9 @@ balances, including their respective values and quantities.`,
 
 // src/funcs/universalGenericSupportedChains.ts
 function universalGenericSupportedChains(client, request, options) {
-  return new APIPromise($do76(client, request, options));
+  return new APIPromise($do77(client, request, options));
 }
-async function $do76(client, request, options) {
+async function $do77(client, request, options) {
   const parsed = safeParse(request, (value) => V1GenericSupportedChainsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -55259,12 +55456,12 @@ var init_universalGenericSupportedChains = __esm(() => {
 });
 
 // src/mcp-server/tools/universalGenericSupportedChains.ts
-var args76, tool$universalGenericSupportedChains;
+var args77, tool$universalGenericSupportedChains;
 var init_universalGenericSupportedChains2 = __esm(() => {
   init_universalGenericSupportedChains();
   init_operations();
   init_tools();
-  args76 = {
+  args77 = {
     request: V1GenericSupportedChainsRequest$inboundSchema
   };
   tool$universalGenericSupportedChains = {
@@ -55272,9 +55469,9 @@ var init_universalGenericSupportedChains2 = __esm(() => {
     description: `List Supported Chains
 
 Get the list of supported chains by the Compass API.`,
-    args: args76,
-    tool: async (client, args77, ctx) => {
-      const [result, apiCall] = await universalGenericSupportedChains(client, args77.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args77,
+    tool: async (client, args78, ctx) => {
+      const [result, apiCall] = await universalGenericSupportedChains(client, args78.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -55289,9 +55486,9 @@ Get the list of supported chains by the Compass API.`,
 
 // src/funcs/universalGenericSupportedTokens.ts
 function universalGenericSupportedTokens(client, request, options) {
-  return new APIPromise($do77(client, request, options));
+  return new APIPromise($do78(client, request, options));
 }
-async function $do77(client, request, options) {
+async function $do78(client, request, options) {
   const parsed = safeParse(request, (value) => V1GenericSupportedTokensRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -55366,12 +55563,12 @@ var init_universalGenericSupportedTokens = __esm(() => {
 });
 
 // src/mcp-server/tools/universalGenericSupportedTokens.ts
-var args77, tool$universalGenericSupportedTokens;
+var args78, tool$universalGenericSupportedTokens;
 var init_universalGenericSupportedTokens2 = __esm(() => {
   init_universalGenericSupportedTokens();
   init_operations();
   init_tools();
-  args77 = {
+  args78 = {
     request: V1GenericSupportedTokensRequest$inboundSchema
   };
   tool$universalGenericSupportedTokens = {
@@ -55379,9 +55576,9 @@ var init_universalGenericSupportedTokens2 = __esm(() => {
     description: `List Supported Tokens
 
 Get the list of supported tokens on a chain by the Compass API.`,
-    args: args77,
-    tool: async (client, args78, ctx) => {
-      const [result, apiCall] = await universalGenericSupportedTokens(client, args78.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args78,
+    tool: async (client, args79, ctx) => {
+      const [result, apiCall] = await universalGenericSupportedTokens(client, args79.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -55396,9 +55593,9 @@ Get the list of supported tokens on a chain by the Compass API.`,
 
 // src/funcs/universalGenericUnwrapWeth.ts
 function universalGenericUnwrapWeth(client, request, options) {
-  return new APIPromise($do78(client, request, options));
+  return new APIPromise($do79(client, request, options));
 }
-async function $do78(client, request, options) {
+async function $do79(client, request, options) {
   const parsed = safeParse(request, (value) => UnwrapWethRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -55469,12 +55666,12 @@ var init_universalGenericUnwrapWeth = __esm(() => {
 });
 
 // src/mcp-server/tools/universalGenericUnwrapWeth.ts
-var args78, tool$universalGenericUnwrapWeth;
+var args79, tool$universalGenericUnwrapWeth;
 var init_universalGenericUnwrapWeth2 = __esm(() => {
   init_universalGenericUnwrapWeth();
   init_components();
   init_tools();
-  args78 = {
+  args79 = {
     request: UnwrapWethRequest$inboundSchema
   };
   tool$universalGenericUnwrapWeth = {
@@ -55483,9 +55680,9 @@ var init_universalGenericUnwrapWeth2 = __esm(() => {
 
 Unwrapping WETH converts the ERC-20 compliant form of ETH back to native ETH that
 can be used for gas and other native purposes.`,
-    args: args78,
-    tool: async (client, args79, ctx) => {
-      const [result, apiCall] = await universalGenericUnwrapWeth(client, args79.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args79,
+    tool: async (client, args80, ctx) => {
+      const [result, apiCall] = await universalGenericUnwrapWeth(client, args80.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -55500,9 +55697,9 @@ can be used for gas and other native purposes.`,
 
 // src/funcs/universalGenericWrapEth.ts
 function universalGenericWrapEth(client, request, options) {
-  return new APIPromise($do79(client, request, options));
+  return new APIPromise($do80(client, request, options));
 }
-async function $do79(client, request, options) {
+async function $do80(client, request, options) {
   const parsed = safeParse(request, (value) => WrapEthRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -55573,12 +55770,12 @@ var init_universalGenericWrapEth = __esm(() => {
 });
 
 // src/mcp-server/tools/universalGenericWrapEth.ts
-var args79, tool$universalGenericWrapEth;
+var args80, tool$universalGenericWrapEth;
 var init_universalGenericWrapEth2 = __esm(() => {
   init_universalGenericWrapEth();
   init_components();
   init_tools();
-  args79 = {
+  args80 = {
     request: WrapEthRequest$inboundSchema
   };
   tool$universalGenericWrapEth = {
@@ -55587,9 +55784,9 @@ var init_universalGenericWrapEth2 = __esm(() => {
 
 Wrapping ETH creates an ERC20 compliant form of ETH that is typically needed for
 it to be traded on DeFi protocols.`,
-    args: args79,
-    tool: async (client, args80, ctx) => {
-      const [result, apiCall] = await universalGenericWrapEth(client, args80.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args80,
+    tool: async (client, args81, ctx) => {
+      const [result, apiCall] = await universalGenericWrapEth(client, args81.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -55606,7 +55803,7 @@ it to be traded on DeFi protocols.`,
 function createMCPServer(deps) {
   const server = new McpServer({
     name: "CompassApiSDK",
-    version: "1.0.10"
+    version: "1.0.12"
   });
   const client = new CompassApiSDKCore({
     apiKeyAuth: deps.apiKeyAuth,
@@ -55691,6 +55888,7 @@ function createMCPServer(deps) {
   tool(tool$transactionBundlerTransactionBundlerAuthorization);
   tool(tool$transactionBundlerTransactionBundlerExecute);
   tool(tool$transactionBundlerTransactionBundlerAaveLoop);
+  tool(tool$transactionBundlerTransactionBundlerMetamaskExecute);
   tool(tool$smartAccountSmartAccountBatchedUserOperations);
   tool(tool$erc4626VaultsVaultsVault);
   tool(tool$erc4626VaultsVaultsDeposit);
@@ -55767,6 +55965,7 @@ var init_server2 = __esm(() => {
   init_transactionBundlerTransactionBundlerAaveLoop2();
   init_transactionBundlerTransactionBundlerAuthorization2();
   init_transactionBundlerTransactionBundlerExecute2();
+  init_transactionBundlerTransactionBundlerMetamaskExecute2();
   init_uniswapV3UniswapLiquidityProvisionIncrease2();
   init_uniswapV3UniswapLiquidityProvisionInRange2();
   init_uniswapV3UniswapLiquidityProvisionMint2();
@@ -56980,7 +57179,7 @@ var routes = ln({
 var app = _e(routes, {
   name: "mcp",
   versionInfo: {
-    currentVersion: "1.0.10"
+    currentVersion: "1.0.12"
   }
 });
 Yt(app, process3.argv.slice(2), buildContext(process3));
@@ -56988,5 +57187,5 @@ export {
   app
 };
 
-//# debugId=2E43E454FDB0C82E64756E2164756E21
+//# debugId=C494BDF8B11B717C64756E2164756E21
 //# sourceMappingURL=mcp-server.js.map