@salesforce/graphiti 10.20.1 → 10.21.0

package/src/lib/walker.ts

@@ -28,6 +28,7 @@ import {
 	type GraphQLOutputType,
 	type GraphQLType,
 } from "graphql";
+import { SchemaError, UserInputError } from "./errors.js";
 import { atomicWriteText } from "./fs-utils.js";
 import { loadIntrospectionResult, getSchemaFilePath, normalizeInstanceUrl } from "./introspect.js";
 import { type OperationType } from "./session.js";
@@ -291,13 +292,14 @@ function validateFragmentTarget(
 ): GraphQLNamedType {
 	const namedType = schema.getType(targetTypeName);
 	if (!namedType) {
-		throw new Error(`Type "${targetTypeName}" not found in schema`);
+		// User named an inline-fragment target type that does not exist.
+		throw new UserInputError(`Type "${targetTypeName}" not found in schema`);
 	}
 
 	if (isUnionType(currentType)) {
 		const allowed = currentType.getTypes().map((type) => type.name);
 		if (!allowed.includes(targetTypeName)) {
-			throw new Error(
+			throw new UserInputError(
 				`Type "${targetTypeName}" is not a possible type of union ${currentType.name}. Allowed: ${allowed.join(", ")}`,
 			);
 		}
@@ -307,7 +309,7 @@ function validateFragmentTarget(
 	if (isInterfaceType(currentType)) {
 		const allowed = schema.getPossibleTypes(currentType).map((type) => type.name);
 		if (!allowed.includes(targetTypeName)) {
-			throw new Error(
+			throw new UserInputError(
 				`Type "${targetTypeName}" does not implement interface ${currentType.name}. Allowed: ${allowed.join(", ")}`,
 			);
 		}
@@ -338,12 +340,12 @@ function validateFragmentTarget(
 			if (hints.length > 0) {
 				msg += `\nDid you mean to use it through a relationship? Try: ${hints.join(" or ")}`;
 			}
-			throw new Error(msg);
+			throw new UserInputError(msg);
 		}
 		return namedType;
 	}
 
-	throw new Error(
+	throw new UserInputError(
 		`Cannot apply an inline fragment at ${currentType.name} (${getTypeKind(currentType)}).`,
 	);
 }
@@ -472,7 +474,7 @@ export function getRootType(schema: GraphQLSchema, operation: OperationType): Gr
 	const rootType = operation === "mutation" ? schema.getMutationType() : schema.getQueryType();
 
 	if (!rootType) {
-		throw new Error(`Schema has no ${operation} type`);
+		throw new SchemaError(`Schema has no ${operation} type`);
 	}
 	return rootType;
 }

package/src/mcp/tools/__tests__/error-surface.contract.spec.ts

@@ -0,0 +1,261 @@
+/**
+ * Copyright (c) 2026, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { buildSchema } from "graphql";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { makeNoopPrimeDeps } from "../../../__tests__/helpers/prime-deps.js";
+import { AuthError } from "../../../lib/errors.js";
+import { type PrimeDeps } from "../../../lib/prime-schema.js";
+import { primeSchemaCache } from "../../../lib/walker.js";
+import { registerSfGqlAggregateTool } from "../sf-gql-aggregate.js";
+import { registerSfGqlConnectTool } from "../sf-gql-connect.js";
+import { registerSfGqlCreateTool } from "../sf-gql-create.js";
+import { registerSfGqlDeleteTool } from "../sf-gql-delete.js";
+import { registerSfGqlDetailTool } from "../sf-gql-detail.js";
+import { registerSfGqlDiscoverTool } from "../sf-gql-discover.js";
+import { registerSfGqlListTool } from "../sf-gql-list.js";
+import { registerSfGqlRawTool } from "../sf-gql-raw.js";
+import { registerSfGqlUpdateTool } from "../sf-gql-update.js";
+
+/**
+ * W-22697673 — contract tests for the shared tool adapter. These drive each
+ * error category end-to-end through a registered MCP tool (sf_gql_list) so we
+ * assert the category prefix is what an MCP host actually receives, not just
+ * what `classifyError` returns in isolation.
+ */
+
+const ORG = "test-err-surface";
+const ORG_URL = "https://test-err-surface.my.salesforce.com";
+const SCHEMA = buildSchema(`
+	type Query { uiapi: UIAPI! }
+	type UIAPI { query: RecordQuery! }
+	type RecordQuery { Account(first: Int, after: String): AccountConnection! }
+	type AccountConnection { edges: [AccountEdge!]!, pageInfo: PageInfo! }
+	type AccountEdge { node: Account! }
+	type PageInfo { hasNextPage: Boolean!, endCursor: String }
+	type Account { Id: ID!, Name: StringValue }
+	type StringValue { value: String }
+`);
+
+async function connectWith(primeDeps: PrimeDeps): Promise<{ client: Client; server: McpServer }> {
+	const server = new McpServer({ name: "graphiti-mcp", version: "test" });
+	registerSfGqlListTool(server, { primeDeps });
+	const [c, s] = InMemoryTransport.createLinkedPair();
+	const client = new Client({ name: "test", version: "0.0.0" });
+	await Promise.all([server.connect(s), client.connect(c)]);
+	return { client, server };
+}
+
+function errorText(result: Awaited<ReturnType<Client["callTool"]>>): string {
+	const content = result.content as { type: string; text?: string }[];
+	return content[0]?.text ?? "";
+}
+
+describe("mcp/tools error surface — category prefixes (contract)", () => {
+	let tmpRoot: string;
+
+	beforeEach(() => {
+		tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), "graphiti-err-surface-"));
+		process.env.GRAPHITI_HOME = tmpRoot;
+		primeSchemaCache(ORG, SCHEMA);
+		primeSchemaCache(ORG_URL, SCHEMA);
+	});
+
+	afterEach(() => {
+		delete process.env.GRAPHITI_HOME;
+		fs.rmSync(tmpRoot, { recursive: true, force: true });
+		vi.restoreAllMocks();
+	});
+
+	it("UserInput: a malformed sf_gql_raw command surfaces with the UserInput prefix", async () => {
+		// `commands` are free-form strings (no GraphQL-Name zod gate), so a bad verb
+		// passes input validation and reaches apply-command — through runTool — which
+		// throws "unknown command". This is a UserInput error the SDK does not pre-empt.
+		const server = new McpServer({ name: "graphiti-mcp", version: "test" });
+		registerSfGqlRawTool(server, { primeDeps: makeNoopPrimeDeps(ORG, ORG_URL, SCHEMA) });
+		const [c, s] = InMemoryTransport.createLinkedPair();
+		const client = new Client({ name: "test", version: "0.0.0" });
+		await Promise.all([server.connect(s), client.connect(c)]);
+		try {
+			const result = await client.callTool({
+				name: "sf_gql_raw",
+				arguments: { org: ORG, commands: ["bogusverb uiapi/query/Account"] },
+			});
+			expect(result.isError).toBe(true);
+			expect(errorText(result)).toMatch(/^UserInput: /);
+			expect(errorText(result)).toMatch(/unknown command/);
+		} finally {
+			await client.close();
+			await server.close();
+		}
+	});
+
+	it("Auth: a credential failure surfaces with the Auth prefix", async () => {
+		const primeDeps: PrimeDeps = {
+			...makeNoopPrimeDeps(ORG, ORG_URL, SCHEMA),
+			getOrgAuth: async () => {
+				throw new AuthError('Failed to get org info for "test-err-surface"');
+			},
+		};
+		const { client, server } = await connectWith(primeDeps);
+		try {
+			const result = await client.callTool({
+				name: "sf_gql_list",
+				arguments: { org: ORG, object: "Account", fields: ["Id"] },
+			});
+			expect(result.isError).toBe(true);
+			expect(errorText(result)).toMatch(/^Auth: /);
+		} finally {
+			await client.close();
+			await server.close();
+		}
+	});
+
+	it("Schema: an introspection/priming failure surfaces with the Schema prefix", async () => {
+		// No prior disk cache (fresh GRAPHITI_HOME) + a download that throws an
+		// untyped error → primeSchemaWithLock wraps it as SchemaError.
+		const primeDeps: PrimeDeps = {
+			...makeNoopPrimeDeps(ORG, ORG_URL, SCHEMA),
+			downloadSchema: async () => {
+				throw new Error("connection.request failed: socket hang up");
+			},
+		};
+		const { client, server } = await connectWith(primeDeps);
+		try {
+			const result = await client.callTool({
+				name: "sf_gql_list",
+				arguments: { org: ORG, object: "Account", fields: ["Id"] },
+			});
+			expect(result.isError).toBe(true);
+			expect(errorText(result)).toMatch(/^Schema: /);
+		} finally {
+			await client.close();
+			await server.close();
+		}
+	});
+
+	it("Internal: an unexpected error is sanitized, prefixed, and logged to stderr", async () => {
+		const stderr = vi.spyOn(console, "error").mockImplementation(() => undefined);
+		const home = os.homedir();
+		const primeDeps: PrimeDeps = {
+			...makeNoopPrimeDeps(ORG, ORG_URL, SCHEMA),
+			// A throw from getOrgAuth (outside the lock) propagates verbatim, so an
+			// unrecognized message lands in the Internal bucket rather than Schema.
+			getOrgAuth: async () => {
+				throw new Error(`unexpected boom at ${home}/private/creds.ts`);
+			},
+		};
+		const { client, server } = await connectWith(primeDeps);
+		try {
+			const result = await client.callTool({
+				name: "sf_gql_list",
+				arguments: { org: ORG, object: "Account", fields: ["Id"] },
+			});
+			expect(result.isError).toBe(true);
+			const text = errorText(result);
+			expect(text).toMatch(/^Internal: /);
+			// The host never sees the developer's home directory.
+			expect(text).not.toContain(home);
+			// The full error is still logged off the stdio channel for operators.
+			expect(stderr).toHaveBeenCalled();
+		} finally {
+			await client.close();
+			await server.close();
+		}
+	});
+});
+
+/**
+ * M7 — every tool, not just sf_gql_list, must route through `runTool`. The
+ * `runTool(() => buildX(...))` one-liner is hand-repeated in 9 files; a
+ * copy-paste miss (omitting runTool) would still yield `isError` from the SDK
+ * but WITHOUT the `<Category>: ` prefix — and the pre-existing per-tool specs,
+ * which assert only `isError`/substrings, would not catch it. This table injects
+ * a throwing `getOrgAuth` (the first call in priming, reached by every tool) and
+ * asserts the host envelope carries the `Auth: ` prefix from all 9 tools.
+ */
+describe("mcp/tools error surface — all 9 tools route through runTool (M7)", () => {
+	let tmpRoot: string;
+
+	beforeEach(() => {
+		tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), "graphiti-err-surface-all-"));
+		process.env.GRAPHITI_HOME = tmpRoot;
+	});
+
+	afterEach(() => {
+		delete process.env.GRAPHITI_HOME;
+		fs.rmSync(tmpRoot, { recursive: true, force: true });
+	});
+
+	const authFailingDeps = (): PrimeDeps => ({
+		...makeNoopPrimeDeps(ORG, ORG_URL, SCHEMA),
+		getOrgAuth: async () => {
+			throw new AuthError('Failed to get org info for "test-err-surface"');
+		},
+	});
+
+	const TOOLS: {
+		name: string;
+		register: (server: McpServer, opts: { primeDeps?: PrimeDeps }) => void;
+		args: Record<string, unknown>;
+	}[] = [
+		{
+			name: "sf_gql_list",
+			register: registerSfGqlListTool,
+			args: { object: "Account", fields: ["Id"] },
+		},
+		{
+			name: "sf_gql_detail",
+			register: registerSfGqlDetailTool,
+			args: { object: "Account", fields: ["Id"] },
+		},
+		{ name: "sf_gql_aggregate", register: registerSfGqlAggregateTool, args: { object: "Account" } },
+		{ name: "sf_gql_create", register: registerSfGqlCreateTool, args: { object: "Account" } },
+		{ name: "sf_gql_update", register: registerSfGqlUpdateTool, args: { object: "Account" } },
+		{ name: "sf_gql_delete", register: registerSfGqlDeleteTool, args: { object: "Account" } },
+		{
+			name: "sf_gql_raw",
+			register: registerSfGqlRawTool,
+			args: { commands: ["select uiapi/query/Account/edges/node/Id"] },
+		},
+		{
+			name: "sf_gql_discover",
+			register: registerSfGqlDiscoverTool,
+			args: { mode: "list_objects" },
+		},
+		{ name: "sf_gql_connect", register: registerSfGqlConnectTool, args: {} },
+	];
+
+	for (const tool of TOOLS) {
+		it(`${tool.name} surfaces a category-prefixed envelope (not a raw SDK error)`, async () => {
+			const server = new McpServer({ name: "graphiti-mcp", version: "test" });
+			tool.register(server, { primeDeps: authFailingDeps() });
+			const [c, s] = InMemoryTransport.createLinkedPair();
+			const client = new Client({ name: "test", version: "0.0.0" });
+			await Promise.all([server.connect(s), client.connect(c)]);
+			try {
+				const result = await client.callTool({
+					name: tool.name,
+					arguments: { org: ORG, ...tool.args },
+				});
+				expect(result.isError).toBe(true);
+				// The prefix is proof the handler went through runTool: the SDK's own
+				// thrown-handler path would emit the bare message with no category.
+				expect(errorText(result)).toMatch(/^(UserInput|Auth|Schema|Internal): /);
+				expect(errorText(result)).toMatch(/^Auth: /);
+			} finally {
+				await client.close();
+				await server.close();
+			}
+		});
+	}
+});

