@@ -5,6 +5,7 @@ import { describe, expect, test } from "bun:test"
 import { Client, InMemoryTransport, StreamableHTTPClientTransport } from "@modelcontextprotocol/client"
 import {
   createMcpHandler,
+  type ElicitRequestFormParams,
   inputRequired,
   inputResponse,
   Server,
@@ -104,6 +105,7 @@ function resourceServer(
     malformedTool?: boolean
     /** Legacy servers give up on the URL elicitation after this many milliseconds. */
     elicitationTimeout?: number
+    formElicitation?: boolean
     respond?: (request: Request) => Response | undefined | Promise<Response | undefined>
   } = {},
 ) {
@@ -166,7 +168,9 @@ function resourceServer(
                 ? [{ name: "empty-elicitation", inputSchema: { type: "object" as const, properties: {} } }]
                 : input.urlElicitation
                   ? [{ name: "url-elicitation", inputSchema: { type: "object" as const, properties: {} } }]
-                  : [{ name: "echo", inputSchema: { type: "object" as const, properties: {} } }]),
+                  : input.formElicitation
+                    ? [{ name: "form-elicitation", inputSchema: { type: "object" as const, properties: {} } }]
+                    : [{ name: "echo", inputSchema: { type: "object" as const, properties: {} } }]),
             ],
           })
         })
@@ -208,7 +212,51 @@ function resourceServer(
             }
           })
         }
