@sundaeswap/sprinkles 0.7.0 → 0.8.0

package/src/Sprinkle/actions/builtin/native-script.ts

@@ -0,0 +1,165 @@
+/**
+ * Native script utilities for Sprinkle actions.
+ *
+ * Provides conversion from user-friendly input formats (CBOR hex or structured JSON)
+ * to Blaze NativeScript objects, and a helper to attach scripts during tx completion.
+ */
+
+import { Core } from "@blaze-cardano/sdk";
+import type { TxBuilder } from "@blaze-cardano/tx";
+import type { TSchema } from "@sinclair/typebox";
+import type { TMultisigScript } from "../../schemas.js";
+import { ActionError } from "../types.js";
+import type { IActionContext } from "../types.js";
+
+/** Input type: either a CBOR hex string or a MultisigScript JSON structure */
+export type NativeScriptInput = string | TMultisigScript;
+
+/**
+ * Converts a MultisigScript JSON structure to a Blaze NativeScript.
+ * Handles the recursive structure (AllOf, AnyOf, AtLeast contain nested scripts).
+ */
+function multisigToNativeScript(ms: TMultisigScript): Core.NativeScript {
+  if ("Signature" in ms) {
+    const hash = Core.Ed25519KeyHashHex(ms.Signature.key_hash);
+    return Core.NativeScript.newScriptPubkey(new Core.ScriptPubkey(hash));
+  }
+  if ("AllOf" in ms) {
+    const scripts = ms.AllOf.scripts.map(multisigToNativeScript);
+    return Core.NativeScript.newScriptAll(new Core.ScriptAll(scripts));
+  }
+  if ("AnyOf" in ms) {
+    const scripts = ms.AnyOf.scripts.map(multisigToNativeScript);
+    return Core.NativeScript.newScriptAny(new Core.ScriptAny(scripts));
+  }
+  if ("AtLeast" in ms) {
+    const scripts = ms.AtLeast.scripts.map(multisigToNativeScript);
+    return Core.NativeScript.newScriptNOfK(
+      new Core.ScriptNOfK(scripts, Number(ms.AtLeast.required)),
+    );
+  }
+  if ("Before" in ms) {
+    return Core.NativeScript.newTimelockExpiry(
+      new Core.TimelockExpiry(Core.Slot(Number(ms.Before.time))),
+    );
+  }
+  if ("After" in ms) {
+    return Core.NativeScript.newTimelockStart(
+      new Core.TimelockStart(Core.Slot(Number(ms.After.time))),
+    );
+  }
+  if ("Script" in ms) {
+    // Script variant references a script by hash — this is a ScriptPubkey
+    // but using the script hash directly as a key hash reference
+    const hash = Core.Ed25519KeyHashHex(ms.Script.script_hash);
+    return Core.NativeScript.newScriptPubkey(new Core.ScriptPubkey(hash));
+  }
+
+  throw new ActionError(
+    "Unrecognized MultisigScript variant",
+    "INVALID_NATIVE_SCRIPT",
+    { input: ms },
+  );
+}
+
+/**
+ * Converts a native script input (CBOR hex string or MultisigScript JSON)
+ * to a Blaze Script object suitable for `provideScript()`.
+ */
+export function toNativeScript(input: NativeScriptInput): Core.Script {
+  if (typeof input === "string") {
+    try {
+      const nativeScript = Core.NativeScript.fromCbor(
+        Core.HexBlob(input),
+      );
+      return Core.Script.newNativeScript(nativeScript);
+    } catch (err) {
+      throw new ActionError(
+        `Invalid native script CBOR: ${err instanceof Error ? err.message : String(err)}`,
+        "INVALID_NATIVE_SCRIPT",
+        { error: err instanceof Error ? err.message : String(err) },
+      );
+    }
+  }
+
+  try {
+    const nativeScript = multisigToNativeScript(input);
+    return Core.Script.newNativeScript(nativeScript);
+  } catch (err) {
+    if (err instanceof ActionError) throw err;
+    throw new ActionError(
+      `Failed to convert MultisigScript to native script: ${err instanceof Error ? err.message : String(err)}`,
+      "INVALID_NATIVE_SCRIPT",
+      { error: err instanceof Error ? err.message : String(err) },
+    );
+  }
+}
+
+/** Regex to extract a script hash from Blaze's "Could not resolve script hash" error */
+const MISSING_SCRIPT_HASH_RE =
+  /complete: Could not resolve script hash[: ]*([0-9a-fA-F]+)/;
+
+/**
+ * Builds a hash → Script lookup from the addressbook in the sprinkle context.
+ * Returns an empty map if there's no addressbook.
+ */
+function buildAddressbookIndex(
+  addressbook: Record<string, TMultisigScript> | undefined,
+): Map<string, Core.Script> {
+  const index = new Map<string, Core.Script>();
+  if (!addressbook) return index;
+  for (const [, ms] of Object.entries(addressbook)) {
+    try {
+      const script = toNativeScript(ms);
+      index.set(script.hash(), script);
+    } catch {
+      // Skip invalid addressbook entries
+    }
+  }
+  return index;
+}
+
+/**
+ * Attaches optional native scripts to a transaction builder and completes it.
+ *
+ * If completion fails because Blaze cannot resolve a required native script hash,
+ * and a context with an addressbook is provided, it will look up the missing script
+ * by hash in the addressbook and retry once.
+ */
+export async function completeWithScripts<S extends TSchema>(
+  txBuilder: TxBuilder,
+  nativeScripts?: NativeScriptInput[],
+  context?: IActionContext<S>,
+): Promise<Core.Transaction> {
+  if (nativeScripts?.length) {
+    for (const input of nativeScripts) {
+      txBuilder.provideScript(toNativeScript(input));
+    }
+  }
+
+  try {
+    return await txBuilder.complete();
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    const match = message.match(MISSING_SCRIPT_HASH_RE);
+
+    if (!match || !context?.sprinkle?.addressbook) {
+      throw err;
+    }
+
+    // Build hash index from addressbook and try to resolve the missing script
+    const addressbookIndex = buildAddressbookIndex(
+      context.sprinkle.addressbook,
+    );
+    const missingHash = match[1];
+    const script = addressbookIndex.get(missingHash);
+
+    if (!script) {
+      throw err;
+    }
+
+    // Attach the found script and retry
+    txBuilder.provideScript(script);
+    return txBuilder.complete();
+  }
+}