package/src/mcp/tools/sf-gql-aggregate.ts

@@ -8,6 +8,7 @@ import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { buildAggregate } from "../../intent/build-aggregate.js";
 import { type PrimeDeps } from "../../lib/prime-schema.js";
 import { AGGREGATE_INPUT } from "../../schemas/input-schemas.js";
+import { runTool } from "../../schemas/tool-adapter.js";
 
 export interface SfGqlAggregateToolOptions {
 	primeDeps?: PrimeDeps;
@@ -26,11 +27,6 @@ export function registerSfGqlAggregateTool(
 				"Build a UIAPI aggregate query against a Salesforce org. Supports count/countDistinct/sum/avg/min/max with optional groupBy and filter. Returns rendered GraphQL, declared variables, generated TypeScript types, and validation warnings.",
 			inputSchema,
 		},
-		async (args) => {
-			const output = await buildAggregate(args, opts.primeDeps);
-			return {
-				content: [{ type: "text", text: JSON.stringify(output) }],
-			};
-		},
+		async (args) => runTool(() => buildAggregate(args, opts.primeDeps)),
 	);
 }

package/src/mcp/tools/sf-gql-connect.ts

@@ -7,6 +7,7 @@
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { buildConnect, type ConnectDeps } from "../../intent/build-connect.js";
 import { CONNECT_INPUT } from "../../schemas/input-schemas.js";
