servers: make tool call result spec compatible

2026-02-19 11:54:58 -05:00 · 2024-12-02 13:12:15 +00:00
parent 87082db0f2
commit 788098220e
5 changed files with 269 additions and 329 deletions
--- a/src/github/index.ts
+++ b/src/github/index.ts
@@ -529,7 +529,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
      case "fork_repository": {
        const args = ForkRepositorySchema.parse(request.params.arguments);
        const fork = await forkRepository(args.owner, args.repo, args.organization);
-        return { toolResult: fork };
+        return { content: [{ type: "text", text: JSON.stringify(fork, null, 2) }] };
      }

      case "create_branch": {
@@ -562,25 +562,25 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
          sha
        });

-        return { toolResult: branch };
+        return { content: [{ type: "text", text: JSON.stringify(branch, null, 2) }] };
      }

      case "search_repositories": {
        const args = SearchRepositoriesSchema.parse(request.params.arguments);
        const results = await searchRepositories(args.query, args.page, args.perPage);
-        return { toolResult: results };
+        return { content: [{ type: "text", text: JSON.stringify(results, null, 2) }] };
      }

      case "create_repository": {
        const args = CreateRepositorySchema.parse(request.params.arguments);
        const repository = await createRepository(args);
-        return { toolResult: repository };
+        return { content: [{ type: "text", text: JSON.stringify(repository, null, 2) }] };
      }

      case "get_file_contents": {
        const args = GetFileContentsSchema.parse(request.params.arguments);
        const contents = await getFileContents(args.owner, args.repo, args.path, args.branch);
-        return { toolResult: contents };
+        return { content: [{ type: "text", text: JSON.stringify(contents, null, 2) }] };
      }

      case "create_or_update_file": {
@@ -594,7 +594,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
          args.branch,
          args.sha
        );
-        return { toolResult: result };
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
      }

      case "push_files": {
@@ -606,21 +606,21 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
          args.files,
          args.message
        );
-        return { toolResult: result };
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
      }

      case "create_issue": {
        const args = CreateIssueSchema.parse(request.params.arguments);
        const { owner, repo, ...options } = args;
        const issue = await createIssue(owner, repo, options);
-        return { toolResult: issue };
+        return { content: [{ type: "text", text: JSON.stringify(issue, null, 2) }] };
      }

      case "create_pull_request": {
        const args = CreatePullRequestSchema.parse(request.params.arguments);
        const { owner, repo, ...options } = args;
        const pullRequest = await createPullRequest(owner, repo, options);
-        return { toolResult: pullRequest };
+        return { content: [{ type: "text", text: JSON.stringify(pullRequest, null, 2) }] };
      }

      default:
--- a/src/gitlab/index.ts
+++ b/src/gitlab/index.ts
@@ -437,7 +437,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
      case "fork_repository": {
        const args = ForkRepositorySchema.parse(request.params.arguments);
        const fork = await forkProject(args.project_id, args.namespace);
-        return { toolResult: fork };
+        return { content: [{ type: "text", text: JSON.stringify(fork, null, 2) }] };
      }

      case "create_branch": {
@@ -452,25 +452,25 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
          ref
        });

-        return { toolResult: branch };
+        return { content: [{ type: "text", text: JSON.stringify(branch, null, 2) }] };
      }

      case "search_repositories": {
        const args = SearchRepositoriesSchema.parse(request.params.arguments);
        const results = await searchProjects(args.search, args.page, args.per_page);
-        return { toolResult: results };
+        return { content: [{ type: "text", text: JSON.stringify(results, null, 2) }] };
      }

      case "create_repository": {
        const args = CreateRepositorySchema.parse(request.params.arguments);
        const repository = await createRepository(args);
-        return { toolResult: repository };
+        return { content: [{ type: "text", text: JSON.stringify(repository, null, 2) }] };
      }

      case "get_file_contents": {
        const args = GetFileContentsSchema.parse(request.params.arguments);
        const contents = await getFileContents(args.project_id, args.file_path, args.ref);
-        return { toolResult: contents };
+        return { content: [{ type: "text", text: JSON.stringify(contents, null, 2) }] };
      }

      case "create_or_update_file": {
@@ -483,7 +483,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
          args.branch,
          args.previous_path
        );
