@compass-labs/api-sdk 0.5.8 → 0.5.10

package/src/lib/matchers.ts

@@ -3,11 +3,10 @@
  */
 
 import { APIError } from "../models/errors/apierror.js";
-import { SDKValidationError } from "../models/errors/sdkvalidationerror.js";
-import { Result } from "../types/fp.js";
+import { ResponseValidationError } from "../models/errors/responsevalidationerror.js";
+import { ERR, OK, Result } from "../types/fp.js";
 import { matchResponse, matchStatusCode, StatusCodePredicate } from "./http.js";
 import { isPlainObject } from "./is-plain-object.js";
-import { safeParse } from "./schemas.js";
 
 export type Encoding =
   | "jsonl"
@@ -176,17 +175,19 @@ export type MatchedError<Matchers> = Matchers extends Matcher<any, infer E>[]
   : never;
 export type MatchFunc<T, E> = (
   response: Response,
+  request: Request,
   options?: { resultKey?: string; extraFields?: Record<string, unknown> },
 ) => Promise<[result: Result<T, E>, raw: unknown]>;
 
 export function match<T, E>(
   ...matchers: Array<Matcher<T, E>>
-): MatchFunc<T, E | APIError | SDKValidationError> {
+): MatchFunc<T, E | APIError | ResponseValidationError> {
   return async function matchFunc(
     response: Response,
+    request: Request,
     options?: { resultKey?: string; extraFields?: Record<string, unknown> },
   ): Promise<
-    [result: Result<T, E | APIError | SDKValidationError>, raw: unknown]
+    [result: Result<T, E | APIError | ResponseValidationError>, raw: unknown]
   > {
     let raw: unknown;
     let matcher: Matcher<T, E> | undefined;
@@ -205,21 +206,22 @@ export function match<T, E>(
     }
 
     if (!matcher) {
-      const responseBody = await response.text();
       return [{
         ok: false,
-        error: new APIError(
-          "Unexpected API response status or content-type",
+        error: new APIError("Unexpected Status or Content-Type", {
           response,
-          responseBody,
-        ),
-      }, responseBody];
+          request,
+          body: await response.text().catch(() => ""),
+        }),
+      }, raw];
     }
 
     const encoding = matcher.enc;
