diff --git a/server/src/services/native-runtime/assigned-mcp-tools.test.ts b/server/src/services/native-runtime/assigned-mcp-tools.test.ts index 96a6f1ce4b9..5f4b653f4d9 100644 --- a/server/src/services/native-runtime/assigned-mcp-tools.test.ts +++ b/server/src/services/native-runtime/assigned-mcp-tools.test.ts @@ -131,6 +131,44 @@ describe("assigned MCP runner tools", () => { expect(f.executeTool).not.toHaveBeenCalled(); }); + it("names the closest permitted assigned tools when a name is mistyped, without calling any of them", async () => { + const read = descriptor("github_bot:read_pull_request"); + const begin = descriptor("github_bot:begin_review", "write"); + const submit = descriptor("github_bot:submit_review", "write"); + const f = fixture([read, begin, submit, ...Array.from({ length: 6 }, (_, i) => descriptor(`calendar:event_${i}`))]); + const assigned = await createAssignedMcpTools({ ...f, delivery: "on_demand" }); + const page = await assigned.execute({ tool: searchName, arguments: { query: "github_bot", limit: 20 } }) as { tools: Array<{ name: string }> }; + const alias = (tool: ToolGatewayDescriptor) => page.tools.find(entry => entry.name.includes(tool.name.split(":")[1]!))!.name; + const unknown = (name: string, mode?: "planning") => + assigned.execute({ tool: callName, arguments: { name, arguments: {} } }, mode).then(() => "", (error: Error) => error.message); + + const dropped = await unknown(`${alias(begin).slice(0, -6)}${alias(begin).slice(-5)}`); + expect(dropped).toMatch(/^assigned_mcp_tool_unknown: name must be an exact name returned by paperclip_search_assigned_tools\./); + expect(dropped).toContain(`Closest assigned names: ${alias(begin)}`); + expect(dropped).not.toContain("calendar"); + + const borrowed = await unknown(`${alias(submit).slice(0, -12)}${alias(read).slice(-12)}`); + expect(borrowed).toContain(`Closest assigned names: ${alias(submit)}`); + + const planning = await unknown(`${alias(begin).slice(0, -1)}0`, "planning"); + expect(planning).toBe("assigned_mcp_tool_unknown: name must be an exact name returned by paperclip_search_assigned_tools. Search assigned tools again and use the returned name."); + + await expect(assigned.execute({ tool: searchName, arguments: { query: "", schemaTool: `${alias(read)}x` } })) + .rejects.toThrow(`Closest assigned names: ${alias(read)}`); + + const oversized = `${alias(read)}${"x".repeat(8 * 1024 * 1024)}`; + expect(await unknown(oversized)).not.toContain("Closest assigned names"); + await expect(assigned.execute({ tool: searchName, arguments: { query: "", schemaTool: oversized } })) + .rejects.toThrow("schemaTool must match an authorized inputSchemaRef. Omit schemaTool"); + + f.listToolsForNamedGateway.mockResolvedValue([read, submit]); + expect(await unknown(`${alias(begin).slice(0, -1)}0`)).not.toContain(alias(begin)); + + f.listToolsForNamedGateway.mockRejectedValue(new Error("gateway_token_revoked")); + expect(await unknown(`${alias(read).slice(0, -1)}0`)).toBe("assigned_mcp_tool_unknown: name must be an exact name returned by paperclip_search_assigned_tools. Search assigned tools again and use the returned name."); + expect(f.executeTool).not.toHaveBeenCalled(); + }); + it.each([undefined, "on_demand"] as const)("advertises usable page limits through MCP discovery (%s)", async delivery => { const f = fixture(Array.from({ length: 25 }, (_, i) => descriptor(`operation_${i}`))); const assigned = await createAssignedMcpTools({ ...f, delivery }); diff --git a/server/src/services/native-runtime/assigned-mcp-tools.ts b/server/src/services/native-runtime/assigned-mcp-tools.ts index 7bea0dc5c1c..129c579c6a4 100644 --- a/server/src/services/native-runtime/assigned-mcp-tools.ts +++ b/server/src/services/native-runtime/assigned-mcp-tools.ts @@ -85,6 +85,32 @@ export function assignedToolName(name: string): string { return `app_${readable}_${digest}`; } +function editDistance(left: string, right: string): number { + let previous = Array.from({ length: right.length + 1 }, (_, index) => index); + for (let leftIndex = 1; leftIndex <= left.length; leftIndex += 1) { + const current = [leftIndex]; + for (let rightIndex = 1; rightIndex <= right.length; rightIndex += 1) { + const substitutionCost = left[leftIndex - 1] === right[rightIndex - 1] ? 0 : 1; + current[rightIndex] = Math.min(current[rightIndex - 1]! + 1, previous[rightIndex]! + 1, previous[rightIndex - 1]! + substitutionCost); + } + previous = current; + } + return previous[right.length]!; +} + +function closestNames(reference: string, names: string[]): string { + const target = reference.trim().toLowerCase(); + const closest = names + .map(name => ({ name, limit: Math.floor(Math.max(target.length, name.length) / 3) })) + .filter(({ name, limit }) => Math.abs(target.length - name.length) <= limit) + .map(({ name, limit }) => ({ name, limit, distance: editDistance(target, name.toLowerCase()) })) + .filter(({ distance, limit }) => distance <= limit) + .sort((a, b) => a.distance - b.distance || (a.name < b.name ? -1 : a.name > b.name ? 1 : 0)) + .slice(0, 3) + .map(({ name }) => name); + return closest.length > 0 ? ` Closest assigned names: ${closest.join(", ")}.` : ""; +} + export const ASSIGNED_SCHEMA_LISTING_BUDGET_BYTES = 768 * 1024; export const ASSIGNED_SCHEMA_ADMISSION_CACHE_ENTRIES = 1024; @@ -316,6 +342,19 @@ export async function createAssignedMcpTools(input: { return matches[0]?.[0]; } + // Intersect fresh grants with this session's pinned catalog. Revocations + // take effect immediately; newly assigned tools require a new session. + async function authorizedTools(currentWorkMode?: WorkMode) { + const current = new Map(deduplicateToolDescriptors(await input.gateway.listToolsForNamedGateway({ + gatewayPublicId: input.gatewayPublicId, bearerToken: input.bearerToken, + })).map(tool => [tool.name, tool])); + return [...tools].filter(([, { tool }]) => { + const fresh = current.get(tool.name); + return fresh && permits(tool) && permits(tool, currentWorkMode) && + permits(fresh) && permits(fresh, currentWorkMode); + }); + } + async function search(argumentsValue: unknown, currentWorkMode?: WorkMode) { const args = object(argumentsValue); const offset = args.offset ?? 0; @@ -332,21 +371,14 @@ export async function createAssignedMcpTools(input: { if (schemaOffset > 0 && !hasSchemaTool) { throw new Error("assigned_mcp_tool_invalid_arguments: A positive schemaOffset requires an exact inputSchemaRef in schemaTool. Omit schemaTool and schemaOffset to search assigned tools."); } - // Intersect fresh grants with this session's pinned catalog. Revocations - // take effect immediately; newly assigned tools require a new session. - const current = new Map(deduplicateToolDescriptors(await input.gateway.listToolsForNamedGateway({ - gatewayPublicId: input.gatewayPublicId, bearerToken: input.bearerToken, - })).map(tool => [tool.name, tool])); const terms = args.query.toLowerCase().trim().split(/\s+/).filter(Boolean); - const authorized = [...tools].filter(([, { tool }]) => { - const fresh = current.get(tool.name); - return fresh && permits(tool) && permits(tool, currentWorkMode) && - permits(fresh) && permits(fresh, currentWorkMode); - }); + const authorized = await authorizedTools(currentWorkMode); if (hasSchemaTool) { const reference = resolveAssignedName(args.schemaTool as string, "schemaTool"); const selected = authorized.find(([name]) => name === reference); - if (!selected) throw new Error("assigned_mcp_tool_unknown: schemaTool must match an authorized inputSchemaRef. Omit schemaTool to search assigned tools, then use an exact inputSchemaRef from the results."); + if (!selected) { + throw new Error(`assigned_mcp_tool_unknown: schemaTool must match an authorized inputSchemaRef.${closestNames(args.schemaTool as string, authorized.map(([name]) => name))} Omit schemaTool to search assigned tools, then use an exact inputSchemaRef from the results.`); + } const schema = JSON.stringify(selected[1].schema); const end = schemaOffset + schemaChunkCharacters; return { @@ -405,7 +437,8 @@ export async function createAssignedMcpTools(input: { parameters = object(args.arguments); const resolved = resolveAssignedName(args.name, "name"); if (!resolved) { - throw new Error("assigned_mcp_tool_unknown: name must be an exact name returned by paperclip_search_assigned_tools. Search assigned tools again and use the returned name."); + const authorized = await authorizedTools(currentWorkMode).then(entries => entries.map(([candidate]) => candidate), () => []); + throw new Error(`assigned_mcp_tool_unknown: name must be an exact name returned by paperclip_search_assigned_tools.${closestNames(args.name, authorized)} Search assigned tools again and use the returned name.`); } name = resolved; }