-        return { toolResult: result };
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
      }

      case "push_files": {
@@ -494,21 +494,21 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
          args.branch,
          args.files.map(f => ({ path: f.file_path, content: f.content }))
        );
-        return { toolResult: result };
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
      }

      case "create_issue": {
        const args = CreateIssueSchema.parse(request.params.arguments);
        const { project_id, ...options } = args;
        const issue = await createIssue(project_id, options);
-        return { toolResult: issue };
+        return { content: [{ type: "text", text: JSON.stringify(issue, null, 2) }] };
      }

      case "create_merge_request": {
        const args = CreateMergeRequestSchema.parse(request.params.arguments);
        const { project_id, ...options } = args;
        const mergeRequest = await createMergeRequest(project_id, options);
-        return { toolResult: mergeRequest };
+        return { content: [{ type: "text", text: JSON.stringify(mergeRequest, null, 2) }] };
      }

      default:
--- a/src/google-maps/index.ts
+++ b/src/google-maps/index.ts
@@ -141,7 +141,7 @@ function getApiKey(): string {
    }
    return apiKey;
  }
-  
+
 const GOOGLE_MAPS_API_KEY = getApiKey();

 // Tool definitions
@@ -151,28 +151,28 @@ const GEOCODE_TOOL: Tool = {
    inputSchema: {
      type: "object",
      properties: {
-        address: { 
-          type: "string", 
-          description: "The address to geocode" 
+        address: {
+          type: "string",
+          description: "The address to geocode"
        }
      },
      required: ["address"]
    }
  };
-  
+
 const REVERSE_GEOCODE_TOOL: Tool = {
  name: "maps_reverse_geocode",
  description: "Convert coordinates into an address",
  inputSchema: {
    type: "object",
    properties: {
-      latitude: { 
-        type: "number", 
-        description: "Latitude coordinate" 
+      latitude: {
+        type: "number",
+        description: "Latitude coordinate"
      },
-      longitude: { 
-        type: "number", 
-        description: "Longitude coordinate" 
+      longitude: {
+        type: "number",
+        description: "Longitude coordinate"
      }
    },
    required: ["latitude", "longitude"]
@@ -185,9 +185,9 @@ const SEARCH_PLACES_TOOL: Tool = {
  inputSchema: {
    type: "object",
    properties: {
-      query: { 
-        type: "string", 
-        description: "Search query" 
+      query: {
+        type: "string",
+        description: "Search query"
      },
      location: {
        type: "object",
@@ -225,7 +225,7 @@ const DISTANCE_MATRIX_TOOL: Tool = {
  name: "maps_distance_matrix",
  description: "Calculate travel distance and time for multiple origins and destinations",
  inputSchema: {
-    type: "object", 
+    type: "object",
    properties: {
      origins: {
        type: "array",
@@ -233,7 +233,7 @@ const DISTANCE_MATRIX_TOOL: Tool = {
        description: "Array of origin addresses or coordinates"
      },
      destinations: {
-        type: "array", 
+        type: "array",
        items: { type: "string" },
        description: "Array of destination addresses or coordinates"
      },
@@ -276,13 +276,13 @@ const DIRECTIONS_TOOL: Tool = {
  inputSchema: {
    type: "object",
    properties: {
-      origin: { 
-        type: "string", 
-        description: "Starting point address or coordinates" 
+      origin: {
+        type: "string",
+        description: "Starting point address or coordinates"
      },
-      destination: { 
-        type: "string", 
-        description: "Ending point address or coordinates" 
+      destination: {
+        type: "string",
+        description: "Ending point address or coordinates"
      },
      mode: {
        type: "string",
@@ -315,28 +315,24 @@ async function handleGeocode(address: string) {

  if (data.status !== "OK") {
    return {
-      toolResult: {
-        content: [{
-          type: "text",
-          text: `Geocoding failed: ${data.error_message || data.status}`
-        }],
-        isError: true
-      }
+      content: [{
+        type: "text",
+        text: `Geocoding failed: ${data.error_message || data.status}`
+      }],
+      isError: true
    };
  }

  return {
-    toolResult: {
-      content: [{
-        type: "text",
-        text: JSON.stringify({
-          location: data.results[0].geometry.location,
-          formatted_address: data.results[0].formatted_address,
-          place_id: data.results[0].place_id
-        }, null, 2)
-      }],
-      isError: false
-    }
+    content: [{
+      type: "text",
+      text: JSON.stringify({
+        location: data.results[0].geometry.location,
+        formatted_address: data.results[0].formatted_address,
+        place_id: data.results[0].place_id
+      }, null, 2)
+    }],
+    isError: false
  };
 }

@@ -350,28 +346,24 @@ async function handleReverseGeocode(latitude: number, longitude: number) {

  if (data.status !== "OK") {
    return {
-      toolResult: {
-        content: [{
-          type: "text",
-          text: `Reverse geocoding failed: ${data.error_message || data.status}`
-        }],
-        isError: true
-      }
+      content: [{
+        type: "text",
+        text: `Reverse geocoding failed: ${data.error_message || data.status}`
+      }],
+      isError: true
    };
  }

  return {
-    toolResult: {
-      content: [{
-        type: "text",
-        text: JSON.stringify({
-          formatted_address: data.results[0].formatted_address,
-          place_id: data.results[0].place_id,
-          address_components: data.results[0].address_components
-        }, null, 2)
-      }],
-      isError: false
-    }
+    content: [{
+      type: "text",
+      text: JSON.stringify({
+        formatted_address: data.results[0].formatted_address,
+        place_id: data.results[0].place_id,
+        address_components: data.results[0].address_components
+      }, null, 2)
+    }],
+    isError: false
  };
 }

@@ -396,33 +388,29 @@ async function handlePlaceSearch(

  if (data.status !== "OK") {
    return {
-      toolResult: {
-        content: [{
-          type: "text",
-          text: `Place search failed: ${data.error_message || data.status}`
-        }],
-        isError: true
-      }
+      content: [{
+        type: "text",
+        text: `Place search failed: ${data.error_message || data.status}`
+      }],
+      isError: true
    };
  }

  return {
-    toolResult: {
-      content: [{
-        type: "text",
-        text: JSON.stringify({
-          places: data.results.map((place) => ({
-            name: place.name,
-            formatted_address: place.formatted_address,
-            location: place.geometry.location,
-            place_id: place.place_id,
-            rating: place.rating,
-            types: place.types
-          }))
-        }, null, 2)
-      }],
-      isError: false
-    }
+    content: [{
+      type: "text",
+      text: JSON.stringify({
+        places: data.results.map((place) => ({
+          name: place.name,
+          formatted_address: place.formatted_address,
+          location: place.geometry.location,
+          place_id: place.place_id,
+          rating: place.rating,
+          types: place.types
+        }))
+      }, null, 2)
+    }],
+    isError: false
  };
 }

@@ -436,33 +424,29 @@ async function handlePlaceDetails(place_id: string) {

  if (data.status !== "OK") {
    return {
-      toolResult: {
-        content: [{
-          type: "text",
-          text: `Place details request failed: ${data.error_message || data.status}`
-        }],
-        isError: true
-      }
+      content: [{
+        type: "text",
+        text: `Place details request failed: ${data.error_message || data.status}`
+      }],
+      isError: true
    };
  }

  return {
-    toolResult: {
-      content: [{
-        type: "text",
-        text: JSON.stringify({
-          name: data.result.name,
-          formatted_address: data.result.formatted_address,
-          location: data.result.geometry.location,
-          formatted_phone_number: data.result.formatted_phone_number,
-          website: data.result.website,
-          rating: data.result.rating,
-          reviews: data.result.reviews,
-          opening_hours: data.result.opening_hours
-        }, null, 2)
-      }],
-      isError: false
-    }
+    content: [{
+      type: "text",
+      text: JSON.stringify({
+        name: data.result.name,
+        formatted_address: data.result.formatted_address,
+        location: data.result.geometry.location,
+        formatted_phone_number: data.result.formatted_phone_number,
+        website: data.result.website,
+        rating: data.result.rating,
+        reviews: data.result.reviews,
+        opening_hours: data.result.opening_hours
+      }, null, 2)
+    }],
+    isError: false
  };
 }
 async function handleDistanceMatrix(
@@ -481,34 +465,30 @@ async function handleDistanceMatrix(

  if (data.status !== "OK") {
    return {
-      toolResult: {
-        content: [{
-          type: "text",
-          text: `Distance matrix request failed: ${data.error_message || data.status}`
-        }],
-        isError: true
-      }
+      content: [{
+        type: "text",
+        text: `Distance matrix request failed: ${data.error_message || data.status}`
+      }],
+      isError: true
    };
  }

  return {
-    toolResult: {
-      content: [{
-        type: "text",
-        text: JSON.stringify({
-          origin_addresses: data.origin_addresses,
-          destination_addresses: data.destination_addresses,
-          results: data.rows.map((row) => ({
-            elements: row.elements.map((element) => ({
-              status: element.status,
-              duration: element.duration,
-              distance: element.distance
-            }))
+    content: [{
+      type: "text",
+      text: JSON.stringify({
+        origin_addresses: data.origin_addresses,
+        destination_addresses: data.destination_addresses,
+        results: data.rows.map((row) => ({
+          elements: row.elements.map((element) => ({
+            status: element.status,
+            duration: element.duration,
+            distance: element.distance
          }))
-        }, null, 2)
-      }],
-      isError: false
-    }
+        }))
+      }, null, 2)
+    }],
+    isError: false
  };
 }

@@ -525,30 +505,26 @@ async function handleElevation(locations: Array<{ latitude: number; longitude: n

  if (data.status !== "OK") {
    return {
-      toolResult: {
-        content: [{
-          type: "text",
-          text: `Elevation request failed: ${data.error_message || data.status}`
-        }],
-        isError: true
-      }
+      content: [{
+        type: "text",
+        text: `Elevation request failed: ${data.error_message || data.status}`
+      }],
+      isError: true
    };
  }

  return {
-    toolResult: {
-      content: [{
-        type: "text",
-        text: JSON.stringify({
-          results: data.results.map((result) => ({
-            elevation: result.elevation,
-            location: result.location,
-            resolution: result.resolution
-          }))
-        }, null, 2)
-      }],
-      isError: false
-    }
+    content: [{
+      type: "text",
+      text: JSON.stringify({
+        results: data.results.map((result) => ({
+          elevation: result.elevation,
+          location: result.location,
+          resolution: result.resolution
+        }))
+      }, null, 2)
+    }],
+    isError: false
  };
 }

@@ -568,36 +544,32 @@ async function handleDirections(

  if (data.status !== "OK") {
    return {
-      toolResult: {
-        content: [{
-          type: "text",
-          text: `Directions request failed: ${data.error_message || data.status}`
-        }],
-        isError: true
-      }
+      content: [{
+        type: "text",
+        text: `Directions request failed: ${data.error_message || data.status}`
+      }],
+      isError: true
    };
  }

  return {
-    toolResult: {
-      content: [{
-        type: "text",
-        text: JSON.stringify({
-          routes: data.routes.map((route) => ({
-            summary: route.summary,
-            distance: route.legs[0].distance,
-            duration: route.legs[0].duration,
-            steps: route.legs[0].steps.map((step) => ({
-              instructions: step.html_instructions,
-              distance: step.distance,
-              duration: step.duration,
-              travel_mode: step.travel_mode
-            }))
+    content: [{
+      type: "text",
+      text: JSON.stringify({
+        routes: data.routes.map((route) => ({
+          summary: route.summary,
+          distance: route.legs[0].distance,
+          duration: route.legs[0].duration,
+          steps: route.legs[0].steps.map((step) => ({
+            instructions: step.html_instructions,
+            distance: step.distance,
+            duration: step.duration,
+            travel_mode: step.travel_mode
          }))
-        }, null, 2)
-      }],
-      isError: false
-    }
+        }))
+      }, null, 2)
+    }],
+    isError: false
  };
 }

@@ -626,7 +598,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
        const { address } = request.params.arguments as { address: string };
        return await handleGeocode(address);
      }
-      
+
      case "maps_reverse_geocode": {
        const { latitude, longitude } = request.params.arguments as {
          latitude: number;
@@ -634,7 +606,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
        };
        return await handleReverseGeocode(latitude, longitude);
      }
-      
+
      case "maps_search_places": {
        const { query, location, radius } = request.params.arguments as {
          query: string;
@@ -643,12 +615,12 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
        };
        return await handlePlaceSearch(query, location, radius);
      }
-      
+
      case "maps_place_details": {
        const { place_id } = request.params.arguments as { place_id: string };
        return await handlePlaceDetails(place_id);
      }
-      
+
      case "maps_distance_matrix": {
        const { origins, destinations, mode } = request.params.arguments as {
          origins: string[];
@@ -657,14 +629,14 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
        };
        return await handleDistanceMatrix(origins, destinations, mode);
      }
-      
+
      case "maps_elevation": {
        const { locations } = request.params.arguments as {
          locations: Array<{ latitude: number; longitude: number }>;
        };
        return await handleElevation(locations);
      }
-      
+
      case "maps_directions": {
        const { origin, destination, mode } = request.params.arguments as {
          origin: string;
@@ -673,27 +645,23 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
        };
        return await handleDirections(origin, destination, mode);
      }
-      
+
      default:
        return {
-          toolResult: {
-            content: [{
-              type: "text",
-              text: `Unknown tool: ${request.params.name}`
-            }],
-            isError: true
-          }
+          content: [{
+            type: "text",
+            text: `Unknown tool: ${request.params.name}`
+          }],
+          isError: true
        };
    }
  } catch (error) {
    return {
-      toolResult: {
-        content: [{
-          type: "text",
-          text: `Error: ${error instanceof Error ? error.message : String(error)}`
-        }],
-        isError: true
-      }
+      content: [{
+        type: "text",
+        text: `Error: ${error instanceof Error ? error.message : String(error)}`
+      }],
+      isError: true
    };
  }
 });
@@ -707,4 +675,4 @@ async function runServer() {
 runServer().catch((error) => {
  console.error("Fatal error running server:", error);
  process.exit(1);
-});
+});
--- a/src/memory/index.ts
+++ b/src/memory/index.ts
@@ -377,26 +377,26 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {

  switch (name) {
    case "create_entities":
-      return { toolResult: await knowledgeGraphManager.createEntities(args.entities as Entity[]) };
+      return { content: [{ type: "text", text: JSON.stringify(await knowledgeGraphManager.createEntities(args.entities as Entity[]), null, 2) }] };
    case "create_relations":
-      return { toolResult: await knowledgeGraphManager.createRelations(args.relations as Relation[]) };
+      return { content: [{ type: "text", text: JSON.stringify(await knowledgeGraphManager.createRelations(args.relations as Relation[]), null, 2) }] };
    case "add_observations":
-      return { toolResult: await knowledgeGraphManager.addObservations(args.observations as { entityName: string; contents: string[] }[]) };
+      return { content: [{ type: "text", text: JSON.stringify(await knowledgeGraphManager.addObservations(args.observations as { entityName: string; contents: string[] }[]), null, 2) }] };
    case "delete_entities":
      await knowledgeGraphManager.deleteEntities(args.entityNames as string[]);
-      return { toolResult: "Entities deleted successfully" };
+      return { content: [{ type: "text", text: "Entities deleted successfully" }] };
    case "delete_observations":
      await knowledgeGraphManager.deleteObservations(args.deletions as { entityName: string; observations: string[] }[]);
-      return { toolResult: "Observations deleted successfully" };
+      return { content: [{ type: "text", text: "Observations deleted successfully" }] };
    case "delete_relations":
      await knowledgeGraphManager.deleteRelations(args.relations as Relation[]);
-      return { toolResult: "Relations deleted successfully" };
+      return { content: [{ type: "text", text: "Relations deleted successfully" }] };
    case "read_graph":
-      return { toolResult: await knowledgeGraphManager.readGraph() };
+      return { content: [{ type: "text", text: JSON.stringify(await knowledgeGraphManager.readGraph(), null, 2) }] };
    case "search_nodes":
-      return { toolResult: await knowledgeGraphManager.searchNodes(args.query as string) };
+      return { content: [{ type: "text", text: JSON.stringify(await knowledgeGraphManager.searchNodes(args.query as string), null, 2) }] };
    case "open_nodes":
-      return { toolResult: await knowledgeGraphManager.openNodes(args.names as string[]) };
+      return { content: [{ type: "text", text: JSON.stringify(await knowledgeGraphManager.openNodes(args.names as string[]), null, 2) }] };
    default:
      throw new Error(`Unknown tool: ${name}`);
  }
--- a/src/puppeteer/index.ts
+++ b/src/puppeteer/index.ts
@@ -124,20 +124,18 @@ async function ensureBrowser() {
  return page!;
 }

-async function handleToolCall(name: string, args: any): Promise<{ toolResult: CallToolResult }> {
+async function handleToolCall(name: string, args: any): Promise<CallToolResult> {
  const page = await ensureBrowser();

  switch (name) {
    case "puppeteer_navigate":
      await page.goto(args.url);
      return {
-        toolResult: {
-          content: [{
-            type: "text",
-            text: `Navigated to ${args.url}`,
-          }],
-          isError: false,
-        },
+        content: [{
+          type: "text",
+          text: `Navigated to ${args.url}`,
+        }],
+        isError: false,
      };

    case "puppeteer_screenshot": {
@@ -151,13 +149,11 @@ async function handleToolCall(name: string, args: any): Promise<{ toolResult: Ca

      if (!screenshot) {
        return {
-          toolResult: {
-            content: [{
-              type: "text",
-              text: args.selector ? `Element not found: ${args.selector}` : "Screenshot failed",
-            }],
-            isError: true,
-          },
+          content: [{
+            type: "text",
+            text: args.selector ? `Element not found: ${args.selector}` : "Screenshot failed",
+          }],
+          isError: true,
        };
      }

@@ -167,20 +163,18 @@ async function handleToolCall(name: string, args: any): Promise<{ toolResult: Ca
      });

      return {
-        toolResult: {
-          content: [
-            {
-              type: "text",
-              text: `Screenshot '${args.name}' taken at ${width}x${height}`,
-            } as TextContent,
-            {
-              type: "image",
-              data: screenshot,
-              mimeType: "image/png",
-            } as ImageContent,
-          ],
-          isError: false,
-        },
+        content: [
+          {
+            type: "text",
+            text: `Screenshot '${args.name}' taken at ${width}x${height}`,
+          } as TextContent,
+          {
+            type: "image",
+            data: screenshot,
+            mimeType: "image/png",
+          } as ImageContent,
+        ],
+        isError: false,
      };
    }

@@ -188,23 +182,19 @@ async function handleToolCall(name: string, args: any): Promise<{ toolResult: Ca
      try {
        await page.click(args.selector);
        return {
-          toolResult: {
-            content: [{
-              type: "text",
-              text: `Clicked: ${args.selector}`,
-            }],
-            isError: false,
-          },
+          content: [{
+            type: "text",
+            text: `Clicked: ${args.selector}`,
+          }],
+          isError: false,
        };
      } catch (error) {
        return {
-          toolResult: {
-            content: [{
-              type: "text",
-              text: `Failed to click ${args.selector}: ${(error as Error).message}`,
-            }],
-            isError: true,
-          },
+          content: [{
+            type: "text",
+            text: `Failed to click ${args.selector}: ${(error as Error).message}`,
+          }],
+          isError: true,
        };
      }

@@ -213,23 +203,19 @@ async function handleToolCall(name: string, args: any): Promise<{ toolResult: Ca
        await page.waitForSelector(args.selector);
        await page.type(args.selector, args.value);
        return {
-          toolResult: {
-            content: [{
-              type: "text",
-              text: `Filled ${args.selector} with: ${args.value}`,
-            }],
-            isError: false,
-          },
+          content: [{
+            type: "text",
+            text: `Filled ${args.selector} with: ${args.value}`,
+          }],
+          isError: false,
        };
      } catch (error) {
        return {
-          toolResult: {
-            content: [{
-              type: "text",
-              text: `Failed to fill ${args.selector}: ${(error as Error).message}`,
-            }],
-            isError: true,
-          },
+          content: [{
+            type: "text",
+            text: `Failed to fill ${args.selector}: ${(error as Error).message}`,
+          }],
+          isError: true,
        };
      }

@@ -238,23 +224,19 @@ async function handleToolCall(name: string, args: any): Promise<{ toolResult: Ca
        await page.waitForSelector(args.selector);
        await page.select(args.selector, args.value);
        return {
-          toolResult: {
-            content: [{
-              type: "text",
-              text: `Selected ${args.selector} with: ${args.value}`,
-            }],
-            isError: false,
-          },
+          content: [{
+            type: "text",
+            text: `Selected ${args.selector} with: ${args.value}`,
+          }],
+          isError: false,
        };
      } catch (error) {
        return {
-          toolResult: {
-            content: [{
-              type: "text",
-              text: `Failed to select ${args.selector}: ${(error as Error).message}`,
-            }],
-            isError: true,
-          },
+          content: [{
+            type: "text",
+            text: `Failed to select ${args.selector}: ${(error as Error).message}`,
+          }],
+          isError: true,
        };
      }

@@ -263,23 +245,19 @@ async function handleToolCall(name: string, args: any): Promise<{ toolResult: Ca
        await page.waitForSelector(args.selector);
        await page.hover(args.selector);
        return {
-          toolResult: {
-            content: [{
-              type: "text",
-              text: `Hovered ${args.selector}`,
-            }],
-            isError: false,
-          },
+          content: [{
+            type: "text",
+            text: `Hovered ${args.selector}`,
+          }],
+          isError: false,
        };
      } catch (error) {
        return {
-          toolResult: {
-            content: [{
-              type: "text",
-              text: `Failed to hover ${args.selector}: ${(error as Error).message}`,
-            }],
-            isError: true,
-          },
+          content: [{
+            type: "text",
+            text: `Failed to hover ${args.selector}: ${(error as Error).message}`,
+          }],
+          isError: true,
        };
      }

@@ -307,37 +285,31 @@ async function handleToolCall(name: string, args: any): Promise<{ toolResult: Ca
        }, args.script);

        return {
-          toolResult: {
-            content: [
-              {
-                type: "text",
-                text: `Execution result:\n${JSON.stringify(result.result, null, 2)}\n\nConsole output:\n${result.logs.join('\n')}`,
-              },
-            ],
-            isError: false,
-          },
+          content: [
+            {
+              type: "text",
+              text: `Execution result:\n${JSON.stringify(result.result, null, 2)}\n\nConsole output:\n${result.logs.join('\n')}`,
+            },
+          ],
+          isError: false,
        };
      } catch (error) {
        return {
-          toolResult: {
-            content: [{
-              type: "text",
-              text: `Script execution failed: ${(error as Error).message}`,
-            }],
-            isError: true,
-          },
+          content: [{
+            type: "text",
+            text: `Script execution failed: ${(error as Error).message}`,
+          }],
+          isError: true,
        };
      }

    default:
      return {
-        toolResult: {
-          content: [{
-            type: "text",
-            text: `Unknown tool: ${name}`,
-          }],
-          isError: true,
-        },
+        content: [{
+          type: "text",
+          text: `Unknown tool: ${name}`,
+        }],
+        isError: true,
      };
  }
 }