-        if (!input.emptyElicitation && !input.urlElicitation) {
+        if (input.formElicitation) {
+          // The primitive schema kinds the elicitation specification allows (client/elicitation#requested-schema):
+          // string with constraints and a default, integer with bounds, a single-select enum, and a boolean.
+          const requestedSchema = {
+            type: "object",
+            properties: {
+              name: {
+                type: "string",
+                title: "Full name",
+                description: "Your display name",
+                minLength: 2,
+                maxLength: 40,
+                default: "Octocat",
+              },
+              age: { type: "integer", title: "Age", minimum: 0, maximum: 130 },
+              colour: { type: "string", enum: ["Red", "Green", "Blue"], default: "Green" },
+              newsletter: { type: "boolean", title: "Newsletter", default: true },
+            },
+            required: ["name"],
+          } satisfies ElicitRequestFormParams["requestedSchema"]
+          const message = "Tell us about yourself"
+          // Modern servers cannot call elicitInput; they return input_required and the SDK client
+          // retries the call with inputResponses (basic/patterns/mrtr).
+          protocol.setRequestHandler("tools/call", async (request, ctx) => {
+            const responses = ctx.mcpReq.inputResponses
+            if (input.modern && !responses) {
+              return inputRequired({
+                inputRequests: { profile: inputRequired.elicit({ message, requestedSchema }) },
+              })
+            }
+            const result = input.modern
+              ? (() => {
+                  const response = inputResponse(responses, "profile")
+                  return response.kind === "elicit"
+                    ? { action: response.action, content: response.content }
+                    : { action: "cancel" }
+                })()
+              : await protocol.elicitInput({ mode: "form", message, requestedSchema })
+            return {
+              content: [{ type: "text", text: JSON.stringify(result) }],
+              structuredContent: result,
+            }
+          })
+        }
+        if (!input.emptyElicitation && !input.urlElicitation && !input.formElicitation) {
           protocol.setRequestHandler("tools/call", (request) => {
             state.toolCalls.push({
               name: request.params.name,
@@ -356,7 +404,10 @@ function resourceMcpLayer(
             } as Payload<typeof definition>
             overrides?.published?.push(event.type)
             if (event.type !== Form.Event.Created.type || !onFormCreated) return Effect.succeed(event)
-            return onFormCreated(Schema.decodeUnknownSync(Form.Event.Created.data)(data).form).pipe(Effect.as(event))
+            // Subscribers receive events after a JSON hop, where undefined-valued optional members drop.
+            // Roundtrip so this mock decodes the same shape a real subscriber sees.
+            const encoded = Schema.encodeUnknownSync(Form.Event.Created.data)(data as { readonly form: Form.Info })
+            return onFormCreated(Schema.decodeUnknownSync(Form.Event.Created.data)(encoded).form).pipe(Effect.as(event))
           },
         }),
         Layer.mock(Integration.Service, {
@@ -1443,6 +1494,112 @@ test("settles modern MCP URL elicitations when the user confirms", async () => {
   )
 })
 
+// Shared by the form elicitation tests below. The form service maps the requested schema onto these
+// fields, preserving titles, constraints, enum options, and defaults (`toElicitationField`).
+const profileFormFields: Form.Fields = [
+  {
+    key: "name",
+    title: "Full name",
+    description: "Your display name",
+    required: true,
+    type: "string",
+    minLength: 2,
+    maxLength: 40,
+    default: "Octocat",
+  },
+  { key: "age", title: "Age", type: "integer", minimum: 0, maximum: 130 },
+  {
+    key: "colour",
+    title: "colour",
+    type: "string",
+    default: "Green",
+    options: [
+      { value: "Red", label: "Red" },
+      { value: "Green", label: "Green" },
+      { value: "Blue", label: "Blue" },
+    ],
+    custom: false,
+  },
+  { key: "newsletter", title: "Newsletter", type: "boolean", default: true },
+]
+
+test("answers a modern MCP form elicitation through the multi-round-trip flow", async () => {
+  await Effect.runPromise(
+    Effect.scoped(
+      Effect.gen(function* () {
+        const server = yield* resourceServer({ modern: true, resources: false, formElicitation: true })
+        const created = yield* Deferred.make<Form.Info>()
+        const result = yield* Effect.gen(function* () {
+          const service = yield* Mcp.Service
+          const forms = yield* Form.Service
+          const call = yield* service
+            .callTool({ server: "resources", name: "form-elicitation" })
+            .pipe(Effect.forkScoped)
+
+          const form = yield* Deferred.await(created)
+          expect(form.metadata).toEqual({
+            kind: "mcp-elicitation",
+            server: "resources",
+            message: "Tell us about yourself",
+          })
+          expect(form.fields).toEqual(profileFormFields)
+
+          yield* forms.reply({
+            id: form.id,
+            answer: { name: "Mona", age: 30, colour: "Blue", newsletter: false },
+          })
+          return yield* Fiber.join(call)
+        }).pipe(
+          Effect.provide(
+            resourceMcpLayer(
+              new ConfigMCP.Remote({ type: "remote", url: server.url, oauth: false, protocol: "2026-07-28" }),
+              (form) => Deferred.succeed(created, form).pipe(Effect.asVoid),
+            ),
+          ),
+        )
+
+        expect(result.structured).toEqual({
+          action: "accept",
+          content: { name: "Mona", age: 30, colour: "Blue", newsletter: false },
+        })
+      }),
+    ),
+  )
+})
+
+test("answers a legacy MCP form elicitation with fields", async () => {
+  await Effect.runPromise(
+    Effect.scoped(
+      Effect.gen(function* () {
+        const server = yield* resourceServer({ resources: false, formElicitation: true })
+        const created = yield* Deferred.make<Form.Info>()
+        const result = yield* Effect.gen(function* () {
+          const service = yield* Mcp.Service
+          const forms = yield* Form.Service
+          const call = yield* service
+            .callTool({ server: "resources", name: "form-elicitation" })
+            .pipe(Effect.forkScoped)
+
+          const form = yield* Deferred.await(created)
+          expect(form.fields).toEqual(profileFormFields)
+          yield* forms.reply({
+            id: form.id,
+            answer: { name: "Mona", age: 30, colour: "Blue", newsletter: false },
+          })
+          return yield* Fiber.join(call)
+        }).pipe(
+          Effect.provide(resourceMcpLayer(server.url, (form) => Deferred.succeed(created, form).pipe(Effect.asVoid))),
+        )
+
+        expect(result.structured).toEqual({
+          action: "accept",
+          content: { name: "Mona", age: 30, colour: "Blue", newsletter: false },
+        })
+      }),
+    ),
+  )
+})
+
 test("loads and reads MCP resources", async () => {
   await Effect.runPromise(
     Effect.scoped(