@salesforce/graphiti 10.15.1 → 10.17.0

package/src/commands/mcp-mirror/__tests__/run-mirror.spec.ts

@@ -0,0 +1,251 @@
+/**
+ * Copyright (c) 2026, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+import { beforeEach, describe, expect, it } from "vitest";
+import { z } from "zod";
+import { captureStdout } from "../../../__tests__/helpers/stdout.js";
+import { SchemaRefreshError } from "../../../lib/prime-schema.js";
+import { runMirror } from "../run-mirror.js";
+
+const SCHEMA = z.object({ org: z.string().min(1), object: z.string() });
+
+beforeEach(() => {
+	// runMirror signals failure via process.exitCode; establish a known 0
+	// baseline so "success leaves it 0" is deterministic and a prior failing
+	// case doesn't leak into the next.
+	process.exitCode = 0;
+});
+
+describe("runMirror", () => {
+	it("prints the build output as one JSON line on success and leaves exitCode 0", async () => {
+		const build = async (input: { org: string; object: string }) => ({
+			query: `# ${input.object}`,
+			echoedOrg: input.org,
+		});
+
+		const out = await captureStdout(() =>
+			runMirror('{"org":"ebikes","object":"Account"}', SCHEMA, build),
+		);
+
+		expect(out.trim().split("\n")).toHaveLength(1);
+		expect(JSON.parse(out)).toEqual({ query: "# Account", echoedOrg: "ebikes" });
+		expect(process.exitCode).toBe(0);
+	});
+
+	it("passes the parsed+validated input to the build function", async () => {
+		let received: unknown;
+		const build = async (input: unknown) => {
+			received = input;
+			return {};
+		};
+
+		await captureStdout(() => runMirror('{"org":"o","object":"Account"}', SCHEMA, build));
+
+		expect(received).toEqual({ org: "o", object: "Account" });
+	});
+
+	it("emits an INVALID_ARGS envelope and sets exitCode 1 on malformed JSON", async () => {
+		const build = async () => ({});
+
+		const out = await captureStdout(() => runMirror("{not json", SCHEMA, build));
+
+		const parsed = JSON.parse(out);
+		expect(parsed.error.code).toBe("INVALID_ARGS");
+		expect(parsed.error.message).toBeTruthy();
+		expect(process.exitCode).toBe(1);
+	});
+
+	it("emits an INVALID_ARGS envelope with Zod details on schema-validation failure", async () => {
+		const build = async () => ({});
+
+		// org is "" → fails min(1); object missing
+		const out = await captureStdout(() => runMirror('{"org":""}', SCHEMA, build));
+
+		const parsed = JSON.parse(out);
+		expect(parsed.error.code).toBe("INVALID_ARGS");
+		expect(parsed.error.details).toBeTruthy();
+		expect(process.exitCode).toBe(1);
+	});
+
+	it("does not call build when validation fails", async () => {
+		let called = false;
+		const build = async () => {
+			called = true;
+			return {};
+		};
+
+		await captureStdout(() => runMirror('{"org":""}', SCHEMA, build));
+
+		expect(called).toBe(false);
+	});
+
+	it("reads JSON from stdin when no positional arg is given", async () => {
+		const build = async (input: { org: string; object: string }) => ({ org: input.org });
+
+		const out = await captureStdout(() =>
+			runMirror(undefined, SCHEMA, build, {
+				readStdin: async () => '{"org":"from-stdin","object":"Case"}',
+			}),
+		);
+
+		expect(JSON.parse(out)).toEqual({ org: "from-stdin" });
+		expect(process.exitCode).toBe(0);
+	});
+
+	it("emits INVALID_ARGS without hanging when no arg is given and stdin is a TTY", async () => {
+		let stdinRead = false;
+		const build = async () => ({});
+
+		const out = await captureStdout(() =>
+			runMirror(undefined, SCHEMA, build, {
+				isTTY: true,
+				readStdin: async () => {
+					stdinRead = true;
+					return "";
+				},
+			}),
+		);
+
+		expect(stdinRead).toBe(false); // guarded before touching stdin
+		expect(JSON.parse(out).error.code).toBe("INVALID_ARGS");
+		expect(process.exitCode).toBe(1);
+	});
+
+	it("maps SchemaRefreshError to SCHEMA_PRIME_FAILED", async () => {
+		const build = async () => {
+			throw new SchemaRefreshError("schema is stale", {
+				instanceUrl: "https://x.my.salesforce.com",
+			});
+		};
+
+		const out = await captureStdout(() =>
+			runMirror('{"org":"o","object":"Account"}', SCHEMA, build),
+		);
+
+		const parsed = JSON.parse(out);
+		expect(parsed.error.code).toBe("SCHEMA_PRIME_FAILED");
+		expect(parsed.error.message).toContain("stale");
+		expect(process.exitCode).toBe(1);
+	});
+
+	it("maps an unrecognized thrown error to INTERNAL and preserves its message", async () => {
+		const build = async () => {
+			throw new Error("something totally unexpected happened");
+		};
+
+		const out = await captureStdout(() =>
+			runMirror('{"org":"o","object":"Account"}', SCHEMA, build),
+		);
+
+		const parsed = JSON.parse(out);
+		expect(parsed.error.code).toBe("INTERNAL");
+		expect(parsed.error.message).toContain("something totally unexpected");
+		expect(process.exitCode).toBe(1);
+	});
+
+	it("best-effort classifies auth-shaped messages as AUTH_FAILED", async () => {
+		const build = async () => {
+			throw new Error("Authentication failed; no valid token for org");
+		};
+
+		const out = await captureStdout(() =>
+			runMirror('{"org":"o","object":"Account"}', SCHEMA, build),
+		);
+
+		const parsed = JSON.parse(out);
+		expect(parsed.error.code).toBe("AUTH_FAILED");
+		expect(parsed.error.message).toContain("Authentication failed");
+		expect(process.exitCode).toBe(1);
+	});
+
+	it("best-effort classifies a ~/.sf path message as AUTH_FAILED", async () => {
+		const build = async () => {
+			throw new Error("Could not read credentials from ~/.sf");
+		};
+
+		const out = await captureStdout(() =>
+			runMirror('{"org":"o","object":"Account"}', SCHEMA, build),
+		);
+
+		expect(JSON.parse(out).error.code).toBe("AUTH_FAILED");
+	});
+
+	it("best-effort classifies introspection/priming messages as SCHEMA_PRIME_FAILED", async () => {
+		const build = async () => {
+			throw new Error("schema download failed during introspection");
+		};
+
+		const out = await captureStdout(() =>
+			runMirror('{"org":"o","object":"Account"}', SCHEMA, build),
+		);
+
+		expect(JSON.parse(out).error.code).toBe("SCHEMA_PRIME_FAILED");
+	});
+
+	it("still prefers the typed SchemaRefreshError signal over message regex", async () => {
+		// A SchemaRefreshError whose message happens to contain an auth-ish word
+		// must still classify by type, not by the regex.
+		const build = async () => {
+			throw new SchemaRefreshError("stale; re-authorization may help", {
+				instanceUrl: "https://x.my.salesforce.com",
+			});
+		};
+
+		const out = await captureStdout(() =>
+			runMirror('{"org":"o","object":"Account"}', SCHEMA, build),
+		);
+
+		expect(JSON.parse(out).error.code).toBe("SCHEMA_PRIME_FAILED");
+	});
+
+	it("treats a literal '-' positional arg as 'read from stdin'", async () => {
+		const build = async (input: { org: string; object: string }) => ({ org: input.org });
+
+		const out = await captureStdout(() =>
+			runMirror("-", SCHEMA, build, {
+				readStdin: async () => '{"org":"via-dash","object":"Case"}',
+			}),
+		);
+
+		expect(JSON.parse(out)).toEqual({ org: "via-dash" });
+		expect(process.exitCode).toBe(0);
+	});
+
+	it("does not leak a stack trace in the INTERNAL envelope by default", async () => {
+		const build = async () => {
+			throw new Error("boom");
+		};
+
+		const out = await captureStdout(() =>
+			runMirror('{"org":"o","object":"Account"}', SCHEMA, build),
+		);
+
+		const parsed = JSON.parse(out);
+		expect(parsed.error.code).toBe("INTERNAL");
+		expect(parsed.error.details).toBeUndefined();
+	});
+
+	it("attaches the stack to INTERNAL details when GRAPHITI_DEBUG=1", async () => {
+		const prev = process.env.GRAPHITI_DEBUG;
+		process.env.GRAPHITI_DEBUG = "1";
+		try {
+			const build = async () => {
+				throw new Error("boom");
+			};
+
+			const out = await captureStdout(() =>
+				runMirror('{"org":"o","object":"Account"}', SCHEMA, build),
+			);
+
+			const parsed = JSON.parse(out);
+			expect(parsed.error.code).toBe("INTERNAL");
+			expect(parsed.error.details.stack).toContain("boom");
+		} finally {
+			if (prev === undefined) delete process.env.GRAPHITI_DEBUG;
+			else process.env.GRAPHITI_DEBUG = prev;
+		}
+	});
+});

package/src/commands/mcp-mirror/commands.ts

@@ -0,0 +1,92 @@
+/**
+ * Copyright (c) 2026, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+/**
+ * CLI mirror commands — one entry per MCP tool. Each binds a Zod input schema
+ * to the matching `intent/build*()` function; all the real logic lives in
+ * `runMirror` (`run-mirror.ts`). The commands are siblings of the MCP tools: same
+ * args, same output, different transport.
+ *
+ * The bindings are data, not bespoke functions — `cli.ts` registers them in a
+ * loop and the tests iterate them, so adding a tool is one `defineMirror(...)`
+ * line here.
+ */
+
+import { type z } from "zod";
+import { runMirror } from "./run-mirror.js";
+import { buildAggregate } from "../../intent/build-aggregate.js";
+import { buildConnect } from "../../intent/build-connect.js";
+import { buildCreate } from "../../intent/build-create.js";
+import { buildDelete } from "../../intent/build-delete.js";
+import { buildDetail } from "../../intent/build-detail.js";
+import { buildDiscover } from "../../intent/build-discover.js";
+import { buildList } from "../../intent/build-list.js";
+import { buildRaw } from "../../intent/build-raw.js";
+import { buildUpdate } from "../../intent/build-update.js";
+import {
+	AGGREGATE_INPUT,
+	CONNECT_INPUT,
+	CREATE_INPUT,
+	DELETE_INPUT,
+	DETAIL_INPUT,
+	DISCOVER_INPUT,
+	LIST_INPUT,
+	RAW_INPUT,
+	UPDATE_INPUT,
+} from "../../schemas/input-schemas.js";
+
+/** A single CLI mirror command: its subcommand name, help summary, and runner. */
+export interface MirrorCommand {
+	/** CLI subcommand name, e.g. "sf-gql-list", matching the MCP tool's `sf_gql_*`. */
+	name: string;
+	/** One-line `--help` summary. */
+	summary: string;
+	/** Read JSON (positional arg or stdin), validate, build, emit one JSON line. */
+	run: (jsonArg?: string) => Promise<void>;
+}
+
+/**
+ * Bind a schema to its builder behind a uniform `run`. The generic `T` is
+ * captured here, at construction, where the schema and builder types still line
+ * up — so {@link MIRRORS} can be a single homogeneous array without forcing the
+ * builders through an `unknown` parameter (which would fail by contravariance).
+ */
+function defineMirror<T>(
+	name: string,
+	summary: string,
+	schema: z.ZodType<T>,
+	build: (input: T) => Promise<unknown>,
+): MirrorCommand {
+	return { name, summary, run: (jsonArg) => runMirror(jsonArg, schema, build) };
+}
+
+/** Every CLI mirror command. Single source of truth for `cli.ts` and the tests. */
+export const MIRRORS: MirrorCommand[] = [
+	defineMirror("sf-gql-list", "Build a UIAPI list query.", LIST_INPUT, buildList),
+	defineMirror("sf-gql-detail", "Build a single-record detail query.", DETAIL_INPUT, buildDetail),
+	defineMirror("sf-gql-discover", "Discover UIAPI schema metadata.", DISCOVER_INPUT, buildDiscover),
+	defineMirror(
+		"sf-gql-aggregate",
+		"Build a UIAPI aggregate query.",
+		AGGREGATE_INPUT,
+		buildAggregate,
+	),
+	defineMirror(
+		"sf-gql-raw",
+		"Build an arbitrary query from CLI-style commands.",
+		RAW_INPUT,
+		buildRaw,
+	),
+	defineMirror("sf-gql-create", "Build a UIAPI create mutation.", CREATE_INPUT, buildCreate),
+	defineMirror("sf-gql-update", "Build a UIAPI update mutation.", UPDATE_INPUT, buildUpdate),
+	defineMirror("sf-gql-delete", "Build a UIAPI delete mutation.", DELETE_INPUT, buildDelete),
+	defineMirror(
+		"sf-gql-connect",
+		"Prime/refresh an org's schema cache.",
+		CONNECT_INPUT,
+		buildConnect,
+	),
+];