+import { runTool } from "../../schemas/tool-adapter.js";
 
 export type SfGqlConnectToolOptions = ConnectDeps;
 
@@ -20,14 +21,9 @@ export function registerSfGqlConnectTool(
 		"sf_gql_connect",
 		{
 			description:
-				"Connect to a Salesforce org and prime its GraphQL schema cache. With forceRefresh, re-download the schema and coherently clear all caches so subsequent tools see freshly-deployed metadata. Concurrent refreshes coalesce into a single introspection. Returns { org, instanceUrl, refreshed, cached, durationMs, warnings? } — not the standard ToolOutput envelope. If a refresh fails but a usable cached schema survives, returns refreshed:false with a staleness warning instead of erroring.",
+				"Connect to a Salesforce org and prime its GraphQL schema cache. With forceRefresh, re-download the schema and coherently clear all caches so subsequent tools see freshly-deployed metadata. Concurrent refreshes coalesce into a single introspection. Returns { org, instanceUrl, refreshed, cached, durationMs, warnings? } — not the standard ToolOutput envelope. If a refresh fails but a usable cached schema survives, returns refreshed:false with a staleness warning instead of erroring. Error convention (all sf_gql_* tools): on failure the isError text is prefixed with a category — `UserInput:` (fix the request), `Auth:` (re-authenticate the org), `Schema:` (introspection/cache problem), or `Internal:` (unexpected) — so you can decide whether to fix inputs, re-auth, or retry.",
 			inputSchema,
 		},
-		async (args) => {
-			const output = await buildConnect(args, opts);
-			return {
-				content: [{ type: "text", text: JSON.stringify(output) }],
-			};
-		},
+		async (args) => runTool(() => buildConnect(args, opts)),
 	);
 }