package/src/Sprinkle/actions/builtin/utility-actions.ts

@@ -0,0 +1,285 @@
+/**
+ * Built-in utility actions for the Sprinkle action system.
+ * These actions provide common Cardano operations: minting tokens,
+ * sending ADA/tokens, and registering stake scripts.
+ */
+
+import { Type } from "@sinclair/typebox";
+import type { TSchema } from "@sinclair/typebox";
+import { Core, makeValue } from "@blaze-cardano/sdk";
+import { ActionError } from "../types.js";
+import type { IAction } from "../types.js";
+import { getBlazeFromContext, isHotWallet } from "./blaze-helper.js";
+import { NativeScriptsParam } from "../../schemas.js";
+import type { NativeScriptInput } from "./native-script.js";
+import { completeWithScripts } from "./native-script.js";
+
+/**
+ * `mint-token` -- Mint native tokens using a native script derived from the wallet's payment key.
+ * The policy is a simple ScriptPubkey requiring the wallet's payment credential to sign.
+ * Requires a hot wallet.
+ */
+export const mintToken: IAction<
+  { tokenName: string; amount: string; nativeScripts?: NativeScriptInput[] },
+  { policyId: string; tokenName: string; amount: string; txCbor: string },
+  TSchema
+> = {
+  name: "mint-token",
+  description:
+    "Mint native tokens using a native script policy derived from the wallet's payment key.",
+  category: "utility",
+  inputSchema: Type.Object({
+    tokenName: Type.String({ description: "Name of the token to mint" }),
+    amount: Type.String({
+      description: "Amount of tokens to mint (as string for BigInt safety)",
+    }),
+    nativeScripts: NativeScriptsParam,
+  }),
+  outputSchema: Type.Object({
+    policyId: Type.String({ description: "Policy ID of the minted token" }),
+    tokenName: Type.String({ description: "Token name" }),
+    amount: Type.String({ description: "Amount minted" }),
+    txCbor: Type.String({
+      description: "Unsigned transaction CBOR hex ready for signing",
+    }),
+  }),
+  execute: async (input, context) => {
+    const blaze = await getBlazeFromContext(context);
+
+    if (!isHotWallet(blaze)) {
+      throw new ActionError(
+        "Mint token requires a hot wallet to derive the native script policy.",
+        "COLD_WALLET",
+      );
+    }
+
+    // Get the wallet's payment credential hash for the native script
+    let address: Core.Address;
+    try {
+      address = await blaze.wallet.getChangeAddress();
+    } catch (err) {
+      throw new ActionError(
+        `Failed to get wallet address: ${err instanceof Error ? err.message : String(err)}`,
+        "NO_ADDRESS",
+        { error: err instanceof Error ? err.message : String(err) },
+      );
+    }
+
+    const baseAddress = address.asBase();
+    if (!baseAddress) {
+      throw new ActionError(
+        "Could not derive base address from wallet. Ensure the wallet has a payment credential.",
+        "INVALID_ADDRESS",
+      );
+    }
+
+    const paymentCredential = baseAddress.getPaymentCredential();
+    if (!paymentCredential?.hash) {
+      throw new ActionError(
+        "Could not extract payment credential hash from wallet address.",
+        "NO_PAYMENT_CREDENTIAL",
+      );
+    }
+
+    const hash = Core.Ed25519KeyHashHex(paymentCredential.hash.toString());
+    const tokenPolicy = new Core.ScriptPubkey(hash);
+    const policy = Core.Script.newNativeScript(
+      Core.NativeScript.newScriptPubkey(tokenPolicy),
+    );
+
+    const policyId = policy.hash();
+    const assetName = Core.AssetName(
+      Core.toHex(Buffer.from(input.tokenName)),
+    );
+    const mintAmount = BigInt(input.amount);
+
+    const mints = new Map<Core.AssetName, bigint>();
+    mints.set(assetName, mintAmount);
+
+    let tx: Core.Transaction;
+    try {
+      const txBuilder = blaze
+        .newTransaction()
+        .addMint(Core.PolicyId(policyId), mints)
+        .provideScript(policy);
+      tx = await completeWithScripts(txBuilder, input.nativeScripts, context);
+    } catch (err) {
+      if (err instanceof ActionError) throw err;
+      throw new ActionError(
+        `Failed to build mint transaction: ${err instanceof Error ? err.message : String(err)}`,
+        "BUILD_ERROR",
+        { error: err instanceof Error ? err.message : String(err) },
+      );
+    }
+
+    return {
+      policyId: policyId.toString(),
+      tokenName: input.tokenName,
+      amount: input.amount,
+      txCbor: tx.toCbor(),
+    };
+  },
+};
+
+/**
+ * `simple-send` -- Send ADA or a native token to a recipient address.
+ * Builds an unsigned transaction that can be signed via TxDialog or sign-transaction.
+ */
+export const simpleSend: IAction<
+  {
+    recipientAddress: string;
+    lovelace?: string;
+    policyId?: string;
+    assetName?: string;
+    tokenAmount?: string;
+    nativeScripts?: NativeScriptInput[];
+  },
+  { txCbor: string },
+  TSchema
+> = {
+  name: "simple-send",
+  description: "Send ADA or a native token to a recipient address.",
+  category: "wallet",
+  inputSchema: Type.Object({
+    recipientAddress: Type.String({
+      description: "Bech32 recipient address",
+    }),
+    lovelace: Type.Optional(
+      Type.String({
+        description:
+          "Amount of lovelace to send (as string for BigInt safety). Required if not sending a token.",
+      }),
+    ),
+    policyId: Type.Optional(
+      Type.String({ description: "Policy ID of the token to send" }),
+    ),
+    assetName: Type.Optional(
+      Type.String({
+        description: "Asset name of the token to send (hex-encoded)",
+      }),
+    ),
+    tokenAmount: Type.Optional(
+      Type.String({
+        description: "Amount of tokens to send (as string for BigInt safety)",
+      }),
+    ),
+    nativeScripts: NativeScriptsParam,
+  }),
+  outputSchema: Type.Object({
+    txCbor: Type.String({
+      description: "Unsigned transaction CBOR hex ready for signing",
+    }),
+  }),
+  execute: async (input, context) => {
+    const blaze = await getBlazeFromContext(context);
+
+    // Validate: must provide lovelace or token details
+    const hasToken = input.policyId && input.assetName && input.tokenAmount;
+    if (!input.lovelace && !hasToken) {
+      throw new ActionError(
+        "Must provide either lovelace amount or token details (policyId, assetName, tokenAmount).",
+        "INVALID_INPUT",
+      );
+    }
+
+    let recipient: Core.Address;
+    try {
+      recipient = Core.Address.fromBech32(input.recipientAddress);
+    } catch (err) {
+      throw new ActionError(
+        `Invalid recipient address: ${err instanceof Error ? err.message : String(err)}`,
+        "INVALID_ADDRESS",
+        { error: err instanceof Error ? err.message : String(err) },
+      );
+    }
+
+    let value: Core.Value;
+    if (hasToken) {
+      const assetId =
+        `${input.policyId}${input.assetName}` as Core.AssetId;
+      value = makeValue(
+        BigInt(input.lovelace ?? "0"),
+        [assetId, BigInt(input.tokenAmount!)],
+      );
+    } else {
+      value = makeValue(BigInt(input.lovelace!));
+    }
+
+    let tx: Core.Transaction;
+    try {
+      const txBuilder = blaze.newTransaction().payAssets(recipient, value);
+      tx = await completeWithScripts(txBuilder, input.nativeScripts, context);
+    } catch (err) {
+      if (err instanceof ActionError) throw err;
+      throw new ActionError(
+        `Failed to build send transaction: ${err instanceof Error ? err.message : String(err)}`,
+        "BUILD_ERROR",
+        { error: err instanceof Error ? err.message : String(err) },
+      );
+    }
+
+    return {
+      txCbor: tx.toCbor(),
+    };
+  },
+};
+
+/**
+ * `register-stake-script` -- Register a stake script credential on-chain.
+ * Takes a script hash and builds a stake registration transaction.
+ */
+export const registerStakeScript: IAction<
+  { scriptHash: string; nativeScripts?: NativeScriptInput[] },
+  { txCbor: string },
+  TSchema
+> = {
+  name: "register-stake-script",
+  description:
+    "Register a stake script credential on-chain. Takes a script hash (hex) and builds the registration transaction.",
+  category: "utility",
+  inputSchema: Type.Object({
+    scriptHash: Type.String({
+      description: "Stake script hash in hex (28 bytes / 56 hex characters)",
+    }),
+    nativeScripts: NativeScriptsParam,
+  }),
+  outputSchema: Type.Object({
+    txCbor: Type.String({
+      description: "Unsigned transaction CBOR hex ready for signing",
+    }),
+  }),
+  execute: async (input, context) => {
+    const blaze = await getBlazeFromContext(context);
+
+    // Validate hex format
+    if (!/^[0-9a-fA-F]{56}$/.test(input.scriptHash)) {
+      throw new ActionError(
+        "Script hash must be exactly 56 hex characters (28 bytes).",
+        "INVALID_SCRIPT_HASH",
+        { provided: input.scriptHash },
+      );
+    }
+
+    const credential = Core.Credential.fromCore({
+      hash: Core.Hash28ByteBase16(input.scriptHash),
+      type: Core.CredentialType.ScriptHash,
+    });
+
+    let tx: Core.Transaction;
+    try {
+      const txBuilder = blaze.newTransaction().addRegisterStake(credential);
+      tx = await completeWithScripts(txBuilder, input.nativeScripts, context);
+    } catch (err) {
+      if (err instanceof ActionError) throw err;
+      throw new ActionError(
+        `Failed to build stake registration transaction: ${err instanceof Error ? err.message : String(err)}`,
+        "BUILD_ERROR",
+        { error: err instanceof Error ? err.message : String(err) },
+      );
+    }
+
+    return {
+      txCbor: tx.toCbor(),
+    };
+  },
+};