package/src/commands/mcp-mirror/run-mirror.ts

@@ -0,0 +1,149 @@
+/**
+ * Copyright (c) 2026, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+import { type z } from "zod";
+import { SchemaRefreshError } from "../../lib/prime-schema.js";
+
+/**
+ * Shared adapter for the `sf-gql-*` CLI mirror commands. Each command reads a
+ * JSON blob (positional arg or stdin), validates it against the same Zod schema
+ * the matching MCP tool advertises, calls the same `intent/build*()` function
+ * the MCP tool calls, and emits exactly one JSON line on stdout. This keeps the
+ * CLI a sibling adapter to the MCP server — same args, same output, different
+ * transport.
+ *
+ * Failures emit a JSON error envelope and set `process.exitCode = 1`. We use
+ * `process.exitCode` rather than `process.exit()` so the buffered stdout write
+ * has time to flush before the process ends.
+ */
+
+/** Error codes surfaced in the failure envelope. */
+export type MirrorErrorCode = "INVALID_ARGS" | "AUTH_FAILED" | "SCHEMA_PRIME_FAILED" | "INTERNAL";
+
+/**
+ * Best-effort classification of a plain `Error` message into a more specific
+ * code. The intent/auth layers throw plain `Error`s with no type signal, so the
+ * only available hint is the message text. This is a NON-CONTRACT heuristic: a
+ * reworded upstream message can fall through to `INTERNAL`. The verbatim message
+ * is always preserved either way, and the typed `SchemaRefreshError` signal
+ * (checked before this) takes precedence. Patterns mirror the MCP-CLI prior art.
+ */
+function classifyErrorMessage(message: string): MirrorErrorCode {
+	if (
+		/\bauth(?:entication|orization)?\b/i.test(message) ||
+		/\bno org\b/i.test(message) ||
+		message.includes("~/.sf")
+	) {
+		return "AUTH_FAILED";
+	}
+	if (/\b(?:introspect(?:ion)?|priming|schema download)\b/i.test(message)) {
+		return "SCHEMA_PRIME_FAILED";
+	}
+	return "INTERNAL";
+}
+
+export interface MirrorErrorEnvelope {
+	error: {
+		code: MirrorErrorCode;
+		message: string;
+		details?: unknown;
+	};
+}
+
+export interface RunMirrorDeps {
+	/** Read the full JSON payload from stdin. Injectable for tests. */
+	readStdin?: () => Promise<string>;
+	/** Whether stdin is a TTY. When true and no arg is given, we don't block on stdin. */
+	isTTY?: boolean;
+}
+
+async function readAllStdin(): Promise<string> {
+	const chunks: Buffer[] = [];
+	for await (const chunk of process.stdin) {
+		chunks.push(chunk as Buffer);
+	}
+	return Buffer.concat(chunks).toString("utf8");
+}
+
+function emitError(code: MirrorErrorCode, message: string, details?: unknown): void {
+	const envelope: MirrorErrorEnvelope = {
+		error: details === undefined ? { code, message } : { code, message, details },
+	};
+	console.log(JSON.stringify(envelope));
+	// Not process.exit(1): let the buffered stdout write flush first.
+	process.exitCode = 1;
+}
+
+/**
+ * Run one mirror command end-to-end.
+ *
+ * @param jsonArg   Positional JSON argument, or undefined to read from stdin.
+ * @param schema    The tool's Zod input schema (shared with the MCP tool).
+ * @param build     The intent-layer builder; receives the validated input.
+ * @param deps      Injectable stdin reader / TTY flag for testing.
+ */
+export async function runMirror<T>(
+	jsonArg: string | undefined,
+	schema: z.ZodType<T>,
+	build: (input: T) => Promise<unknown>,
+	deps: RunMirrorDeps = {},
+): Promise<void> {
+	// 1. Source the raw JSON: a positional arg wins, except a literal "-" which
+	//    is the conventional "read from stdin" sentinel. Otherwise read stdin
+	//    (unless TTY, where blocking would hang waiting for a human to type).
+	const isTTY = deps.isTTY ?? process.stdin.isTTY;
+	const wantsStdin = jsonArg === undefined || jsonArg === "-";
+	let raw: string;
+	if (!wantsStdin) {
+		raw = jsonArg as string;
+	} else if (isTTY) {
+		emitError("INVALID_ARGS", "No input provided. Pass a JSON argument or pipe JSON to stdin.");
+		return;
+	} else {
+		const readStdin = deps.readStdin ?? readAllStdin;
+		raw = await readStdin();
+		if (!raw.trim()) {
+			emitError("INVALID_ARGS", "No input provided. Pass a JSON argument or pipe JSON to stdin.");
+			return;
+		}
+	}
+
+	// 2. Parse JSON.
+	let json: unknown;
+	try {
+		json = JSON.parse(raw);
+	} catch (err) {
+		emitError("INVALID_ARGS", `Invalid JSON: ${(err as Error).message}`);
+		return;
+	}
+
+	// 3. Validate against the shared Zod schema.
+	const result = schema.safeParse(json);
+	if (!result.success) {
+		emitError("INVALID_ARGS", "Input failed schema validation.", result.error.issues);
+		return;
+	}
+
+	// 4. Build and emit. Classify failures: the typed SchemaRefreshError signal
+	//    first, then a best-effort message regex (AUTH_FAILED / SCHEMA_PRIME_FAILED),
+	//    else INTERNAL. The verbatim message is always preserved.
+	try {
+		const output = await build(result.data);
+		console.log(JSON.stringify(output));
+	} catch (err) {
+		const message = err instanceof Error ? err.message : String(err);
+		// Typed signal wins; otherwise fall back to the best-effort message regex.
+		const code: MirrorErrorCode =
+			err instanceof SchemaRefreshError ? "SCHEMA_PRIME_FAILED" : classifyErrorMessage(message);
+		// The stack is omitted by default so the envelope never leaks internals;
+		// GRAPHITI_DEBUG=1 opts into attaching it under `details` for debugging.
+		const details =
+			process.env.GRAPHITI_DEBUG === "1" && err instanceof Error && err.stack
+				? { stack: err.stack }
+				: undefined;
+		emitError(code, message, details);
+	}
+}