package/src/mcp/tools/sf-gql-create.ts

@@ -8,6 +8,7 @@ import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { buildCreate } from "../../intent/build-create.js";
 import { type PrimeDeps } from "../../lib/prime-schema.js";
 import { CREATE_INPUT } from "../../schemas/input-schemas.js";
+import { runTool } from "../../schemas/tool-adapter.js";
 
 export interface SfGqlCreateToolOptions {
 	primeDeps?: PrimeDeps;
@@ -26,11 +27,6 @@ export function registerSfGqlCreateTool(
 				"Build a UIAPI create mutation against a Salesforce org. Declares a typed input variable ($input: <Object>CreateInput!) and selects return fields on the created record. Returns rendered GraphQL, declared variables, generated TypeScript types, and validation warnings.",
 			inputSchema,
 		},
-		async (args) => {
-			const output = await buildCreate(args, opts.primeDeps);
-			return {
-				content: [{ type: "text", text: JSON.stringify(output) }],
-			};
-		},
+		async (args) => runTool(() => buildCreate(args, opts.primeDeps)),
 	);
 }

package/src/mcp/tools/sf-gql-delete.ts

@@ -8,6 +8,7 @@ import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { buildDelete } from "../../intent/build-delete.js";
 import { type PrimeDeps } from "../../lib/prime-schema.js";
 import { DELETE_INPUT } from "../../schemas/input-schemas.js";