+    let body = "";
     switch (encoding) {
       case "json":
-        raw = await response.json();
+        body = await response.text();
+        raw = JSON.parse(body);
         break;
       case "jsonl":
         raw = response.body;
@@ -231,16 +233,19 @@ export function match<T, E>(
         raw = response.body;
         break;
       case "text":
-        raw = await response.text();
+        body = await response.text();
+        raw = body;
         break;
       case "sse":
         raw = response.body;
         break;
       case "nil":
-        raw = await discardResponseBody(response);
+        body = await response.text();
+        raw = undefined;
         break;
       case "fail":
-        raw = await response.text();
+        body = await response.text();
+        raw = body;
         break;
       default:
         encoding satisfies never;
@@ -250,11 +255,7 @@ export function match<T, E>(
     if (matcher.enc === "fail") {
       return [{
         ok: false,
-        error: new APIError(
-          "API error occurred",
-          response,
-          typeof raw === "string" ? raw : "",
-        ),
+        error: new APIError("API error occurred", { request, response, body }),
       }, raw];
     }
 
@@ -266,6 +267,9 @@ export function match<T, E>(
         ...options?.extraFields,
         ...(matcher.hdrs ? { Headers: unpackHeaders(response.headers) } : null),
         ...(isPlainObject(raw) ? raw : null),
+        request$: request,
+        response$: response,
+        body$: body,
       };
     } else if (resultKey) {
       data = {
@@ -284,18 +288,20 @@ export function match<T, E>(
     }
 
     if ("err" in matcher) {
-      const result = safeParse(
+      const result = safeParseResponse(
         data,
         (v: unknown) => matcher.schema.parse(v),
         "Response validation failed",
+        { request, response, body },
       );
       return [result.ok ? { ok: false, error: result.value } : result, raw];
     } else {
       return [
-        safeParse(
+        safeParseResponse(
           data,
           (v: unknown) => matcher.schema.parse(v),
           "Response validation failed",
+          { request, response, body },
         ),
         raw,
       ];
@@ -318,25 +324,22 @@ export function unpackHeaders(headers: Headers): Record<string, string[]> {
   return out;
 }
 
-/**
- * Discards the response body to free up resources.
- *
- * To learn why this is need, see the undici docs:
- * https://undici.nodejs.org/#/?id=garbage-collection
- */
-export async function discardResponseBody(res: Response) {
-  const reader = res.body?.getReader();
-  if (reader == null) {
-    return;
-  }
-
+function safeParseResponse<Inp, Out>(
+  rawValue: Inp,
+  fn: (value: Inp) => Out,
+  errorMessage: string,
+  httpMeta: { response: Response; request: Request; body: string },
+): Result<Out, ResponseValidationError> {
   try {
-    let done = false;
-    while (!done) {
-      const res = await reader.read();
-      done = res.done;
-    }
-  } finally {
-    reader.releaseLock();
+    return OK(fn(rawValue));
+  } catch (err) {
+    return ERR(
+      new ResponseValidationError(errorMessage, {
+        cause: err,
+        rawValue,
+        rawMessage: errorMessage,
+        ...httpMeta,
+      }),
+    );
   }
 }

package/src/mcp-server/mcp-server.ts

@@ -19,7 +19,7 @@ const routes = buildRouteMap({
 export const app = buildApplication(routes, {
   name: "mcp",
   versionInfo: {
-    currentVersion: "0.5.8",
+    currentVersion: "0.5.10",
   },
 });
 

package/src/mcp-server/server.ts

@@ -47,6 +47,7 @@ import { tool$morphoVaultPosition } from "./tools/morphoVaultPosition.js";
 import { tool$morphoVaults } from "./tools/morphoVaults.js";
 import { tool$morphoWithdraw } from "./tools/morphoWithdraw.js";
 import { tool$morphoWithdrawCollateral } from "./tools/morphoWithdrawCollateral.js";
+import { tool$pendleAddLiquidity } from "./tools/pendleAddLiquidity.js";
 import { tool$pendleBuyPt } from "./tools/pendleBuyPt.js";
 import { tool$pendleBuyYt } from "./tools/pendleBuyYt.js";
 import { tool$pendleMarket } from "./tools/pendleMarket.js";
@@ -54,6 +55,7 @@ import { tool$pendleMarkets } from "./tools/pendleMarkets.js";
 import { tool$pendlePosition } from "./tools/pendlePosition.js";
 import { tool$pendlePositions } from "./tools/pendlePositions.js";
 import { tool$pendleRedeemYield } from "./tools/pendleRedeemYield.js";
+import { tool$pendleRemoveLiquidity } from "./tools/pendleRemoveLiquidity.js";
 import { tool$pendleSellPt } from "./tools/pendleSellPt.js";
 import { tool$pendleSellYt } from "./tools/pendleSellYt.js";
 import { tool$skyBuy } from "./tools/skyBuy.js";
@@ -98,7 +100,7 @@ export function createMCPServer(deps: {
 }) {
   const server = new McpServer({
     name: "CompassApiSDK",
-    version: "0.5.8",
+    version: "0.5.10",
   });
 
   const client = new CompassApiSDKCore({
@@ -191,13 +193,15 @@ export function createMCPServer(deps: {
   tool(tool$universalAllowanceSet);
   tool(tool$pendlePosition);
   tool(tool$pendlePositions);
-  tool(tool$pendleMarkets);
   tool(tool$pendleMarket);
+  tool(tool$pendleMarkets);
   tool(tool$pendleBuyPt);
   tool(tool$pendleSellPt);
   tool(tool$pendleBuyYt);
   tool(tool$pendleSellYt);
   tool(tool$pendleRedeemYield);
+  tool(tool$pendleAddLiquidity);
+  tool(tool$pendleRemoveLiquidity);
   tool(tool$transactionBatchingAuthorization);
   tool(tool$transactionBatchingExecute);
   tool(tool$transactionBatchingAaveLoop);

package/src/mcp-server/tools/pendleAddLiquidity.ts

@@ -0,0 +1,40 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { pendleAddLiquidity } from "../../funcs/pendleAddLiquidity.js";
+import * as components from "../../models/components/index.js";
+import { formatResult, ToolDefinition } from "../tools.js";
+
+const args = {
+  request: components.PendleAddLiquidityRequest$inboundSchema,
+};
+
+export const tool$pendleAddLiquidity: ToolDefinition<typeof args> = {
+  name: "pendle-add-liquidity",
+  description: `Add Liquidity
+
+Add liquidity to a Pendle Market to earn yield.
+
+Liquidity is added in the form of the market's Underlying Token. Representation of
+the liquidity received is the market's Liquidity Provider Token (LP).`,
+  args,
+  tool: async (client, args, ctx) => {
+    const [result, apiCall] = await pendleAddLiquidity(
+      client,
+      args.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);
+  },
+};

package/src/mcp-server/tools/pendleRemoveLiquidity.ts

@@ -0,0 +1,41 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { pendleRemoveLiquidity } from "../../funcs/pendleRemoveLiquidity.js";
+import * as components from "../../models/components/index.js";
+import { formatResult, ToolDefinition } from "../tools.js";
+
+const args = {
+  request: components.PendleRemoveLiquidityRequest$inboundSchema,
+};
+
+export const tool$pendleRemoveLiquidity: ToolDefinition<typeof args> = {
+  name: "pendle-remove-liquidity",
+  description: `Remove Liquidity
+
+Remove liquidity from a Pendle Market.
+
+Liquidity is removed in the form of the market's Liquidity Provider Token (LP) into
+the market's Underlying Token. An appropriate allowance for the Pendle Router on the
+market contract must be set beforehand`,
+  args,
+  tool: async (client, args, ctx) => {
+    const [result, apiCall] = await pendleRemoveLiquidity(
+      client,
+      args.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);
+  },
+};

package/src/mcp-server/tools/universalAllowanceSet.ts

@@ -12,9 +12,10 @@ const args = {
 
 export const tool$universalAllowanceSet: ToolDefinition<typeof args> = {
   name: "universal-allowance-set",
-  description: `Set Allowance (symbol)
+  description: `Set Allowance
 
-This endpoint allows users to modify the token allowance for a specific protocol.
+This endpoint allows users to modify the token allowance on any ERC-20 token for
+a specific protocol.
 
 In decentralized finance (DeFi), setting an allowance is a necessary step to
 authorize a protocol to spend a specified amount of tokens on behalf of the user.

package/src/models/components/aavelooprequest.ts

@@ -23,7 +23,22 @@ import {
 /**
  * Amount of collateral token to supply to Aave
  */
-export type CollateralAmount = number | string;
+export type InitialCollateralAmount = number | string;
+
+/**
+ * Total loop collateral will be calculated as `multiplier` x `initial_collateral_amount`
+ */
+export type Multiplier = number | string;
+
+/**
+ * Maximum allowed slippage for token swaps in percentage
+ */
+export type MaxSlippagePercent = number | string;
+
+/**
+ * Loan To Value percentage of the loop
+ */
+export type LoanToValue = number | string;
 
 /**
  * Request model for executing an Aave loop strategy.
@@ -59,66 +74,202 @@ export type AaveLoopRequest = {
   /**
    * Amount of collateral token to supply to Aave
    */
-  collateralAmount: number | string;
+  initialCollateralAmount: number | string;
   /**
-   * Number of times to perform the supply-borrow loop
+   * Total loop collateral will be calculated as `multiplier` x `initial_collateral_amount`
    */
-  loopCount: number;
+  multiplier: number | string;
   /**
    * Maximum allowed slippage for token swaps in percentage
    */
-  maxSlippagePercent: number;
+  maxSlippagePercent: number | string;
   /**
    * Loan To Value percentage of the loop
    */
-  loanToValue: number;
+  loanToValue: number | string;
 };
 
 /** @internal */
-export const CollateralAmount$inboundSchema: z.ZodType<
-  CollateralAmount,
+export const InitialCollateralAmount$inboundSchema: z.ZodType<
+  InitialCollateralAmount,
   z.ZodTypeDef,
   unknown
 > = z.union([z.number(), z.string()]);
 
 /** @internal */
-export type CollateralAmount$Outbound = number | string;
+export type InitialCollateralAmount$Outbound = number | string;
 
 /** @internal */
-export const CollateralAmount$outboundSchema: z.ZodType<
-  CollateralAmount$Outbound,
+export const InitialCollateralAmount$outboundSchema: z.ZodType<
+  InitialCollateralAmount$Outbound,
   z.ZodTypeDef,
-  CollateralAmount
+  InitialCollateralAmount
 > = z.union([z.number(), z.string()]);
 
 /**
  * @internal
  * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
  */
-export namespace CollateralAmount$ {
-  /** @deprecated use `CollateralAmount$inboundSchema` instead. */
-  export const inboundSchema = CollateralAmount$inboundSchema;
-  /** @deprecated use `CollateralAmount$outboundSchema` instead. */
-  export const outboundSchema = CollateralAmount$outboundSchema;
-  /** @deprecated use `CollateralAmount$Outbound` instead. */
-  export type Outbound = CollateralAmount$Outbound;
+export namespace InitialCollateralAmount$ {
+  /** @deprecated use `InitialCollateralAmount$inboundSchema` instead. */
+  export const inboundSchema = InitialCollateralAmount$inboundSchema;
+  /** @deprecated use `InitialCollateralAmount$outboundSchema` instead. */
+  export const outboundSchema = InitialCollateralAmount$outboundSchema;
+  /** @deprecated use `InitialCollateralAmount$Outbound` instead. */
+  export type Outbound = InitialCollateralAmount$Outbound;
 }
 
-export function collateralAmountToJSON(
-  collateralAmount: CollateralAmount,
+export function initialCollateralAmountToJSON(
+  initialCollateralAmount: InitialCollateralAmount,
 ): string {
   return JSON.stringify(
-    CollateralAmount$outboundSchema.parse(collateralAmount),
+    InitialCollateralAmount$outboundSchema.parse(initialCollateralAmount),
+  );
+}
+
+export function initialCollateralAmountFromJSON(
+  jsonString: string,
+): SafeParseResult<InitialCollateralAmount, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => InitialCollateralAmount$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'InitialCollateralAmount' from JSON`,
+  );
+}
+
+/** @internal */
+export const Multiplier$inboundSchema: z.ZodType<
+  Multiplier,
+  z.ZodTypeDef,
+  unknown
+> = z.union([z.number(), z.string()]);
+
+/** @internal */
+export type Multiplier$Outbound = number | string;
+
+/** @internal */
+export const Multiplier$outboundSchema: z.ZodType<
+  Multiplier$Outbound,
+  z.ZodTypeDef,
+  Multiplier
+> = z.union([z.number(), z.string()]);
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace Multiplier$ {
+  /** @deprecated use `Multiplier$inboundSchema` instead. */
+  export const inboundSchema = Multiplier$inboundSchema;
+  /** @deprecated use `Multiplier$outboundSchema` instead. */
+  export const outboundSchema = Multiplier$outboundSchema;
+  /** @deprecated use `Multiplier$Outbound` instead. */
+  export type Outbound = Multiplier$Outbound;
+}
+
+export function multiplierToJSON(multiplier: Multiplier): string {
+  return JSON.stringify(Multiplier$outboundSchema.parse(multiplier));
+}
+
+export function multiplierFromJSON(
+  jsonString: string,
+): SafeParseResult<Multiplier, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Multiplier$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Multiplier' from JSON`,
   );
 }
 
-export function collateralAmountFromJSON(
+/** @internal */
+export const MaxSlippagePercent$inboundSchema: z.ZodType<
+  MaxSlippagePercent,
+  z.ZodTypeDef,
+  unknown
+> = z.union([z.number(), z.string()]);
+
+/** @internal */
+export type MaxSlippagePercent$Outbound = number | string;
+
+/** @internal */
+export const MaxSlippagePercent$outboundSchema: z.ZodType<
+  MaxSlippagePercent$Outbound,
+  z.ZodTypeDef,
+  MaxSlippagePercent
+> = z.union([z.number(), z.string()]);
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace MaxSlippagePercent$ {
+  /** @deprecated use `MaxSlippagePercent$inboundSchema` instead. */
+  export const inboundSchema = MaxSlippagePercent$inboundSchema;
+  /** @deprecated use `MaxSlippagePercent$outboundSchema` instead. */
+  export const outboundSchema = MaxSlippagePercent$outboundSchema;
+  /** @deprecated use `MaxSlippagePercent$Outbound` instead. */
+  export type Outbound = MaxSlippagePercent$Outbound;
+}
+
+export function maxSlippagePercentToJSON(
+  maxSlippagePercent: MaxSlippagePercent,
+): string {
+  return JSON.stringify(
+    MaxSlippagePercent$outboundSchema.parse(maxSlippagePercent),
+  );
+}
+
+export function maxSlippagePercentFromJSON(
+  jsonString: string,
+): SafeParseResult<MaxSlippagePercent, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => MaxSlippagePercent$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'MaxSlippagePercent' from JSON`,
+  );
+}
+
+/** @internal */
+export const LoanToValue$inboundSchema: z.ZodType<
+  LoanToValue,
+  z.ZodTypeDef,
+  unknown
+> = z.union([z.number(), z.string()]);
+
+/** @internal */
+export type LoanToValue$Outbound = number | string;
+
+/** @internal */
+export const LoanToValue$outboundSchema: z.ZodType<
+  LoanToValue$Outbound,
+  z.ZodTypeDef,
+  LoanToValue
+> = z.union([z.number(), z.string()]);
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace LoanToValue$ {
+  /** @deprecated use `LoanToValue$inboundSchema` instead. */
+  export const inboundSchema = LoanToValue$inboundSchema;
+  /** @deprecated use `LoanToValue$outboundSchema` instead. */
+  export const outboundSchema = LoanToValue$outboundSchema;
+  /** @deprecated use `LoanToValue$Outbound` instead. */
+  export type Outbound = LoanToValue$Outbound;
+}
+
+export function loanToValueToJSON(loanToValue: LoanToValue): string {
+  return JSON.stringify(LoanToValue$outboundSchema.parse(loanToValue));
+}
+
+export function loanToValueFromJSON(
   jsonString: string,
-): SafeParseResult<CollateralAmount, SDKValidationError> {
+): SafeParseResult<LoanToValue, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => CollateralAmount$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'CollateralAmount' from JSON`,
+    (x) => LoanToValue$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'LoanToValue' from JSON`,
   );
 }
 
@@ -133,17 +284,16 @@ export const AaveLoopRequest$inboundSchema: z.ZodType<
   signed_authorization: SignedAuthorization$inboundSchema,
   collateral_token: TokenEnum$inboundSchema,
   borrow_token: TokenEnum$inboundSchema,
-  collateral_amount: z.union([z.number(), z.string()]),
-  loop_count: z.number().int(),
-  max_slippage_percent: z.number(),
-  loan_to_value: z.number(),
+  initial_collateral_amount: z.union([z.number(), z.string()]),
+  multiplier: z.union([z.number(), z.string()]),
+  max_slippage_percent: z.union([z.number(), z.string()]),
+  loan_to_value: z.union([z.number(), z.string()]),
 }).transform((v) => {
   return remap$(v, {
     "signed_authorization": "signedAuthorization",
     "collateral_token": "collateralToken",
     "borrow_token": "borrowToken",
-    "collateral_amount": "collateralAmount",
-    "loop_count": "loopCount",
+    "initial_collateral_amount": "initialCollateralAmount",
     "max_slippage_percent": "maxSlippagePercent",
     "loan_to_value": "loanToValue",
   });
@@ -156,10 +306,10 @@ export type AaveLoopRequest$Outbound = {
   signed_authorization: SignedAuthorization$Outbound;
   collateral_token: string;
   borrow_token: string;
-  collateral_amount: number | string;
-  loop_count: number;
-  max_slippage_percent: number;
-  loan_to_value: number;
+  initial_collateral_amount: number | string;
+  multiplier: number | string;
+  max_slippage_percent: number | string;
+  loan_to_value: number | string;
 };
 
 /** @internal */
@@ -173,17 +323,16 @@ export const AaveLoopRequest$outboundSchema: z.ZodType<
   signedAuthorization: SignedAuthorization$outboundSchema,
   collateralToken: TokenEnum$outboundSchema,
   borrowToken: TokenEnum$outboundSchema,
-  collateralAmount: z.union([z.number(), z.string()]),
-  loopCount: z.number().int(),
-  maxSlippagePercent: z.number(),
-  loanToValue: z.number(),
+  initialCollateralAmount: z.union([z.number(), z.string()]),
+  multiplier: z.union([z.number(), z.string()]),
+  maxSlippagePercent: z.union([z.number(), z.string()]),
+  loanToValue: z.union([z.number(), z.string()]),
 }).transform((v) => {
   return remap$(v, {
     signedAuthorization: "signed_authorization",
     collateralToken: "collateral_token",
     borrowToken: "borrow_token",
-    collateralAmount: "collateral_amount",
-    loopCount: "loop_count",
+    initialCollateralAmount: "initial_collateral_amount",
     maxSlippagePercent: "max_slippage_percent",
     loanToValue: "loan_to_value",
   });

package/src/models/components/index.ts

@@ -97,6 +97,8 @@ export * from "./multicallauthorizationrequest.js";
 export * from "./multicallauthorizationresponse.js";
 export * from "./multicallexecuterequest.js";
 export * from "./openposition.js";
+export * from "./pendleaddliquidityparams.js";
+export * from "./pendleaddliquidityrequest.js";
 export * from "./pendlebuyptparams.js";
 export * from "./pendlebuyptrequest.js";
 export * from "./pendlebuyytparams.js";
@@ -108,6 +110,8 @@ export * from "./pendlelistuserpositionsresponse.js";
 export * from "./pendlemarket.js";
 export * from "./pendleredeemyieldparams.js";
 export * from "./pendleredeemyieldrequest.js";
+export * from "./pendleremoveliquidityparams.js";
+export * from "./pendleremoveliquidityrequest.js";
 export * from "./pendlesellptparams.js";
 export * from "./pendlesellptrequest.js";
 export * from "./pendlesellytparams.js";