package/src/lib/graphql-name.ts

@@ -14,8 +14,8 @@
  * warning (`buildOutput` never throws) while the malformed query is still
  * returned as `ToolOutput.query`.
  *
- * The MCP boundary has its own zod-based `graphqlName()` factory
- * (`src/mcp/tools/shared/zod-schemas.ts`); this is the intent-layer twin used
+ * The schema boundary has its own zod-based `graphqlName()` factory
+ * (`src/schemas/fields.ts`); this is the intent-layer twin used
  * by the builders, which are also reachable directly (CLI, eval harness).
  */
 export const GRAPHQL_NAME_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;

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

@@ -5,81 +5,15 @@
  */
 
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { z } from "zod";
-import { graphqlName } from "./shared/zod-schemas.js";
 import { buildAggregate } from "../../intent/build-aggregate.js";
-import { GROUP_BY_FUNCTIONS } from "../../intent/types.js";
 import { type PrimeDeps } from "../../lib/prime-schema.js";
+import { AGGREGATE_INPUT } from "../../schemas/input-schemas.js";
 
 export interface SfGqlAggregateToolOptions {
 	primeDeps?: PrimeDeps;
 }
 
-const aliasField = z
-	.string()
-	.optional()
-	.describe("GraphQL alias for this aggregation's result key.");
-
-const aggregationSchema = z.discriminatedUnion("function", [
-	z.object({
-		function: z.enum(["count", "countDistinct"]),
-		field: z.string().optional().describe('SObject field API name. Defaults to "Id" when omitted.'),
-		alias: aliasField,
-	}),
-	z.object({
-		function: z.enum(["sum", "avg", "min", "max"]),
-		field: z.string().describe("SObject field API name. Required for sum/avg/min/max."),
-		alias: aliasField,
-	}),
-]);
-
-const groupByElementSchema = z.union([
-	z.string(),
-	z.object({
-		field: z.string().describe("SObject field API name (DateTime/Date field)."),
-		function: z
-			.enum(GROUP_BY_FUNCTIONS)
-			.describe("Date bucketing function from UIAPI GroupByFunction enum."),
-	}),
-]);
-
-const inputSchema = {
-	org: z.string().describe("Org alias resolved via local Salesforce CLI auth (~/.sf, ~/.sfdx)."),
-	object: graphqlName('SObject API name, e.g. "Account", "Order". Must be a valid GraphQL Name.'),
-	groupBy: z
-		.array(groupByElementSchema)
-		.optional()
-		.describe(
-			"GroupBy elements. Each is either a plain field name string (renders as `{Field: {group: true}}`) or an object `{field, function}` for date-bucketed groupBy (renders as `{Field: {function: CALENDAR_MONTH}}`). Omit or pass `[]` for un-grouped aggregation; with no aggregations either, defaults to `count` over `Id` (FR-8.2).",
-		),
-	aggregations: z
-		.array(aggregationSchema)
-		.optional()
-		.describe(
-			"List of aggregation functions to compute. Each entry projects under its alias (or default `<function><PascalCaseField>`).",
-		),
-	filter: z
-		.record(z.unknown())
-		.optional()
-		.describe(
-			"<Object>_Filter applied to every aggregation. String leaves matching $varName promote to typed query variables.",
-		),
-	orderBy: z
-		.union([z.record(z.unknown()), z.array(z.record(z.unknown()))])
-		.optional()
-		.describe(
-			"<Object>_OrderBy. Singleton object preferred; arrays are collapsed to the first entry. String leaves matching $varName promote to typed query variables.",
-		),
-	first: z
-		.number()
-		.int()
-		.positive()
-		.optional()
-		.describe("Connection page size (top-N pattern). No default — omit for all buckets."),
-	operationName: graphqlName(
-		"Override the GraphQL operation name. Defaults to <Object>Aggregate.",
-	).optional(),
-};
+const inputSchema = AGGREGATE_INPUT.shape;
 
 export function registerSfGqlAggregateTool(
 	server: McpServer,

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

@@ -5,21 +5,12 @@
  */
 
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { z } from "zod";
-import { orgAlias } from "./shared/zod-schemas.js";
 import { buildConnect, type ConnectDeps } from "../../intent/build-connect.js";
+import { CONNECT_INPUT } from "../../schemas/input-schemas.js";
 
 export type SfGqlConnectToolOptions = ConnectDeps;
 
-const inputSchema = {
-	org: orgAlias("Org alias or username resolved via local Salesforce CLI auth (~/.sf, ~/.sfdx)."),
-	forceRefresh: z
-		.boolean()
-		.optional()
-		.describe(
-			"Re-download the schema even if it is already cached, clearing the on-disk introspection JSON, the in-memory parsed schema, and the ObjectInfo cache. Use after deploying new metadata (fields, picklist values, objects) so subsequent tools see the changes. Defaults to false.",
-		),
-};
+const inputSchema = CONNECT_INPUT.shape;
 
 export function registerSfGqlConnectTool(
 	server: McpServer,

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

@@ -5,34 +5,15 @@
  */
 
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { z } from "zod";
-import { graphqlName } from "./shared/zod-schemas.js";
 import { buildCreate } from "../../intent/build-create.js";
 import { type PrimeDeps } from "../../lib/prime-schema.js";
+import { CREATE_INPUT } from "../../schemas/input-schemas.js";
 
 export interface SfGqlCreateToolOptions {
 	primeDeps?: PrimeDeps;
 }
 
-const inputSchema = {
-	org: z.string().describe("Org alias resolved via local Salesforce CLI auth (~/.sf, ~/.sfdx)."),
-	object: graphqlName('SObject API name, e.g. "Account", "Order". Must be a valid GraphQL Name.'),
-	returnFields: z
-		.array(z.string())
-		.optional()
-		.describe(
-			'Scalar field API names to read back on the created Record. Defaults to ["Id"]. Dot-paths like Owner.Name are not supported in mutation results; passing them produces a warning and the field is skipped.',
-		),
-	inputVariable: z
-		.string()
-		.optional()
-		.describe(
-			'Variable name (without "$") for the create input. Defaults to "input". Declared as $<name>: <Object>CreateInput!.',
-		),
-	operationName: graphqlName(
-		"Override the GraphQL operation name. Defaults to Create<Object>.",
-	).optional(),
-};
+const inputSchema = CREATE_INPUT.shape;
 
 export function registerSfGqlCreateTool(
 	server: McpServer,

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

@@ -5,28 +5,15 @@
  */
 
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { z } from "zod";
-import { graphqlName } from "./shared/zod-schemas.js";
 import { buildDelete } from "../../intent/build-delete.js";
 import { type PrimeDeps } from "../../lib/prime-schema.js";
+import { DELETE_INPUT } from "../../schemas/input-schemas.js";
 
 export interface SfGqlDeleteToolOptions {
 	primeDeps?: PrimeDeps;
 }
 
-const inputSchema = {
-	org: z.string().describe("Org alias resolved via local Salesforce CLI auth (~/.sf, ~/.sfdx)."),
-	object: graphqlName('SObject API name, e.g. "Account", "Order". Must be a valid GraphQL Name.'),
-	inputVariable: z
-		.string()
-		.optional()
-		.describe(
-			'Variable name (without "$") for the delete input. Defaults to "input". Declared as $<name>: RecordDeleteInput! — the schema-wide delete input carrying the record Id, not an <Object>-specific type.',
-		),
-	operationName: graphqlName(
-		"Override the GraphQL operation name. Defaults to Delete<Object>.",
-	).optional(),
-};
+const inputSchema = DELETE_INPUT.shape;
 
 export function registerSfGqlDeleteTool(
 	server: McpServer,