@lifi/composer-sdk 0.2.0 → 0.4.0-staging.1

package/src/generated/config.generated.ts

@@ -3,8 +3,13 @@
 
 import type { Address, IntegerStringInput } from '../types.js';
 
+/**
+ * a number between 0 and 10000
+ */
+export type Between010000 = number;
+
 export interface CoreSplitConfig {
-  bps: number;
+  bps: Between010000;
 }
 
 /**
@@ -89,12 +94,17 @@ export interface InvariantNeqConfig {
   threshold: IntegerStringInput;
 }
 
+/**
+ * a non-negative number
+ */
+export type NonNegative = number;
+
 export interface CoreBpsDownConfig {
-  bps: number;
+  bps: NonNegative;
 }
 
 export interface CoreBpsUpConfig {
-  bps: number;
+  bps: NonNegative;
 }
 
 export interface CoreApproveConfig {
@@ -634,6 +644,33 @@ export interface LifiFlashloanRepayConfig {
   fee?: string;
 }
 
+export type ContinuationAssertReadyConfig =
+  | {
+      kind: 'erc20BalanceGte';
+      chainId: Positive;
+      token: StartsWith0X;
+      owner: StartsWith0X;
+      minAmount: string;
+    }
+  | {
+      kind: 'nativeBalanceGte';
+      chainId: Positive;
+      owner: StartsWith0X;
+      minAmount: string;
+    }
+  | {
+      kind: 'call';
+      chainId: Positive;
+      to: StartsWith0X;
+      calldata: StartsWith0X;
+      comparator: 'gte' | 'eq' | 'lte';
+      value: string;
+    };
+/**
+ * a string starting with "0x"
+ */
+export type StartsWith0X = string;
+
 export interface LifiZapConfig {
   resourceOut:
     | {
@@ -647,15 +684,6 @@ export interface LifiZapConfig {
       };
 }
 
-/**
- * a non-negative number
- */
-export type GreaterThanOrEqualTo0 = number;
-/**
- * a number between 0 and 10000
- */
-export type Between010000 = number;
-
 export interface ParaswapBuyConfig {
   resourceOut:
     | {
@@ -668,8 +696,8 @@ export interface ParaswapBuyConfig {
         chainId: Positive;
       };
   exactAmountOut: string;
-  srcDecimals: GreaterThanOrEqualTo0;
-  destDecimals: GreaterThanOrEqualTo0;
+  srcDecimals: NonNegative;
+  destDecimals: NonNegative;
   maxSlippageBps?: Between010000;
   partner?: string;
   partnerAddress?: string;

package/src/generated/materialisers.generated.ts

@@ -10,6 +10,7 @@ import type {
   BalanceOfMaterialiserConfig as BalanceOfMaterialiserConfigSchema,
   CallMaterialiserConfig as CallMaterialiserConfigSchema,
   DirectDepositMaterialiserConfig as DirectDepositMaterialiserConfigSchema,
+  FlashloanMaterialiserConfig as FlashloanMaterialiserConfigSchema,
 } from './config.generated.js';
 
 export type BalanceOfMaterialiserConfig =
@@ -42,3 +43,14 @@ export const call = (config: CallMaterialiserConfig): MaterialiserInput => ({
   kind: 'call',
   ...config,
 });
+
+export type FlashloanMaterialiserConfig =
+  MaterialiserConfigOf<FlashloanMaterialiserConfigSchema>;
+
+/** Borrow tokens from a flashloan provider; amount becomes a register populated by the proxy at callback time — accepts: resource */
+export const flashloan = (
+  config: FlashloanMaterialiserConfig,
+): MaterialiserInput => ({
+  kind: 'flashloan',
+  ...config,
+});

package/src/generated/operations.generated.ts

@@ -20,9 +20,11 @@ import type { TypedGuard } from '../types.js';
 import type {
   AaveBorrowConfig,
   AaveClaimRewardsConfig,
+  AaveGetHealthFactorConfig,
   AaveRepayConfig,
   AaveRepayWithATokensConfig,
   AaveSetEModeConfig,
+  ContinuationAssertReadyConfig,
   CoreApproveConfig,
   CoreAsResourceConfig,
   CoreBalanceOfConfig,
@@ -46,10 +48,16 @@ import type {
   InvariantNeqConfig,
   InvariantNumericConfig,
   InvariantNumericInRangeConfig,
+  LifiFlashloanRepayConfig,
   LifiSwapConfig,
   LifiZapConfig,
+  MorphoBlueBorrowConfig,
+  MorphoBlueGetPositionConfig,
+  MorphoBlueRepayConfig,
   MorphoBlueSupplyCollateralConfig,
+  MorphoBlueSupplyConfig,
   MorphoBlueWithdrawCollateralConfig,
+  MorphoBlueWithdrawConfig,
   ParaswapBuyConfig,
 } from './config.generated.js';
 
@@ -500,6 +508,13 @@ export interface AaveSetEModeArgs {
   readonly guards?: readonly TypedGuard<never>[];
 }
 
+/** Read the current Aave v3 health factor (WAD-scaled, 1e18; type(uint256).max for users with no debt) by static-calling IPool.getUserAccountData and decomposing the returned tuple. Exposes the healthFactor element as a uint256 handle suitable for use with core.numericInvariant. */
+export interface AaveGetHealthFactorArgs {
+  readonly bind: Record<string, never>;
+  readonly config: AaveGetHealthFactorConfig;
+  readonly guards?: readonly TypedGuard<'healthFactor'>[];
+}
+
 /** Deposit the collateral asset of a Morpho Blue market on behalf of the execution proxy. mode: 'exact' pulls the input handle's amount. mode: 'all' reads the proxy's current ERC20 balance of the market's collateral token and pulls that amount, ignoring the input handle's literal value — note this pulls the proxy's total balance (including unrelated upstream residuals), not just the input port's delivery. Credits Position.collateral on the Morpho singleton; emits no return value and exposes no resource output (the collateral is non-transferable accounting state). */
 export interface MorphoBlueSupplyCollateralArgs {
   readonly bind: {
@@ -516,6 +531,77 @@ export interface MorphoBlueWithdrawCollateralArgs {
   readonly guards?: readonly TypedGuard<'collateralWithdrawn'>[];
 }
 
+/** Borrow the loan asset from a Morpho Blue market against existing collateral. Exposes the borrowed amount as a Resource and the (assetsBorrowed, sharesBorrowed) tuple as handles. */
+export interface MorphoBlueBorrowArgs {
+  readonly bind: Record<string, never>;
+  readonly config: MorphoBlueBorrowConfig;
+  readonly guards?: readonly TypedGuard<'assetsBorrowed' | 'sharesBorrowed'>[];
+}
+
+/** Repay a Morpho Blue debt position with the supplied asset. mode: 'exact' repays the input handle amount; mode: 'max' reads Position.borrowShares via a precursor static call and repays in shares mode to retire the debt to the wei. Returns any unspent residual as a Resource. */
+export interface MorphoBlueRepayArgs {
+  readonly bind: {
+    readonly assetIn: Bindable<'resource'>;
+    readonly onBehalfOf: Bindable<'address'>;
+  };
+  readonly config: MorphoBlueRepayConfig;
+  readonly guards?: readonly TypedGuard<
+    'actualRepaid' | 'sharesRepaid' | 'residual'
+  >[];
+}
+
+/** Supply the loan asset of a Morpho Blue market and receive supplyShares accounting credit. Returns the (assetsSupplied, sharesSupplied) tuple as handles and any unspent residual as a Resource. */
+export interface MorphoBlueSupplyArgs {
+  readonly bind: {
+    readonly assetIn: Bindable<'resource'>;
+  };
+  readonly config: MorphoBlueSupplyConfig;
+  readonly guards?: readonly TypedGuard<
+    'assetsSupplied' | 'sharesSupplied' | 'residual'
+  >[];
+}
+
+/** Withdraw the loan asset from a Morpho Blue supply position. mode: 'exact' withdraws the configured amount; mode: 'max' reads Position.supplyShares via a precursor static call and burns all shares to retire the supply to the wei. Exposes the withdrawn amount as a Resource. */
+export interface MorphoBlueWithdrawArgs {
+  readonly bind: Record<string, never>;
+  readonly config: MorphoBlueWithdrawConfig;
+  readonly guards?: readonly TypedGuard<
+    'assetsWithdrawn' | 'sharesWithdrawn'
+  >[];
+}
+
+/** Read a Morpho Blue Position struct via a static call on the singleton. Exposes (supplyShares, borrowShares, collateral) as handles whose kinds match the on-chain field types (uint256, uint128, uint128). */
+export interface MorphoBlueGetPositionArgs {
+  readonly bind: Record<string, never>;
+  readonly config: MorphoBlueGetPositionConfig;
+  readonly guards?: readonly TypedGuard<
+    'supplyShares' | 'borrowShares' | 'collateral'
+  >[];
+}
+
+/** Transfer principal + fee back to the LiFi flashloan adapter for one leg */
+export interface LifiFlashloanRepayArgs {
+  readonly bind: {
+    readonly funds: Bindable<'resource'>;
+    readonly feeBuffer?: Bindable<'resource'>;
+  };
+  readonly config: LifiFlashloanRepayConfig;
+  readonly guards?: readonly TypedGuard<never>[];
+}
+
+/** Assert a continuation readiness check on-chain; reverts the second leg if its proceeds have not landed */
+export interface ContinuationAssertReadyArgs {
+  readonly bind: Record<string, never>;
+  readonly config: ContinuationAssertReadyConfig;
+  readonly guards?: readonly TypedGuard<never>[];
+}
+
+/** Carries a committed continuation thunk as node metadata for the settlement echo; emits no IR1 */
+export interface ContinuationCommitmentArgs {
+  readonly bind: Record<string, never>;
+  readonly guards?: readonly TypedGuard<never>[];
+}
+
 /** Route tokens into a DeFi protocol position via the edge catalog */
 export interface LifiZapArgs {
   readonly bind: {
@@ -620,11 +706,45 @@ export interface AaveClaimRewardsOutputs {
   readonly claimedAmount: OutputHandle<'uint256'>;
 }
 
+export interface AaveGetHealthFactorOutputs {
+  readonly healthFactor: OutputHandle<'uint256'>;
+}
+
 export interface MorphoBlueWithdrawCollateralOutputs {
   readonly withdrawn: OutputHandle<'resource'>;
   readonly collateralWithdrawn: OutputHandle<'uint256'>;
 }
 
+export interface MorphoBlueBorrowOutputs {
+  readonly borrowed: OutputHandle<'resource'>;
+  readonly assetsBorrowed: OutputHandle<'uint256'>;
+  readonly sharesBorrowed: OutputHandle<'uint256'>;
+}
+
+export interface MorphoBlueRepayOutputs {
+  readonly actualRepaid: OutputHandle<'uint256'>;
+  readonly sharesRepaid: OutputHandle<'uint256'>;
+  readonly residual: OutputHandle<'resource'>;
+}
+
+export interface MorphoBlueSupplyOutputs {
+  readonly assetsSupplied: OutputHandle<'uint256'>;
+  readonly sharesSupplied: OutputHandle<'uint256'>;
+  readonly residual: OutputHandle<'resource'>;
+}
+
+export interface MorphoBlueWithdrawOutputs {
+  readonly withdrawn: OutputHandle<'resource'>;
+  readonly assetsWithdrawn: OutputHandle<'uint256'>;
+  readonly sharesWithdrawn: OutputHandle<'uint256'>;
+}
+
+export interface MorphoBlueGetPositionOutputs {
+  readonly supplyShares: OutputHandle<'uint256'>;
+  readonly borrowShares: OutputHandle<'uint128'>;
+  readonly collateral: OutputHandle<'uint128'>;
+}
+
 export interface LifiZapOutputs {
   readonly amountOut: OutputHandle<'resource'>;
 }
@@ -739,6 +859,11 @@ export type GeneratedOps = {
   readonly lifi: {
     /** Swap tokens via the LI.FI aggregator API — original id: "lifi.swap" */
     readonly swap: (nodeId: string, args: LifiSwapArgs) => LifiSwapOutputs;
+    /** Transfer principal + fee back to the LiFi flashloan adapter for one leg — original id: "lifi.flashloanRepay" */
+    readonly flashloanRepay: (
+      nodeId: string,
+      args: LifiFlashloanRepayArgs,
+    ) => void;
     /** Route tokens into a DeFi protocol position via the edge catalog — original id: "lifi.zap" */
     readonly zap: (nodeId: string, args: LifiZapArgs) => LifiZapOutputs;
   };
@@ -823,6 +948,11 @@ export type GeneratedOps = {
     ) => AaveClaimRewardsOutputs;
     /** Switch the executionAddress's Aave v3 eMode category. 0 disables eMode. The pool reverts if the switch would make the position unhealthy or if any open borrow is for an asset outside the target category. — original id: "aave.setEMode" */
     readonly setEMode: (nodeId: string, args: AaveSetEModeArgs) => void;
+    /** Read the current Aave v3 health factor (WAD-scaled, 1e18; type(uint256).max for users with no debt) by static-calling IPool.getUserAccountData and decomposing the returned tuple. Exposes the healthFactor element as a uint256 handle suitable for use with core.numericInvariant. — original id: "aave.getHealthFactor" */
+    readonly getHealthFactor: (
+      nodeId: string,
+      args: AaveGetHealthFactorArgs,
+    ) => AaveGetHealthFactorOutputs;
   };
   readonly morphoBlue: {
     /** Deposit the collateral asset of a Morpho Blue market on behalf of the execution proxy. mode: 'exact' pulls the input handle's amount. mode: 'all' reads the proxy's current ERC20 balance of the market's collateral token and pulls that amount, ignoring the input handle's literal value — note this pulls the proxy's total balance (including unrelated upstream residuals), not just the input port's delivery. Credits Position.collateral on the Morpho singleton; emits no return value and exposes no resource output (the collateral is non-transferable accounting state). — original id: "morphoBlue.supplyCollateral" */
@@ -835,6 +965,43 @@ export type GeneratedOps = {
       nodeId: string,
       args: MorphoBlueWithdrawCollateralArgs,
     ) => MorphoBlueWithdrawCollateralOutputs;
+    /** Borrow the loan asset from a Morpho Blue market against existing collateral. Exposes the borrowed amount as a Resource and the (assetsBorrowed, sharesBorrowed) tuple as handles. — original id: "morphoBlue.borrow" */
+    readonly borrow: (
+      nodeId: string,
+      args: MorphoBlueBorrowArgs,
+    ) => MorphoBlueBorrowOutputs;
+    /** Repay a Morpho Blue debt position with the supplied asset. mode: 'exact' repays the input handle amount; mode: 'max' reads Position.borrowShares via a precursor static call and repays in shares mode to retire the debt to the wei. Returns any unspent residual as a Resource. — original id: "morphoBlue.repay" */
+    readonly repay: (
+      nodeId: string,
+      args: MorphoBlueRepayArgs,
+    ) => MorphoBlueRepayOutputs;
+    /** Supply the loan asset of a Morpho Blue market and receive supplyShares accounting credit. Returns the (assetsSupplied, sharesSupplied) tuple as handles and any unspent residual as a Resource. — original id: "morphoBlue.supply" */
+    readonly supply: (
+      nodeId: string,
+      args: MorphoBlueSupplyArgs,
+    ) => MorphoBlueSupplyOutputs;
+    /** Withdraw the loan asset from a Morpho Blue supply position. mode: 'exact' withdraws the configured amount; mode: 'max' reads Position.supplyShares via a precursor static call and burns all shares to retire the supply to the wei. Exposes the withdrawn amount as a Resource. — original id: "morphoBlue.withdraw" */
+    readonly withdraw: (
+      nodeId: string,
+      args: MorphoBlueWithdrawArgs,
+    ) => MorphoBlueWithdrawOutputs;
+    /** Read a Morpho Blue Position struct via a static call on the singleton. Exposes (supplyShares, borrowShares, collateral) as handles whose kinds match the on-chain field types (uint256, uint128, uint128). — original id: "morphoBlue.getPosition" */
+    readonly getPosition: (
+      nodeId: string,
+      args: MorphoBlueGetPositionArgs,
+    ) => MorphoBlueGetPositionOutputs;
+  };
+  readonly continuation: {
+    /** Assert a continuation readiness check on-chain; reverts the second leg if its proceeds have not landed — original id: "continuation.assertReady" */
+    readonly assertReady: (
+      nodeId: string,
+      args: ContinuationAssertReadyArgs,
+    ) => void;
+    /** Carries a committed continuation thunk as node metadata for the settlement echo; emits no IR1 — original id: "continuation.commitment" */
+    readonly commitment: (
+      nodeId: string,
+      args: ContinuationCommitmentArgs,
+    ) => void;
   };
   readonly paraswap: {
     /** Exact-output (BUY) swap via the Paraswap/Velora Market API: produce exactly `exactAmountOut` of the destination token, pulling only the source needed and exposing the genuinely-unspent source as `unspentIn`. — original id: "paraswap.buy" */
@@ -956,6 +1123,8 @@ export const bindGeneratedOps = (
         amountOut: 'resource',
         unspentIn: 'resource',
       } as const),
+    flashloanRepay: (nodeId: string, args: LifiFlashloanRepayArgs) =>
+      builder.call(nodeId, 'lifi.flashloanRepay', args, {}),
     zap: (nodeId: string, args: LifiZapArgs) =>
       builder.call(nodeId, 'lifi.zap', args, {
         amountOut: 'resource',
@@ -1058,6 +1227,10 @@ export const bindGeneratedOps = (
       } as const),
     setEMode: (nodeId: string, args: AaveSetEModeArgs) =>
       builder.call(nodeId, 'aave.setEMode', args, {}),
+    getHealthFactor: (nodeId: string, args: AaveGetHealthFactorArgs) =>
+      builder.call(nodeId, 'aave.getHealthFactor', args, {
+        healthFactor: 'uint256',
+      } as const),
   },
   morphoBlue: {
     supplyCollateral: (nodeId: string, args: MorphoBlueSupplyCollateralArgs) =>
@@ -1070,6 +1243,47 @@ export const bindGeneratedOps = (
         withdrawn: 'resource',
         collateralWithdrawn: 'uint256',
       } as const),
+    borrow: (nodeId: string, args: MorphoBlueBorrowArgs) =>
+      builder.call(nodeId, 'morphoBlue.borrow', args, {
+        borrowed: 'resource',
+        assetsBorrowed: 'uint256',
+        sharesBorrowed: 'uint256',
+      } as const),
+    repay: (nodeId: string, args: MorphoBlueRepayArgs) =>
+      builder.call(nodeId, 'morphoBlue.repay', args, {
+        actualRepaid: 'uint256',
+        sharesRepaid: 'uint256',
+        residual: 'resource',
+      } as const),
+    supply: (nodeId: string, args: MorphoBlueSupplyArgs) =>
+      builder.call(nodeId, 'morphoBlue.supply', args, {
+        assetsSupplied: 'uint256',
+        sharesSupplied: 'uint256',
+        residual: 'resource',
+      } as const),
+    withdraw: (nodeId: string, args: MorphoBlueWithdrawArgs) =>
+      builder.call(nodeId, 'morphoBlue.withdraw', args, {
+        withdrawn: 'resource',
+        assetsWithdrawn: 'uint256',
+        sharesWithdrawn: 'uint256',
+      } as const),
+    getPosition: (nodeId: string, args: MorphoBlueGetPositionArgs) =>
+      builder.call(nodeId, 'morphoBlue.getPosition', args, {
+        supplyShares: 'uint256',
+        borrowShares: 'uint128',
+        collateral: 'uint128',
+      } as const),
+  },
+  continuation: {
+    assertReady: (nodeId: string, args: ContinuationAssertReadyArgs) =>
+      builder.call(nodeId, 'continuation.assertReady', args, {}),
+    commitment: (nodeId: string, args: ContinuationCommitmentArgs) =>
+      builder.call(
+        nodeId,
+        'continuation.commitment',
+        { ...args, config: {} },
+        {},
+      ),
   },
   paraswap: {
     buy: (nodeId: string, args: ParaswapBuyArgs) =>

package/src/index.ts

@@ -26,7 +26,11 @@ export type {
   ZapPackEdge,
   ZapPackOverview,
 } from './discovery.js';
-export type { ComposeError, ComposeErrorCode } from './errors.js';
+export type {
+  ComposeError,
+  ComposeErrorCode,
+  ComposePreparationOps,
+} from './errors.js';
 export type {
   AppliedGuard,
   ApprovalEntry,
@@ -38,6 +42,7 @@ export type {
   ComposeContinuation,
   ComposeErrorKind,
   ComposeTransactionRequest,
+  FailedPreparedOp,
   Flow,
   InputSpec,
   MaterialiserConfigOf,
@@ -63,12 +68,18 @@ export type {
   Erc20BalanceRequirement,
   NativeBalanceRequirement,
   Erc20AllowanceRequirement,
+  ContinuationIntent,
+  ContinuationOutcome,
+  Check,
+  CheckComparator,
+  Phase1ArtifactWire,
+  ContinuationPlanWire,
 } from '@lifi/compose-spec';
 export {
   SIMULATE_MAX_TRACKED_BALANCES,
   SIMULATE_MAX_REQUIREMENTS,
 } from '@lifi/compose-spec';
-export { isComposeError } from './errors.js';
+export { isComposeError, isComposePreparationError } from './errors.js';
 
 export type {
   Bindable,

package/src/responseSchemas.ts

@@ -112,6 +112,19 @@ export const parseCompilePartialEnvelope = (
   return parsed.success ? parsed.data : null;
 };
 
+/**
+ * A single prepared-op failure inside a `preparation_error` envelope. `kind` is
+ * kept as `string` here — the narrowing to `GenericComposeErrorKind` happens in
+ * `errorFromHttpResponse`, where the value is lifted onto `ComposeError`.
+ */
+export interface ServerFailedPreparedOp {
+  readonly callId: string;
+  readonly op: string;
+  readonly kind: string;
+  readonly message: string;
+  readonly path?: string;
+}
+
 /** Error envelope returned on non-2xx responses. */
 export interface ServerErrorBody {
   readonly error?: {
@@ -119,12 +132,26 @@ export interface ServerErrorBody {
     readonly message?: string;
     readonly path?: string;
     readonly details?: SimulationRevert;
+    readonly failedOps?: readonly ServerFailedPreparedOp[];
+    readonly succeededOps?: readonly string[];
   };
 }
 
+const failedPreparedOpSchema = z.object({
+  callId: z.string(),
+  op: z.string(),
+  kind: z.string(),
+  message: z.string(),
+  path: z.string().optional(),
+});
+
 // `details` is passed through (`z.custom`) rather than parsed: the SDK does not
 // own the `SimulationRevert` schema and forwards the field verbatim onto
 // `ComposeError`.
+//
+// `failedOps`/`succeededOps` are optional here because every error kind shares
+// this envelope; they are only populated for `preparation_error` (422). Zod
+// strips undeclared keys, so omitting them would silently drop them.
 const serverErrorBodySchema = z.object({
   error: z
     .object({
@@ -132,6 +159,8 @@ const serverErrorBodySchema = z.object({
       message: z.string().optional(),
       path: z.string().optional(),
       details: z.custom<SimulationRevert>().optional(),
+      failedOps: z.array(failedPreparedOpSchema).readonly().optional(),
+      succeededOps: z.array(z.string()).readonly().optional(),
     })
     .optional(),
 });

package/src/sdk.ts

@@ -63,8 +63,8 @@ export interface ComposeSdkOptions {
   readonly baseUrl: string;
   /** Optional custom `fetch` implementation. Defaults to `globalThis.fetch`. */
   readonly fetch?: typeof globalThis.fetch;
-  /** Optional LI.FI API key for authenticated access. Sent as the `x-lifi-api-key` header on every request. */
-  readonly apiKey?: string;
+  /** LI.FI API key, sent as the `x-lifi-api-key` header on every request. Required — the Compose API rejects unauthenticated requests. */
+  readonly apiKey: string;
 }
 
 /**
@@ -77,7 +77,7 @@ export interface ComposeSdkOptions {
  * ```ts
  * import { createComposeSdk, resources, materialisers } from '@lifi/composer-sdk';
  *
- * const sdk = createComposeSdk({ baseUrl: 'https://li.quest' });
+ * const sdk = createComposeSdk({ baseUrl: 'https://li.quest', apiKey: 'YOUR_API_KEY' });
  *
  * const builder = sdk.flow(1, {
  *   inputs: { usdc: resources.erc20('0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48', 1) },
@@ -136,12 +136,12 @@ export interface ComposeSdk {
 /**
  * Creates a new Compose SDK instance.
  *
- * @param options - SDK configuration including the API base URL and optional fetch implementation.
+ * @param options - SDK configuration including the API base URL, required API key, and optional fetch implementation.
  * @returns A {@link ComposeSdk} instance.
  *
  * @example
  * ```ts
- * const sdk = createComposeSdk({ baseUrl: 'https://li.quest' });
+ * const sdk = createComposeSdk({ baseUrl: 'https://li.quest', apiKey: 'YOUR_API_KEY' });
  * ```
  */
 export const createComposeSdk = (options: ComposeSdkOptions): ComposeSdk => {