+import { runTool } from "../../schemas/tool-adapter.js";
 
 export interface SfGqlDeleteToolOptions {
 	primeDeps?: PrimeDeps;
@@ -26,11 +27,6 @@ export function registerSfGqlDeleteTool(
 				"Build a UIAPI delete mutation against a Salesforce org. Declares a typed input variable ($input: RecordDeleteInput!) and selects Id on the deleted record. The input type is schema-wide (not <Object>-specific) and the result is Id only. Returns rendered GraphQL, declared variables, generated TypeScript types, and validation warnings.",
 			inputSchema,
 		},
-		async (args) => {
-			const output = await buildDelete(args, opts.primeDeps);
-			return {
-				content: [{ type: "text", text: JSON.stringify(output) }],
-			};
-		},
+		async (args) => runTool(() => buildDelete(args, opts.primeDeps)),
 	);
 }

package/src/mcp/tools/sf-gql-detail.ts

@@ -8,6 +8,7 @@ import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { buildDetail } from "../../intent/build-detail.js";
 import { type PrimeDeps } from "../../lib/prime-schema.js";
 import { DETAIL_INPUT } from "../../schemas/input-schemas.js";
+import { runTool } from "../../schemas/tool-adapter.js";
 
 export interface SfGqlDetailToolOptions {
 	primeDeps?: PrimeDeps;
@@ -35,11 +36,6 @@ export function registerSfGqlDetailTool(
 			].join("\n"),
 			inputSchema,
 		},
-		async (args) => {
-			const output = await buildDetail(args, opts.primeDeps);
-			return {
-				content: [{ type: "text", text: JSON.stringify(output) }],
-			};
-		},
+		async (args) => runTool(() => buildDetail(args, opts.primeDeps)),
 	);
 }

package/src/mcp/tools/sf-gql-discover.ts

@@ -7,6 +7,7 @@
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { buildDiscover, type DiscoverDeps } from "../../intent/build-discover.js";
 import { DISCOVER_INPUT } from "../../schemas/input-schemas.js";
