support native url elicitation mode in MCP host

Previously UrlElicitation was converted to a form with a _url_hint property workaround. Now the server uses the MCP SDK's native mode:"url" elicitation and requires both form and url client capabilities before enabling inline elicitation. Clients with only form support fall back to the pause/resume path.

Rhys Sullivan committed 7 months ago

Commit 7616ccf1 parent 5bca7c92 files · +72 −48Browse files

Unified · Split

2 files

packages/hosts/mcp/src/server.test.ts +61 −29
packages/hosts/mcp/src/server.ts +11 −19

packages/hosts/mcp/src/server.test.ts+61−29

     });
     const { client, close } = await connect(engine, {
-      elicitation: { form: {} },
+      elicitation: { form: {}, url: {} },
     });
     try {
     });
     const { client, close } = await connect(engine, {
-      elicitation: { form: {} },
+      elicitation: { form: {}, url: {} },
     });
     // Register a client-side handler that auto-accepts
     });
     const { client, close } = await connect(engine, {
-      elicitation: { form: {} },
+      elicitation: { form: {}, url: {} },
     });
     client.setRequestHandler(ElicitRequestSchema, async () => ({
     });
     const { client, close } = await connect(engine, {
-      elicitation: { form: {} },
+      elicitation: { form: {}, url: {} },
     });
     client.setRequestHandler(ElicitRequestSchema, async (request) => {
     }
   });
-  it("UrlElicitation is converted to a form with _url_hint property", async () => {
+  it("UrlElicitation is sent as native mode:url elicitation", async () => {
-    let receivedMessage: string | undefined;
+    let receivedParams: Record<string, unknown> | undefined;
-    let receivedSchema: Record<string, unknown> | undefined;
     const engine = makeStubEngine({
       execute: async (_code, { onElicitation }) => {
     });
     const { client, close } = await connect(engine, {
-      elicitation: { form: {} },
+      elicitation: { form: {}, url: {} },
     });
     client.setRequestHandler(ElicitRequestSchema, async (request) => {
-      receivedMessage = request.params.message;
+      receivedParams = request.params as Record<string, unknown>;
-      const params = request.params;
-      if ("requestedSchema" in params) {
-        receivedSchema = params.requestedSchema as Record<string, unknown>;
-      }
       return { action: "accept" as const, content: {} };
     });
         name: "execute",
         arguments: { code: "oauth" },
       });
-      expect(receivedMessage).toBe("Please authenticate");
+      expect(receivedParams?.mode).toBe("url");
-      expect(receivedSchema).toEqual({
+      expect(receivedParams?.message).toBe("Please authenticate");
-        type: "object",
+      expect(receivedParams?.url).toBe("https://example.com/oauth");
-        properties: {
+      expect(receivedParams?.elicitationId).toBe("elic-1");
-          _url_hint: {
-            type: "string",
-            description:
-              "Please open this URL: https://example.com/oauth",
-            default: "https://example.com/oauth",
-          },
-        },
-      });
     } finally {
       await close();
     }
     });
     const { client, close } = await connect(engine, {
-      elicitation: { form: {} },
+      elicitation: { form: {}, url: {} },
     });
     try {
   it("resume tool is hidden when client supports elicitation", async () => {
     const engine = makeStubEngine({});
     const { client, close } = await connect(engine, {
-      elicitation: { form: {} },
+      elicitation: { form: {}, url: {} },
     });
     try {
   });
 });
+// ---------------------------------------------------------------------------
+// Tests — client with form-only elicitation (falls back to pause/resume)
+// ---------------------------------------------------------------------------
+describe("MCP host server — client with form-only elicitation", () => {
+  it("resume tool is visible when client only supports form elicitation", async () => {
+    const engine = makeStubEngine({});
+    const { client, close } = await connect(engine, {
+      elicitation: { form: {} },
+    });
+    try {
+      const { tools } = await client.listTools();
+      const names = tools.map((t) => t.name);
+      expect(names).toContain("execute");
+      expect(names).toContain("resume");
+    } finally {
+      await close();
+    }
+  });
+  it("uses pause/resume path when client only supports form", async () => {
+    const engine = makeStubEngine({
+      executeWithPause: async () => ({
+        status: "completed",
+        result: { result: "form-only-path" },
+      }),
+    });
+    const { client, close } = await connect(engine, {
+      elicitation: { form: {} },
+    });
+    try {
+      const result = await client.callTool({
+        name: "execute",
+        arguments: { code: "test" },
+      });
+      expect(result.content).toEqual([{ type: "text", text: "form-only-path" }]);
+    } finally {
+      await close();
+    }
+  });
+});
 // ---------------------------------------------------------------------------
 // Tests — client WITHOUT elicitation (pause/resume path)
 // ---------------------------------------------------------------------------
     });
     const { client, close } = await connect(engine, {
-      elicitation: { form: {} },
+      elicitation: { form: {}, url: {} },
     });
     // Client throws when it receives the elicitation — server should catch
     });
     const { client, close } = await connect(engine, {
-      elicitation: { form: {} },
+      elicitation: { form: {}, url: {} },
     });
     let callCount = 0;

packages/hosts/mcp/src/server.ts+11−19

   const capabilities = server.server.getClientCapabilities();
   if (capabilities === undefined || !capabilities.elicitation) return false;
   const elicitation = capabilities.elicitation as Record<string, unknown>;
-  // The MCP SDK requires `elicitation.form` for form-based elicitation.
+  return Boolean(elicitation.form) && Boolean(elicitation.url);
-  // An empty `elicitation: {}` is auto-upgraded to `{ form: {} }` by the SDK's
-  // schema preprocess, but we guard explicitly in case that doesn't apply.
-  return Boolean(elicitation.form);
 };
-const elicitationRequestToSchema: (
+type ElicitInputParams =
-  request: ElicitationRequest,
+  | { mode?: "form"; message: string; requestedSchema: { readonly [key: string]: unknown } }
-) => { message: string; requestedSchema: { readonly [key: string]: unknown } } =
+  | { mode: "url"; message: string; url: string; elicitationId: string };
+const elicitationRequestToParams: (request: ElicitationRequest) => ElicitInputParams =
   Match.type<ElicitationRequest>().pipe(
     Match.tag("UrlElicitation", (req) => ({
+      mode: "url" as const,
       message: req.message,
-      requestedSchema: {
+      url: req.url,
-        type: "object",
+      elicitationId: req.elicitationId,
-        properties: {
-          _url_hint: {
-            type: "string",
-            description: `Please open this URL: ${req.url}`,
-            default: req.url,
-          },
-        },
-      },
     })),
     Match.tag("FormElicitation", (req) => ({
       message: req.message,
 const makeMcpElicitationHandler = (server: McpServer): ElicitationHandler =>
   (ctx: ElicitationContext): Effect.Effect<typeof ElicitationResponse.Type> => {
-    const { message, requestedSchema } = elicitationRequestToSchema(ctx.request);
+    const params = elicitationRequestToParams(ctx.request);
     return Effect.promise(async (): Promise<typeof ElicitationResponse.Type> => {
       try {
         const response = await server.server.elicitInput(
-          { message, requestedSchema } as Parameters<typeof server.server.elicitInput>[0],
+          params as Parameters<typeof server.server.elicitInput>[0],
         );
         return {