bsv-mcp 0.2.0 → 0.2.7

package/tools/bap/generate.ts

@@ -25,12 +25,10 @@ const { toArray } = BSVUtils;
 const KEY_DIR = path.join(os.homedir(), ".bsv-mcp");
 const KEY_FILE_PATH = path.join(KEY_DIR, "keys.json");
 
-const bapGenerateArgsSchema = z
-	.object({
-		alternateName: z.string().optional(),
-		description: z.string().optional(),
-	})
-	.optional();
+const bapGenerateArgsSchema = z.object({
+	alternateName: z.string().optional().describe("Alternate name for the BAP identity profile"),
+	description: z.string().optional().describe("Description for the BAP identity profile"),
+});
 
 export type BapGenerateArgs = z.infer<typeof bapGenerateArgsSchema>;
 
@@ -415,10 +413,10 @@ export function registerBapGenerateTool(server: McpServer) {
 	server.tool(
 		"bap_generate",
 		"Generates a BAP HD master key AND derives the first identity key if no BAP keys (xprv or identityPk) exist. Saves keys to secure storage. Attempts on-chain registration using payPk (honors DISABLE_BROADCASTING). Optionally takes alternateName and description for the profile.",
-		{ args: bapGenerateArgsSchema },
-		async ({ args }: { args?: BapGenerateArgs }): Promise<CallToolResult> => {
+		{ ...bapGenerateArgsSchema.shape },
+		async ({ alternateName, description }): Promise<CallToolResult> => {
 			try {
-				const result = await generateBapKeys(args);
+				const result = await generateBapKeys({ alternateName, description });
 				// Format result as JSON
 				return {
 					content: [{ type: "text", text: JSON.stringify(result, null, 2) }],

package/tools/bap/getCurrentAddress.ts

@@ -15,14 +15,7 @@ export function registerBapGetCurrentAddressTool(
 	server.tool(
 		"bap_getCurrentAddress",
 		"Retrieves the current BAP identity's Bitcoin SV address. This address is derived from the server's configured identity key.",
-		{
-			args: z
-				.object({}) // No arguments needed
-				.optional()
-				.describe(
-					"No parameters required - simply returns the current BAP identity address",
-				),
-		},
+		{},
 		async () => {
 			try {
 				let pkToUse = identityPk;

package/tools/bap/getId.ts

@@ -73,12 +73,12 @@ export function registerBapGetIdTool(
 	server.tool(
 		"bap_getId",
 		"Retrieves a Bitcoin Attestation Protocol (BAP) identity profile using an idKey (Paymail or public key). If no idKey is provided, it attempts to use the server's configured identity key.",
-		{ args: bapGetIdArgsSchema },
+		{ ...bapGetIdArgsSchema.shape },
 		async (
-			{ args }: { args: BapGetIdArgs },
+			{ idKey },
 			extra: RequestHandlerExtra<ServerRequest, ServerNotification>,
 		): Promise<CallToolResult> => {
-			let targetIdKey = args.idKey;
+			let targetIdKey = idKey;
 
 			if (!targetIdKey) {
 				// First priority: Use authenticated user's BAP ID from OAuth session

package/tools/bsocial/bmapFollow.ts

@@ -83,14 +83,10 @@ export function registerBmapReadFollowsTool(server: McpServer) {
 	server.tool(
 		"bmap_readFollows",
 		"Read follow relationships from the BMAP API. Shows who a user is following or who follows them.",
-		{ args: bmapReadFollowsArgsSchema },
-		async ({
-			args,
-		}: {
-			args: BmapReadFollowsArgs;
-		}): Promise<CallToolResult> => {
+		{ ...bmapReadFollowsArgsSchema.shape },
+		async ({ bapId, type, limit, page }): Promise<CallToolResult> => {
 			try {
-				const result = await readBmapFollows(args);
+				const result = await readBmapFollows({ bapId, type, limit, page });
 
 				if (result.success) {
 					return {

package/tools/bsocial/bmapLikes.ts

@@ -73,10 +73,10 @@ export function registerBmapReadLikesTool(server: McpServer) {
 	server.tool(
 		"bmap_readLikes",
 		"Read likes and reactions for a specific post from the BMAP API. Shows who liked the post and what emoji reactions were used.",
-		{ args: bmapReadLikesArgsSchema },
-		async ({ args }: { args: BmapReadLikesArgs }): Promise<CallToolResult> => {
+		{ ...bmapReadLikesArgsSchema.shape },
+		async ({ txid, limit, page }): Promise<CallToolResult> => {
 			try {
-				const result = await readBmapLikes(args);
+				const result = await readBmapLikes({ txid, limit, page });
 
 				if (result.success) {
 					return {

package/tools/bsocial/bmapReadPosts.ts

@@ -110,10 +110,10 @@ export function registerBmapReadPostsTool(server: McpServer) {
 	server.tool(
 		"bmap_readPosts",
 		"Read social posts from the BMAP API (query layer). Can fetch posts by author (BAP ID), specific post by transaction ID, or recent posts from all users. Supports pagination and feed functionality.",
-		{ args: bmapReadPostsArgsSchema },
-		async ({ args }: { args: BmapReadPostsArgs }): Promise<CallToolResult> => {
+		{ ...bmapReadPostsArgsSchema.shape },
+		async ({ bapId, txid, limit, page, feed, address }): Promise<CallToolResult> => {
 			try {
-				const result = await readBmapPosts(args);
+				const result = await readBmapPosts({ bapId, txid, limit, page, feed, address });
 
 				if (result.success) {
 					return {

package/tools/bsocial/createPost.ts

@@ -127,9 +127,9 @@ export function registerCreatePostTool(server: McpServer, wallet: Wallet) {
 	server.tool(
 		"bsocial_createPost",
 		"Create a social post on the BSV blockchain using B:// and MAP protocols. Posts are stored permanently on-chain and can include plain text or markdown content.",
-		{ args: createPostArgsSchema },
-		async ({ args }: { args: CreatePostArgs }): Promise<CallToolResult> => {
-			const result = await createSocialPost(args, wallet);
+		{ ...createPostArgsSchema.shape },
+		async ({ content, contentType, app, additionalMapData }): Promise<CallToolResult> => {
+			const result = await createSocialPost({ content, contentType, app, additionalMapData }, wallet);
 			return createResponse(result);
 		},
 	);

package/tools/bsocial/readPosts.ts

@@ -198,10 +198,10 @@ export function registerReadPostsTool(server: McpServer) {
 	server.tool(
 		"bsocial_readPosts",
 		"Read social posts from the BSV blockchain using BMAP API. Can fetch posts by author (BAP ID), specific post by transaction ID, or recent posts from all users. Supports pagination and feed functionality.",
-		{ args: readPostsArgsSchema },
-		async ({ args }: { args: ReadPostsArgs }): Promise<CallToolResult> => {
+		{ ...readPostsArgsSchema.shape },
+		async ({ bapId, txid, limit, page, feed }): Promise<CallToolResult> => {
 			try {
-				const result = await readSocialPosts(args);
+				const result = await readSocialPosts({ bapId, txid, limit, page, feed });
 
 				if (result.success && result.posts) {
 					// Format posts for display

package/tools/bsv/decodeTransaction.ts

@@ -123,15 +123,12 @@ export function registerDecodeTransactionTool(server: McpServer): void {
 	server.tool(
 		"bsv_decodeTransaction",
 		"Decodes and analyzes Bitcoin SV transactions to provide detailed insights. This powerful tool accepts either a transaction ID or raw transaction data and returns comprehensive information including inputs, outputs, fee calculations, script details, and blockchain context. Supports both hex and base64 encoded transactions and automatically fetches additional on-chain data when available.",
-		{
-			args: decodeTransactionArgsSchema,
-		},
+		decodeTransactionArgsSchema.shape,
 		async (
-			{ args }: { args: DecodeTransactionArgs },
+			{ tx, encoding },
 			extra: RequestHandlerExtra<ServerRequest, ServerNotification>,
 		) => {
 			try {
-				const { tx, encoding } = args;
 				let transaction: Transaction;
 				let rawTx: string;
 				let txid: string;

package/tools/bsv/explore.ts

@@ -131,10 +131,9 @@ export function registerExploreTool(server: McpServer): void {
 			"NETWORK:\n" +
 			"- health: API health check\n\n" +
 			"Use the appropriate parameters for each endpoint type and specify 'main' or 'test' network.",
-		{ args: exploreArgsSchema },
-		async ({ args }) => {
+		exploreArgsSchema.shape,
+		async (params) => {
 			try {
-				const params = exploreArgsSchema.parse(args);
 
 				// Validate required parameters for specific endpoints
 				if (

package/tools/bsv/getPrice.ts

@@ -1,5 +1,4 @@
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { z } from "zod";
 
 // Define cache duration (5 minutes in milliseconds)
 const PRICE_CACHE_DURATION = 5 * 60 * 1000;
@@ -53,14 +52,7 @@ export function registerGetPriceTool(server: McpServer): void {
 	server.tool(
 		"bsv_getPrice",
 		"Retrieves the current price of Bitcoin SV (BSV) in USD from a reliable exchange API. This tool provides real-time market data that can be used for calculating transaction values, monitoring market conditions, or converting between BSV and fiat currencies.",
-		{
-			args: z
-				.object({})
-				.optional()
-				.describe(
-					"No parameters required - simply returns the current BSV price in USD",
-				),
-		},
+		{},
 		async () => {
 			try {
 				const price = await getBsvPriceWithCache();

package/tools/bsv/token.ts

@@ -17,14 +17,11 @@ export function registerTokenTools(server: McpServer): void {
 	server.tool(
 		"bsv_toSatoshi",
 		{
-			args: z.object({
-				bitcoin: z.union([z.number(), z.string()]),
-				returnType: z.enum(["number", "string", "bigint"]).optional(),
-			}),
+			bitcoin: z.union([z.number(), z.string()]),
+			returnType: z.enum(["number", "string", "bigint"]).optional(),
 		},
-		async ({ args }) => {
+		async ({ bitcoin, returnType }) => {
 			try {
-				const { bitcoin, returnType } = args;
 				let result: number | string | bigint;
 
 				switch (returnType) {
@@ -49,14 +46,11 @@ export function registerTokenTools(server: McpServer): void {
 	server.tool(
 		"bsv_toBitcoin",
 		{
-			args: z.object({
-				satoshis: z.union([z.number(), z.string(), z.bigint()]),
-				returnType: z.enum(["number", "string", "bigint"]).optional(),
-			}),
+			satoshis: z.union([z.number(), z.string(), z.bigint()]),
+			returnType: z.enum(["number", "string", "bigint"]).optional(),
 		},
-		async ({ args }) => {
+		async ({ satoshis, returnType }) => {
 			try {
-				const { satoshis, returnType } = args;
 				let result: number | string | bigint;
 
 				switch (returnType) {
@@ -93,15 +87,12 @@ export function registerTokenTools(server: McpServer): void {
 	server.tool(
 		"bsv_toTokenSatoshi",
 		{
-			args: z.object({
-				token: z.union([z.number(), z.string(), z.bigint()]),
-				decimals: z.number().int().min(0),
-				returnType: z.enum(["number", "string", "bigint"]).optional(),
-			}),
+			token: z.union([z.number(), z.string(), z.bigint()]),
+			decimals: z.number().int().min(0),
+			returnType: z.enum(["number", "string", "bigint"]).optional(),
 		},
-		async ({ args }) => {
+		async ({ token, decimals, returnType }) => {
 			try {
-				const { token, decimals, returnType } = args;
 				let result: number | string | bigint;
 
 				switch (returnType) {
@@ -126,15 +117,12 @@ export function registerTokenTools(server: McpServer): void {
 	server.tool(
 		"bsv_toToken",
 		{
-			args: z.object({
-				tokenSatoshi: z.union([z.number(), z.string(), z.bigint()]),
-				decimals: z.number().int().min(0),
-				returnType: z.enum(["number", "string", "bigint"]).optional(),
-			}),
+			tokenSatoshi: z.union([z.number(), z.string(), z.bigint()]),
+			decimals: z.number().int().min(0),
+			returnType: z.enum(["number", "string", "bigint"]).optional(),
 		},
-		async ({ args }) => {
+		async ({ tokenSatoshi, decimals, returnType }) => {
 			try {
-				const { tokenSatoshi, decimals, returnType } = args;
 				let result: number | string | bigint;
 
 				switch (returnType) {

package/tools/index.ts

@@ -2,7 +2,6 @@ import type { PrivateKey } from "@bsv/sdk";
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { registerA2bDiscoverTool } from "./a2b/discover";
 import { registerBapTools } from "./bap";
-// import { registerBigBlocksTools } from "./bigblocks"; // Disabled - Turbopack module resolution issues
 import { registerBsocialTools } from "./bsocial";
 import { registerBsvTools } from "./bsv";
 import { registerMneeTools } from "./mnee";
@@ -26,7 +25,6 @@ import type { Wallet } from "./wallet/wallet";
  * - enableBsocialTools: controlled by DISABLE_BSOCIAL_TOOLS
  * - enableWalletTools: controlled by DISABLE_WALLET_TOOLS
  * - enableMneeTools: controlled by DISABLE_MNEE_TOOLS
- * - enableBigBlocksTools: controlled by DISABLE_BIGBLOCKS_TOOLS
  */
 export interface ToolsConfig {
 	enableBsvTools?: boolean;
@@ -37,7 +35,6 @@ export interface ToolsConfig {
 	enableBsocialTools?: boolean;
 	enableWalletTools?: boolean;
 	enableMneeTools?: boolean;
-	enableBigBlocksTools?: boolean;
 	identityPk?: PrivateKey;
 	payPk?: PrivateKey;
 	xprv?: string;
@@ -77,10 +74,6 @@ export function registerAllTools(
 	const enableBsocialTools =
 		process.env.DISABLE_BSOCIAL_TOOLS !== "true" &&
 		config.enableBsocialTools !== false;
-	const enableBigBlocksTools =
-		process.env.DISABLE_BIGBLOCKS_TOOLS !== "true" &&
-		config.enableBigBlocksTools !== false;
-
 	// Register BSV-related tools
 	if (enableBsvTools) {
 		registerBsvTools(server);
@@ -117,12 +110,6 @@ export function registerAllTools(
 		registerBsocialTools(server, { wallet: config.wallet });
 	}
 
-	// Register BigBlocks tools
-	// Disabled - Turbopack module resolution issues
-	// if (enableBigBlocksTools) {
-	// 	registerBigBlocksTools(server);
-	// }
-
 	// Register Wallet tools themselves
 	if (enableWalletTools) {
 		if (config.integratedWallet?.isDropletMode) {

package/tools/mnee/getBalance.ts

@@ -19,11 +19,9 @@ export function registerGetBalanceTool(
 	server.tool(
 		"mnee_getBalance",
 		"Retrieves the current MNEE token balance for the wallet. Returns the balance in MNEE tokens.",
-		{
-			args: getBalanceArgsSchema,
-		},
+		{},
 		async (
-			{ args }: { args: GetBalanceArgs },
+			_params,
 			extra: RequestHandlerExtra<ServerRequest, ServerNotification>,
 		) => {
 			try {

package/tools/mnee/parseTx.ts

@@ -24,13 +24,13 @@ export function registerParseTxTool(
 	server.tool(
 		"mnee_parseTx",
 		"Parse an MNEE transaction to get detailed information about its operations and amounts. All amounts are in atomic units with 5 decimal precision (e.g. 1000 atomic units = 0.01 MNEE).",
-		{ args: parseTxArgsSchema },
+		{ ...parseTxArgsSchema.shape },
 		async (
-			{ args }: { args: ParseTxArgs },
+			{ txid },
 			extra: RequestHandlerExtra<ServerRequest, ServerNotification>,
 		): Promise<CallToolResult> => {
 			try {
-				const result: ParseTxResponse = await mnee.parseTx(args.txid);
+				const result: ParseTxResponse = await mnee.parseTx(txid);
 
 				return {
 					content: [

package/tools/mnee/sendMnee.ts

@@ -42,18 +42,18 @@ export function registerSendMneeTool(server: McpServer, mnee: Mnee): void {
 	server.tool(
 		"mnee_sendMnee",
 		"Send MNEE tokens to a specified address",
-		{ args: sendMneeArgsSchema },
+		{ ...sendMneeArgsSchema.shape },
 		async (
-			{ args }: { args: SendMneeArgs },
+			{ address, amount, currency },
 			extra: RequestHandlerExtra<ServerRequest, ServerNotification>,
 		): Promise<CallToolResult> => {
 			try {
 				// Since 1 MNEE = $1, the amount is the same in both currencies
-				const mneeAmount = args.amount;
+				const mneeAmount = amount;
 
 				const transferRequest: SendMNEE[] = [
 					{
-						address: args.address,
+						address,
 						amount: mneeAmount,
 					},
 				];
@@ -101,7 +101,7 @@ export function registerSendMneeTool(server: McpServer, mnee: Mnee): void {
 									rawtx: result.rawtx,
 									mneeAmount: mneeAmount,
 									usdAmount: formatUSD(mneeAmount),
-									recipient: args.address,
+									recipient: address,
 								},
 								null,
 								2,

package/tools/ordinals/getInscription.ts

@@ -42,14 +42,13 @@ export function registerGetInscriptionTool(server: McpServer): void {
 		"ordinals_getInscription",
 		"Retrieves detailed information about a specific ordinal inscription by its outpoint. Returns complete inscription data including content type, file information, inscription origin, and current status. Useful for verifying NFT authenticity or retrieving metadata about digital artifacts.",
 		{
-			args: getInscriptionArgsSchema,
+			...getInscriptionArgsSchema.shape,
 		},
 		async (
-			{ args }: { args: GetInscriptionArgs },
+			{ outpoint },
 			extra: RequestHandlerExtra,
 		) => {
 			try {
-				const { outpoint } = args;
 
 				// Validate outpoint format
 				if (!/^[0-9a-f]{64}_\d+$/i.test(outpoint)) {

package/tools/ordinals/getTokenByIdOrTicker.ts

@@ -43,14 +43,17 @@ export function registerGetTokenByIdOrTickerTool(server: McpServer): void {
 		"ordinals_getTokenByIdOrTicker",
 		"Retrieves detailed information about a specific BSV-20 token by its ID or ticker symbol. Returns complete token data including ticker symbol, supply information, decimals, and current status. This tool is useful for verifying token authenticity or checking supply metrics.",
 		{
-			args: getTokenByIdOrTickerArgsSchema,
+			id: z
+				.string()
+				.optional()
+				.describe("BSV20 token ID in outpoint format (txid_vout)"),
+			tick: z.string().optional().describe("BSV20 token ticker symbol"),
 		},
 		async (
-			{ args }: { args: GetTokenByIdOrTickerArgs },
+			{ id, tick },
 			extra: RequestHandlerExtra,
 		) => {
 			try {
-				const { id, tick } = args;
 
 				// Validate that at least one of id or tick is provided
 				if (!id && !tick) {

package/tools/ordinals/marketListings.ts

@@ -95,29 +95,13 @@ export function registerMarketListingsTool(server: McpServer): void {
 		"ordinals_marketListings",
 		"Retrieves current marketplace listings for Bitcoin SV ordinals with flexible filtering. Supports multiple asset types (NFTs, BSV-20 tokens, BSV-21 tokens) through a unified interface. Results include listing prices, details about the assets, and seller information.",
 		{
-			args: marketListingsArgsSchema,
+			...marketListingsArgsSchema.shape,
 		},
 		async (
-			{ args }: { args: MarketListingsArgs },
+			{ limit, offset, sort, dir, address, origin, mime, num, minPrice, maxPrice, tokenType, id, tick, pending },
 			extra: RequestHandlerExtra,
 		) => {
 			try {
-				const {
-					limit,
-					offset,
-					sort,
-					dir,
-					address,
-					origin,
-					mime,
-					num,
-					minPrice,
-					maxPrice,
-					tokenType,
-					id,
-					tick,
-					pending,
-				} = args;
 
 				// Determine the API endpoint based on tokenType
 				let baseUrl = "https://ordinals.gorillapool.io/api";

package/tools/ordinals/marketSales.ts

@@ -73,12 +73,10 @@ export function registerMarketSalesTool(server: McpServer): void {
 		"ordinals_marketSales",
 		"Retrieves recent sales data for BSV-20 and BSV-21 tokens on the ordinals marketplace. This tool provides insights into market activity, including sale prices, transaction details, and token information. Supports filtering by token ID, ticker symbol, or seller address to help analyze market trends and track specific token sales.",
 		{
-			args: marketSalesArgsSchema,
+			...marketSalesArgsSchema.shape,
 		},
-		async ({ args }: { args: MarketSalesArgs }, extra: RequestHandlerExtra) => {
+		async ({ limit, offset, dir, tokenType, id, tick, pending, address }, extra: RequestHandlerExtra) => {
 			try {
-				const { limit, offset, dir, tokenType, id, tick, pending, address } =
-					args;
 
 				// Determine the API endpoint based on tokenType
 				let baseUrl = "https://ordinals.gorillapool.io/api";

package/tools/ordinals/searchInscriptions.ts

@@ -59,15 +59,13 @@ export function registerSearchInscriptionsTool(server: McpServer): void {
 		"ordinals_searchInscriptions",
 		"Searches for Bitcoin SV ordinal inscriptions using flexible criteria. This powerful search tool supports filtering by address, inscription content, MIME type, MAP fields, and other parameters. Results include detailed information about each matched inscription. Ideal for discovering NFTs and exploring the ordinals ecosystem.",
 		{
-			args: searchInscriptionsArgsSchema,
+			...searchInscriptionsArgsSchema.shape,
 		},
 		async (
-			{ args }: { args: SearchInscriptionsArgs },
+			{ limit, offset, dir, num, origin, address, map, terms, mime },
 			extra: RequestHandlerExtra,
 		) => {
 			try {
-				const { limit, offset, dir, num, origin, address, map, terms, mime } =
-					args;
 
 				// Build the URL with query parameters
 				const url = new URL(

package/tools/utils/index.ts

@@ -14,10 +14,10 @@ export function registerUtilsTools(server: McpServer): void {
 	server.tool(
 		installAgentMasterTool.name,
 		installAgentMasterTool.description,
-		{ args: installAgentMasterTool.inputSchema },
-		async ({ args }) => {
+		{ ...installAgentMasterTool.inputSchema.shape },
+		async (params) => {
 			try {
-				const result = await installAgentMasterTool.handler(args);
+				const result = await installAgentMasterTool.handler(params);
 				return {
 					content: [
 						{
@@ -62,22 +62,20 @@ export function registerUtilsTools(server: McpServer): void {
 			"- The tool returns the converted data as a string\n" +
 			"- For binary conversion, data is represented as an array of byte values",
 		{
-			args: z.object({
-				data: z.string().describe("The data string to be converted"),
-				from: encodingSchema.describe(
-					"Source encoding format (utf8, hex, base64, or binary)",
-				),
-				to: encodingSchema.describe(
-					"Target encoding format to convert to (utf8, hex, base64, or binary)",
-				),
-			}),
+			data: z.string().describe("The data string to be converted"),
+			from: encodingSchema.describe(
+				"Source encoding format (utf8, hex, base64, or binary)",
+			),
+			to: encodingSchema.describe(
+				"Target encoding format to convert to (utf8, hex, base64, or binary)",
+			),
 		},
-		async ({ args }) => {
+		async ({ data, from, to }) => {
 			try {
 				const result = convertData({
-					data: args.data,
-					from: args.from,
-					to: args.to,
+					data,
+					from,
+					to,
 				});
 				return {
 					content: [

package/tools/wallet/a2bPublishAgent.ts

@@ -1,10 +1,5 @@
 import { PrivateKey, Utils } from "@bsv/sdk";
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import type { RequestHandlerExtra } from "@modelcontextprotocol/sdk/shared/protocol.js";
-import type {
-	ServerNotification,
-	ServerRequest,
-} from "@modelcontextprotocol/sdk/types.js";
 import type {
 	ChangeResult,
 	CreateOrdinalsConfig,
@@ -14,7 +9,6 @@ import type {
 	PreMAP,
 } from "js-1sat-ord";
 import { createOrdinals } from "js-1sat-ord";
-import { Sigma } from "sigma-protocol";
 import { z } from "zod";
 import packageJson from "../../package.json";
 import { V5Broadcaster } from "../../utils/broadcaster";
@@ -155,11 +149,8 @@ export function registerA2bPublishAgentTool(server: McpServer, wallet: Wallet) {
 	server.tool(
 		"wallet_a2bPublish",
 		"Publish an agent.json record on-chain via Ordinal inscription",
-		{ args: a2bPublishArgsSchema },
-		async (
-			{ args }: { args: A2bPublishArgs },
-			extra: RequestHandlerExtra<ServerRequest, ServerNotification>,
-		) => {
+		{ ...a2bPublishArgsSchema.shape },
+		async ({ agentUrl, agentName, description, providerOrganization, providerUrl, version, documentationUrl, streaming, pushNotifications, stateTransitionHistory, defaultInputModes, defaultOutputModes, skills, destinationAddress }) => {
 			try {
 				const paymentPk = wallet.getPaymentKey();
 				if (!paymentPk) throw new Error("No private key available");
@@ -167,7 +158,7 @@ export function registerA2bPublishAgentTool(server: McpServer, wallet: Wallet) {
 				if (!paymentUtxos?.length)
 					throw new Error("No payment UTXOs available to fund inscription");
 
-				// TODO: Get the skills from actually running the MCP instead of trusting the agent args for args.skills
+				// TODO: Get the skills from actually running the MCP instead of trusting the agent args for skills
 				const walletAddress = paymentPk.toAddress().toString();
 
 				// Create pricing plans using the new schema
@@ -212,27 +203,27 @@ export function registerA2bPublishAgentTool(server: McpServer, wallet: Wallet) {
 
 				// Assemble AgentCard with defaults and user overrides
 				const agentCard = {
-					name: args.agentName,
-					description: args.description ?? null,
-					url: args.agentUrl,
+					name: agentName,
+					description: description ?? null,
+					url: agentUrl,
 					provider:
-						args.providerOrganization && args.providerUrl
+						providerOrganization && providerUrl
 							? {
-									organization: args.providerOrganization,
-									url: args.providerUrl,
+									organization: providerOrganization,
+									url: providerUrl,
 								}
 							: null,
-					version: args.version ?? packageJson.version,
-					documentationUrl: args.documentationUrl ?? null,
+					version: version ?? packageJson.version,
+					documentationUrl: documentationUrl ?? null,
 					capabilities: {
-						streaming: args.streaming,
-						pushNotifications: args.pushNotifications,
-						stateTransitionHistory: args.stateTransitionHistory,
+						streaming,
+						pushNotifications,
+						stateTransitionHistory,
 					},
 					authentication: null,
-					defaultInputModes: args.defaultInputModes,
-					defaultOutputModes: args.defaultOutputModes,
-					skills: args.skills,
+					defaultInputModes,
+					defaultOutputModes,
+					skills,
 					"x-payment-config": pricingConfig,
 				};
 				// Validate compliance
@@ -245,7 +236,7 @@ export function registerA2bPublishAgentTool(server: McpServer, wallet: Wallet) {
 					contentType: "application/json",
 				};
 				// Destination for the ordinal
-				const targetAddress = args.destinationAddress ?? walletAddress;
+				const targetAddress = destinationAddress ?? walletAddress;
 				const destinations: Destination[] = [
 					{ address: targetAddress, inscription },
 				];