package/src/Sprinkle/actions/cli-adapter.ts

@@ -132,18 +132,34 @@ export function coerceValue(raw: unknown, schema: TSchema): unknown {
   }
 
   if (isObject(schema)) {
+    let obj = raw;
     // If it's a JSON string, parse it
     if (typeof raw === "string") {
       const trimmed = raw.trim();
       if (trimmed.startsWith("{")) {
         try {
-          return JSON.parse(trimmed);
+          obj = JSON.parse(trimmed);
         } catch {
           return raw;
         }
+      } else {
+        return raw;
       }
     }
-    return raw;
+    // Recurse into properties to coerce nested values
+    if (typeof obj === "object" && obj !== null && !Array.isArray(obj)) {
+      const props = schema.properties as Record<string, TSchema> | undefined;
+      if (props) {
+        const result: Record<string, unknown> = { ...(obj as Record<string, unknown>) };
+        for (const [key, propSchema] of Object.entries(props)) {
+          if (key in result) {
+            result[key] = coerceValue(result[key], propSchema);
+          }
+        }
+        return result;
+      }
+    }
+    return obj;
   }
 
   if (isString(schema)) {

package/src/Sprinkle/actions/index.ts

@@ -27,6 +27,7 @@ export {
   runMcp,
 } from "./mcp-adapter.js";
 
-export { getBuiltinActions } from "./builtin/index.js";
+export { getBuiltinActions, toNativeScript, completeWithScripts } from "./builtin/index.js";
+export type { NativeScriptInput } from "./builtin/index.js";
 
 export { promptAndExecute } from "./tui-helpers.js";

package/src/Sprinkle/actions/mcp-adapter.ts

@@ -3,6 +3,7 @@
  *
  * Provides:
  * - TypeBox to JSON Schema conversion (typeboxToJsonSchema)
+ * - TypeBox to Zod conversion for MCP SDK compatibility (typeboxToZod)
  * - BigInt string coercion for MCP input (coerceMcpInput)
  * - Lazy MCP SDK import with graceful error (getMcpSdk)
  * - MCP server creation from registered actions (createMcpServer)
@@ -279,6 +280,180 @@ export function coerceMcpInput(input: unknown, schema: TSchema): unknown {
   return input;
 }
 
+// ---------------------------------------------------------------------------
+// TypeBox to Zod conversion
+// ---------------------------------------------------------------------------
+
+/**
+ * Zod module shape (the parts we use from zod).
+ * Typed loosely since zod is a transitive dependency of @modelcontextprotocol/sdk,
+ * not a direct dependency of Sprinkles.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type ZodType = any;
+interface IZodModule {
+  string: () => ZodType;
+  number: () => ZodType;
+  boolean: () => ZodType;
+  literal: (value: unknown) => ZodType;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  object: (shape: Record<string, any>) => ZodType;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  array: (item: any) => ZodType;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  union: (members: any[]) => ZodType;
+  nullType: () => ZodType;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  any: () => any;
+}
+
+let _zod: IZodModule | undefined;
+
+/**
+ * Lazily import the Zod module.
+ * Zod is a transitive dependency of @modelcontextprotocol/sdk, so it's
+ * guaranteed to be available when MCP mode is used.
+ */
+async function getZod(): Promise<IZodModule> {
+  if (_zod) return _zod;
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const mod = (await import("zod")) as any;
+    _zod = {
+      string: () => mod.string(),
+      number: () => mod.number(),
+      boolean: () => mod.boolean(),
+      literal: (v: unknown) => mod.literal(v),
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      object: (shape: Record<string, any>) => mod.object(shape),
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      array: (item: any) => mod.array(item),
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      union: (members: any[]) => mod.union(members),
+      nullType: () => mod.nullType(),
+      any: () => mod.any(),
+    };
+    return _zod;
+  } catch {
+    throw new Error(
+      "MCP mode requires zod (via @modelcontextprotocol/sdk). Install @modelcontextprotocol/sdk.",
+    );
+  }
+}
+
+/**
+ * Convert a TypeBox schema to a Zod schema for MCP SDK compatibility.
+ *
+ * The MCP SDK (v1.27+) expects Zod schemas for tool input validation,
+ * not plain JSON Schema objects. This function converts TypeBox schemas
+ * to their Zod equivalents so the SDK correctly registers tool parameters.
+ *
+ * BigInt fields are represented as z.string() with a regex pattern since
+ * JSON (and thus MCP) has no BigInt type. The coerceMcpInput function
+ * handles converting these string values back to BigInt at call time.
+ */
+export async function typeboxToZod(schema: TSchema): Promise<ZodType> {
+  const z = await getZod();
+  return _typeboxToZod(schema, z);
+}
+
+function _typeboxToZod(schema: TSchema, z: IZodModule): ZodType {
+  if (isBigInt(schema)) {
+    // BigInt -> string with regex pattern (JSON has no BigInt)
+    return z.string().regex(/^-?[0-9]+$/);
+  }
+
+  if (isString(schema)) {
+    let s = z.string();
+    if (schema.description) s = s.describe(schema.description);
+    return s;
+  }
+
+  if (isNumber(schema) || isInteger(schema)) {
+    let n = z.number();
+    if (schema.description) n = n.describe(schema.description);
+    return n;
+  }
+
+  if (isBoolean(schema)) {
+    let b = z.boolean();
+    if (schema.description) b = b.describe(schema.description);
+    return b;
+  }
+
+  if (isNull(schema)) {
+    return z.nullType();
+  }
+
+  if (isLiteral(schema)) {
+    return z.literal(schema.const);
+  }
+
+  if (isArray(schema)) {
+    const itemSchema = (schema as { items?: TSchema }).items;
+    if (itemSchema) {
+      return z.array(_typeboxToZod(itemSchema, z));
+    }
+    return z.array(z.any());
+  }
+
+  if (isObject(schema)) {
+    const properties = schema.properties as Record<string, TSchema>;
+    const shape: Record<string, ZodType> = {};
+
+    for (const [propName, propSchema] of Object.entries(properties)) {
+      let zodProp = _typeboxToZod(propSchema, z);
+      if (isOptional(propSchema)) {
+        zodProp = zodProp.optional();
+      }
+      shape[propName] = zodProp;
+    }
+
+    return z.object(shape);
+  }
+
+  if (isUnion(schema)) {
+    const members = schema.anyOf.map((member: TSchema) =>
+      _typeboxToZod(member, z),
+    );
+    if (members.length >= 2) {
+      return z.union(members);
+    }
+    return members[0] ?? z.any();
+  }
+
+  // Fallback: accept anything
+  return z.any();
+}
+
+/**
+ * Convert a TypeBox object schema to a Zod "raw shape" (Record<string, ZodType>).
+ * This is the format expected by the MCP SDK's tool() API.
+ */
+export async function typeboxToZodShape(
+  schema: TSchema,
+): Promise<Record<string, ZodType>> {
+  const z = await getZod();
+
+  if (!isObject(schema)) {
+    // Non-object input schemas get wrapped as { input: zodSchema }
+    return { input: _typeboxToZod(schema, z) };
+  }
+
+  const properties = schema.properties as Record<string, TSchema>;
+  const shape: Record<string, ZodType> = {};
+
+  for (const [propName, propSchema] of Object.entries(properties)) {
+    let zodProp = _typeboxToZod(propSchema, z);
+    if (isOptional(propSchema)) {
+      zodProp = zodProp.optional();
+    }
+    shape[propName] = zodProp;
+  }
+
+  return shape;
+}
+
 // ---------------------------------------------------------------------------
 // Lazy MCP SDK import
 // ---------------------------------------------------------------------------
@@ -364,15 +539,15 @@ export async function createMcpServer<S extends TSchema>(
   const actions = sprinkle.listActions() as AnyAction<S>[];
 
   for (const action of actions) {
-    const inputSchema = typeboxToJsonSchema(action.inputSchema);
+    const zodShape = await typeboxToZodShape(action.inputSchema);
 
     // Register the action as an MCP tool.
-    // The high-level McpServer.tool() API accepts:
-    //   tool(name, description, schema, handler)
+    // The high-level McpServer.tool() API accepts a Zod raw shape
+    // (Record<string, ZodType>) for input validation.
     server.tool(
       action.name,
       action.description,
-      inputSchema,
+      zodShape,
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
       async (input: unknown): Promise<any> => {
         const coercedInput = coerceMcpInput(input, action.inputSchema);