// Repro for #1555: "Local HTTP MCP native elicitation times out before reaching
// client". The Cloudflare counterpart (cloudflare/mcp-native-elicitation.test.ts,
// green since #1522) proves the reverse request routes on the originating
// tools/call stream there. This is the same scenario against the LOCAL daemon's
// HTTP MCP endpoint, which the report says never delivers `elicitation/create`
// and fails with McpNativeElicitationTransportError / -32001 request timed out.
//
// Same shape as the local browser-approval scenario (a require_approval policy
// on a built-in read tool), but with `elicitation_mode=native` and a client that
// advertises `capabilities.elicitation.form` and answers the request in-band —
// so no browser is needed, only the raw SDK transport with the bearer.
import { expect } from "@effect/vitest";
import { Effect } from "effect";
import { HttpApiClient } from "effect/unstable/httpapi";
import { FetchHttpClient, HttpClient, HttpClientRequest } from "effect/unstable/http";
import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
import { ElicitRequestSchema } from "@modelcontextprotocol/sdk/types.js";
import { composePluginApi } from "@executor-js/api/server";

import { scenario } from "../src/scenario";
import { Cli, RunDir } from "../src/services";
import { withLocalServer } from "./local-server";

const coreApi = composePluginApi([] as const);

const GATED_TOOL = "executor.coreTools.policies.list";
const GATED_CODE = `
const result = await tools.executor.coreTools.policies.list({});
return JSON.stringify(result);
`;

scenario(
  "Local · native MCP elicitation carries approval decisions on the tool call stream",
  { timeout: 300_000 },
  Effect.gen(function* () {
    const cli = yield* Cli;
    const runDir = yield* RunDir;

    yield* withLocalServer(cli, runDir, (server) =>
      Effect.gen(function* () {
        // Bearer-authed typed API client (local's credential is the printed
        // token) — used only to plant the gating policy.
        const api = yield* HttpApiClient.make(coreApi, {
          baseUrl: new URL("/api", server.origin).toString(),
          transformClient: HttpClient.mapRequest((request) =>
            HttpClientRequest.setHeader(request, "authorization", `Bearer ${server.token}`),
          ),
        }).pipe(Effect.provide(FetchHttpClient.layer));

        const policy = yield* api.policies.create({
          payload: { owner: "org", pattern: GATED_TOOL, action: "require_approval" },
        });

        yield* Effect.gen(function* () {
          let decision: "accept" | "decline" | "cancel" = "accept";
          let elicitationCount = 0;
          const client = yield* Effect.acquireRelease(
            Effect.promise(async () => {
              const connectedClient = new Client(
                { name: "e2e-local-native-elicitation", version: "1.0.0" },
                { capabilities: { elicitation: { form: {}, url: {} } } },
              );
              connectedClient.setRequestHandler(ElicitRequestSchema, async () => {
                elicitationCount += 1;
                return decision === "accept"
                  ? { action: "accept" as const, content: {} }
                  : { action: decision };
              });
              const url = new URL(`${server.origin}/mcp`);
              url.searchParams.set("elicitation_mode", "native");
              url.searchParams.set("artifacts", "false");
              await connectedClient.connect(
                new StreamableHTTPClientTransport(url, {
                  requestInit: { headers: { authorization: `Bearer ${server.token}` } },
                }),
              );
              return connectedClient;
            }),
            (connectedClient) => Effect.promise(() => connectedClient.close()),
          );

          const accepted = yield* Effect.promise(() =>
            client.callTool({ name: "execute", arguments: { code: GATED_CODE } }, undefined, {
              timeout: 30_000,
            }),
          );
          expect(elicitationCount, "the native elicitation reached the client").toBe(1);
          expect(accepted.isError, "accepting lets the gated tool complete").toBeFalsy();
          expect(
            JSON.stringify(accepted.content),
            "the gated tool returned its policy listing",
          ).toContain(policy.id);

          decision = "decline";
          const declined = yield* Effect.promise(() =>
            client.callTool({ name: "execute", arguments: { code: GATED_CODE } }, undefined, {
              timeout: 30_000,
            }),
          );
          expect(elicitationCount, "the second native elicitation also reached the client").toBe(2);
          expect(declined.isError, "declining blocks the gated tool").toBe(true);
          expect(
            JSON.stringify(declined.content),
            "the engine reports the client's decline decision",
          ).toContain("declined by the user");
          expect(
            JSON.stringify(declined.content),
            "the declined tool did not return its output",
          ).not.toContain(policy.id);

          decision = "cancel";
          const cancelled = yield* Effect.promise(() =>
            client.callTool({ name: "execute", arguments: { code: GATED_CODE } }, undefined, {
              timeout: 30_000,
            }),
          );
          expect(elicitationCount, "the cancel elicitation also reached the client").toBe(3);
          expect(cancelled.isError, "cancelling blocks the gated tool").toBe(true);
          expect(
            JSON.stringify(cancelled.content),
            "the engine reports the client's cancel decision",
          ).toContain("cancelled by the user");
        }).pipe(Effect.scoped);
      }),
    );
  }),
);