fix: mcp output structure (#26)

Author: ijusttookadnatest

.github/workflows/ci.yml

@@ -39,7 +39,7 @@ jobs:
             ${{ runner.os }}-pnpm-store-
 
       - name: Install dependencies
-        run: pnpm install --force
+        run: pnpm install
 
       - name: Check formatting with Prettier
         run: pnpm prettier --check "packages/**/*.{ts,tsx}"

packages/core/src/interfaces/index.ts

@@ -1,6 +1,12 @@
 import { z } from 'zod';
 import { Account, RpcProvider } from 'starknet';
 
+export interface toolResult {
+  status: 'success' | 'failure';
+  data?: Record<string, any> | Array<any>;
+  error?: string;
+}
+
 export interface mcpTool {
   name: string;
   description: string;

packages/core/src/utils/index.ts

@@ -26,6 +26,25 @@ const extractBaseSchema = (schema: z.ZodTypeAny): z.ZodObject<any> => {
   throw new Error('Unable to extract base schema from provided Zod schema');
 };
 
+/**
+ * Format tool execution result for MCP response
+ * @param result - The result object from tool execution
+ * @returns Formatted MCP response
+ */
+const formatToolResult = (result: any) => {
+  return {
+    isError: result.status === 'failure' ? true : false,
+    content: [
+      {
+        type: 'text',
+        text: JSON.stringify(
+          result.status === 'failure' ? result.error : result.data
+        ),
+      },
+    ],
+  };
+};
+
 /**
  * Register MCP tools with a server instance
  * @param server - The MCP server instance
@@ -39,31 +58,17 @@ export const registerToolsWithServer = async (
     if (!tool.schema) {
       server.tool(tool.name, tool.description, async () => {
         const result = await tool.execute({});
-        return {
-          content: [
-            {
-              type: 'text',
-              text: JSON.stringify(result),
-            },
-          ],
-        };
+        return formatToolResult(result);
       });
     } else {
       const baseSchema = extractBaseSchema(tool.schema);
       server.tool(
         tool.name,
         tool.description,
         baseSchema.shape,
-        async (params: any, extra: any) => {
+        async (params: any, _extra: any) => {
           const result = await tool.execute(params);
-          return {
-            content: [
-              {
-                type: 'text',
-                text: JSON.stringify(result),
-              },
-            ],
-          };
+          return formatToolResult(result);
         }
       );
     }

packages/mcp/__test__/e2e/env.test.js

@@ -3,8 +3,8 @@ import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
 
 const transport = new StdioClientTransport({
-  command: 'npx',
-  args: ['-y', '@kasarlabs/ask-starknet-mcp@latest'],
+  command: 'node',
+  args: ['build/index.js'],
 });
 
 const client = new Client({
@@ -14,41 +14,16 @@ const client = new Client({
 
 try {
   await client.connect(transport);
-
-  // const result = await client.callTool({
-  //   name: "perform_starknet_actions",
-  //   arguments: {
-  //     userInput: "I want to create a new Argent account, then transfer 0.2 STRK to it with my account, then deploy it"
-  //   }
-  // });
-
   const result = await client.callTool({
     name: 'ask_starknet',
     arguments: {
-      userInput: 'can you bridge my fund with starkgate?',
+      userInput: 'can you deploy account argent 0x2251?',
+      rawTools: true,
     },
   });
+  console.log(result);
   const response = JSON.parse(result.content[0].text);
   console.log(response);
-
-  const result2 = await client.callTool({
-    name: 'ask_starknet',
-    arguments: {
-      userInput: 'help',
-    },
-  });
-
-  const response2 = JSON.parse(result2.content[0].text);
-  console.log(response2);
-
-  const result3 = await client.callTool({
-    name: 'ask_starknet',
-    arguments: {
-      userInput: 'how can i use ask-starknet to build a project in defi',
-    },
-  });
-  const response3 = JSON.parse(result3.content[0].text);
-  console.log(response3);
 } catch (error) {
   console.error('Error:', error.message);
 } finally {

packages/mcp/mcp-test.json

@@ -0,0 +1,11 @@
+{
+  "mcpServers": {
+    "ask-starknet": {
+      "command": "node",
+      "args": ["build/index.js"],
+      "env": {
+        "NODE_ENV": "local"
+      }
+    }
+  }
+}

packages/mcp/src/graph/agents/specialized.ts

@@ -13,6 +13,21 @@ import { MCPEnvironment } from '../mcps/interfaces.js';
 import { createLLM } from '../../utils/llm.js';
 import { specializedPrompt } from './prompts.js';
 
+// Cache for LLM instances to avoid recreating them and accumulating listeners
+const llmCache = new Map<string, ReturnType<typeof createLLM>>();
+
+function getCachedLLM(env: MCPEnvironment) {
+  const cacheKey =
+    env.ANTHROPIC_API_KEY || env.GEMINI_API_KEY || env.OPENAI_API_KEY || '';
+
+  if (!llmCache.has(cacheKey)) {
+    const llm = createLLM(env);
+    llmCache.set(cacheKey, llm);
+  }
+
+  return llmCache.get(cacheKey)!;
+}
+
 async function specializedAgent(mcpServerName: string, env: MCPEnvironment) {
   const client = new MultiServerMCPClient({
     mcpServers: {
@@ -28,7 +43,7 @@ async function specializedAgent(mcpServerName: string, env: MCPEnvironment) {
     {}
   );
 
-  const llm = createLLM(env);
+  const llm = getCachedLLM(env);
 
   if (!llm.bindTools) {
     throw new Error('The selected LLM model does not support tool binding');

packages/mcps/argent/src/tools/createAccount.ts

@@ -1,7 +1,7 @@
 import { RpcProvider } from 'starknet';
 import { ARGENT_CLASS_HASH } from '../lib/constant/contract.js';
 import { AccountManager } from '../lib/utils/AccountManager.js';
-import { onchainRead } from '@kasarlabs/ask-starknet-core';
+import { onchainRead, toolResult } from '@kasarlabs/ask-starknet-core';
 
 /**
  * Creates a new Argent account.
@@ -11,55 +11,22 @@ import { onchainRead } from '@kasarlabs/ask-starknet-core';
  * @returns {Promise<object>} Object with account details
  * @throws {Error} If account creation fails
  */
-export const CreateArgentAccount = async (env: onchainRead) => {
+export const CreateArgentAccount = async (
+  env: onchainRead
+): Promise<toolResult> => {
   try {
     const accountManager = new AccountManager(env.provider);
     const accountDetails =
       await accountManager.createAccount(ARGENT_CLASS_HASH);
 
     return {
       status: 'success',
-      wallet: 'AX',
-      publicKey: accountDetails.publicKey,
-      privateKey: accountDetails.privateKey,
-      contractAddress: accountDetails.contractAddress,
-    };
-  } catch (error) {
-    return {
-      status: 'failure',
-      error: error instanceof Error ? error.message : 'Unknown error',
-    };
-  }
-};
-
-/**
- * Creates an Argent account with deployment fee estimation.
- * @async
- * @function CreateArgentAccountSignature
- * @returns {Promise<object>} Object with account and fee details
- * @throws {Error} If creation or fee estimation fails
- */
-export const CreateArgentAccountSignature = async () => {
-  try {
-    const provider = new RpcProvider({ nodeUrl: process.env.STARKNET_RPC_URL });
-
-    const accountManager = new AccountManager(provider);
-    const accountDetails =
-      await accountManager.createAccount(ARGENT_CLASS_HASH);
-    const suggestedMaxFee = await accountManager.estimateAccountDeployFee(
-      ARGENT_CLASS_HASH,
-      accountDetails
-    );
-    const maxFee = suggestedMaxFee.suggestedMaxFee * 2n;
-
-    return {
-      status: 'success',
-      transaction_type: 'CREATE_ACCOUNT',
-      wallet: 'AX',
-      publicKey: accountDetails.publicKey,
-      privateKey: accountDetails.privateKey,
-      contractAddress: accountDetails.contractAddress,
-      deployFee: maxFee.toString(),
+      data: {
+        wallet: 'AX',
+        publicKey: accountDetails.publicKey,
+        privateKey: accountDetails.privateKey,
+        contractAddress: accountDetails.contractAddress,
+      },
     };
   } catch (error) {
     return {

packages/mcps/argent/src/tools/deployAccount.ts

@@ -3,7 +3,7 @@ import { ARGENT_CLASS_HASH } from '../lib/constant/contract.js';
 import { AccountManager } from '../lib/utils/AccountManager.js';
 import { z } from 'zod';
 import { accountDetailsSchema } from '../schemas/schema.js';
-import { onchainRead } from '@kasarlabs/ask-starknet-core';
+import { onchainRead, toolResult } from '@kasarlabs/ask-starknet-core';
 /**
  * Deploys an Argent account using RPC provider.
  * @async
@@ -16,47 +16,18 @@ import { onchainRead } from '@kasarlabs/ask-starknet-core';
 export const DeployArgentAccount = async (
   env: onchainRead,
   params: z.infer<typeof accountDetailsSchema>
-) => {
+): Promise<toolResult> => {
   try {
     const accountManager = new AccountManager(env.provider);
     const tx = await accountManager.deployAccount(ARGENT_CLASS_HASH, params);
 
     return {
       status: 'success',
-      wallet: 'AX',
-      transaction_hash: tx.transactionHash,
-      contract_address: tx.contractAddress,
-    };
-  } catch (error) {
-    return {
-      status: 'failure',
-      error: error instanceof Error ? error.message : 'Unknown error',
-    };
-  }
-};
-
-/**
- * Deploys an Argent account using RPC.
- * @async
- * @function DeployArgentAccountSignature
- * @param {z.infer<typeof accountDetailsSchema>} params - Account details
- * @returns {Promise<string>} JSON string with deployment result
- * @throws {Error} If deployment fails
- */
-export const DeployArgentAccountSignature = async (
-  params: z.infer<typeof accountDetailsSchema>
-) => {
-  try {
-    const provider = new RpcProvider({ nodeUrl: process.env.STARKNET_RPC_URL });
-
-    const accountManager = new AccountManager(provider);
-    const tx = await accountManager.deployAccount(ARGENT_CLASS_HASH, params);
-
-    return {
-      status: 'success',
-      wallet: 'AX',
-      transaction_hash: tx.transactionHash,
-      contract_address: tx.contractAddress,
+      data: {
+        wallet: 'AX',
+        transaction_hash: tx.transactionHash,
+        contract_address: tx.contractAddress,
+      },
     };
   } catch (error) {
     return {

packages/mcps/artpeace/src/tools/placePixel.ts

@@ -4,7 +4,7 @@ import { artpeaceAddr } from '../lib/constants/artpeace.js';
 import { ArtpeaceHelper } from '../lib/utils/helper.js';
 import { placePixelParam } from '../schemas/index.js';
 import { Checker } from '../lib/utils/checker.js';
-import { onchainWrite } from '@kasarlabs/ask-starknet-core';
+import { onchainWrite, toolResult } from '@kasarlabs/ask-starknet-core';
 
 /**
  * Places pixels on a Starknet canvas using the Artpeace contract
@@ -15,7 +15,7 @@ import { onchainWrite } from '@kasarlabs/ask-starknet-core';
 export const placePixel = async (
   env: onchainWrite,
   input: { params: placePixelParam[] }
-) => {
+): Promise<toolResult> => {
   try {
     const { params } = input;
     const account = env.account;
@@ -49,15 +49,12 @@ export const placePixel = async (
 
     return {
       status: 'success',
-      transaction_hash: txHash,
+      data: { transaction_hash: txHash },
     };
   } catch (error: any) {
     return {
-      status: 'error',
-      error: {
-        code: 'PLACE_PIXEL_DATA_ERROR',
-        message: error.message || 'Failed to place a pixel',
-      },
+      status: 'failure',
+      error: error.message || 'Failed to place a pixel',
     };
   }
 };

packages/mcps/avnu/src/tools/fetchRoute.ts

@@ -1,5 +1,9 @@
 import { fetchQuotes, QuoteRequest } from '@avnu/avnu-sdk';
-import { onchainRead, onchainWrite } from '@kasarlabs/ask-starknet-core';
+import {
+  onchainRead,
+  onchainWrite,
+  toolResult,
+} from '@kasarlabs/ask-starknet-core';
 import { TokenService } from './fetchTokens.js';
 import { RouteSchemaType } from '../schemas/index.js';
 import { RouteResult } from '../interfaces/index.js';
@@ -96,17 +100,24 @@ export class RouteFetchService {
  * @param {string} accountAddress - The account address
  * @returns {Promise<RouteResult>} The route fetch result
  */
-export const getRoute = async (env: onchainWrite, params: RouteSchemaType) => {
+export const getRoute = async (
+  env: onchainWrite,
+  params: RouteSchemaType
+): Promise<toolResult> => {
   try {
     const routeService = new RouteFetchService();
     const result = await routeService.fetchRoute(
       params,
       env,
       env.account.address
     );
-    return JSON.stringify(result, (_, value) =>
+    const res = JSON.stringify(result, (_, value) =>
       typeof value === 'bigint' ? value.toString() : value
     );
+    return {
+      status: 'success',
+      data: { res },
+    };
   } catch (error) {
     return {
       status: 'failure',