+import { runTool } from "../../schemas/tool-adapter.js";
 
 export type SfGqlDiscoverToolOptions = DiscoverDeps;
 
@@ -23,11 +24,6 @@ export function registerSfGqlDiscoverTool(
 				"Discover Salesforce UIAPI schema metadata: list queryable SObjects, describe an object's fields/picklists/child relationships, or describe a single field. Returns mode-specific metadata (not the standard ToolOutput envelope).",
 			inputSchema,
 		},
-		async (args) => {
-			const output = await buildDiscover(args, opts);
-			return {
-				content: [{ type: "text", text: JSON.stringify(output) }],
-			};
-		},
+		async (args) => runTool(() => buildDiscover(args, opts)),
 	);
 }

package/src/mcp/tools/sf-gql-list.ts

@@ -8,6 +8,7 @@ import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { buildList } from "../../intent/build-list.js";
 import { type PrimeDeps } from "../../lib/prime-schema.js";
 import { LIST_INPUT } from "../../schemas/input-schemas.js";
+import { runTool } from "../../schemas/tool-adapter.js";
 
 export interface SfGqlListToolOptions {
 	primeDeps?: PrimeDeps;
@@ -23,11 +24,6 @@ export function registerSfGqlListTool(server: McpServer, opts: SfGqlListToolOpti
 				"Build a UIAPI list query against a Salesforce org. Returns rendered GraphQL, declared variables, generated TypeScript types, and validation warnings.",
 			inputSchema,
 		},
-		async (args) => {
-			const output = await buildList(args, opts.primeDeps);
-			return {
-				content: [{ type: "text", text: JSON.stringify(output) }],
-			};
-		},
+		async (args) => runTool(() => buildList(args, opts.primeDeps)),
 	);
 }

package/src/mcp/tools/sf-gql-raw.ts

@@ -8,6 +8,7 @@ import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { buildRaw } from "../../intent/build-raw.js";
 import { type PrimeDeps } from "../../lib/prime-schema.js";
 import { RAW_INPUT } from "../../schemas/input-schemas.js";
+import { runTool } from "../../schemas/tool-adapter.js";
 
 export interface SfGqlRawToolOptions {
 	primeDeps?: PrimeDeps;
@@ -23,11 +24,6 @@ export function registerSfGqlRawTool(server: McpServer, opts: SfGqlRawToolOption
 				"Low-level escape hatch: build an arbitrary UIAPI query, mutation, or aggregate from CLI-style commands (select/set/var) when the typed tools don't model the case (cross-union selections, custom mutations). Returns rendered GraphQL, declared variables, generated TypeScript types, and validation warnings. Fails fast on a bad command.",
 			inputSchema,
 		},
-		async (args) => {
-			const output = await buildRaw(args, opts.primeDeps);
-			return {
-				content: [{ type: "text", text: JSON.stringify(output) }],
-			};
-		},
+		async (args) => runTool(() => buildRaw(args, opts.primeDeps)),
 	);
 }

package/src/mcp/tools/sf-gql-update.ts

@@ -8,6 +8,7 @@ import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { buildUpdate } from "../../intent/build-update.js";
 import { type PrimeDeps } from "../../lib/prime-schema.js";
 import { UPDATE_INPUT } from "../../schemas/input-schemas.js";
+import { runTool } from "../../schemas/tool-adapter.js";
 
 export interface SfGqlUpdateToolOptions {
 	primeDeps?: PrimeDeps;
@@ -26,11 +27,6 @@ export function registerSfGqlUpdateTool(
 				"Build a UIAPI update mutation against a Salesforce org. Declares a typed input variable ($input: <Object>UpdateInput!) and selects return fields on the updated record. Returns rendered GraphQL, declared variables, generated TypeScript types, and validation warnings.",
 			inputSchema,
 		},
-		async (args) => {
-			const output = await buildUpdate(args, opts.primeDeps);
-			return {
-				content: [{ type: "text", text: JSON.stringify(output) }],
-			};
-		},
+		async (args) => runTool(() => buildUpdate(args, opts.primeDeps)),
 	);
 }