pi-soly 1.9.3 → 1.11.0

package/mcp/__tests__/elicitation-handler.upstream-test.ts

@@ -0,0 +1,346 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import type { ElicitRequest } from "@modelcontextprotocol/sdk/types.js";
+
+const mocks = vi.hoisted(() => ({
+  open: vi.fn(async () => undefined),
+}));
+
+vi.mock("open", () => ({ default: mocks.open }));
+
+function request(params: ElicitRequest["params"]): ElicitRequest {
+  return { method: "elicitation/create", params } as ElicitRequest;
+}
+
+describe("MCP elicitation", () => {
+  beforeEach(() => {
+    mocks.open.mockReset();
+    mocks.open.mockResolvedValue(undefined);
+  });
+
+  it("collects a form with stock Pi dialogs and lets the user review it before sending", async () => {
+    const { handleElicitationRequest } = await import("../elicitation-handler.ts");
+    const ui = {
+      select: vi.fn()
+        .mockResolvedValueOnce("Continue")
+        .mockResolvedValueOnce("Enter value")
+        .mockResolvedValueOnce("Submit"),
+      input: vi.fn().mockResolvedValueOnce("octocat"),
+      notify: vi.fn(),
+    };
+
+    const result = await handleElicitationRequest(
+      { serverName: "github", ui: ui as any, allowUrl: true },
+      request({
+        mode: "form",
+        message: "Please provide your GitHub username",
+        requestedSchema: {
+          type: "object",
+          properties: {
+            username: { type: "string", title: "GitHub username", minLength: 1 },
+          },
+          required: ["username"],
+        },
+      }),
+    );
+
+    expect(ui.select.mock.calls[0]).toEqual([
+      "MCP Input Request\nServer: github\n\nPlease provide your GitHub username",
+      ["Continue", "Decline"],
+    ]);
+    expect(ui.input).toHaveBeenCalledWith("GitHub username (required)", undefined);
+    expect(ui.select.mock.calls[2][0]).toContain("GitHub username: octocat");
+    expect(result).toEqual({ action: "accept", content: { username: "octocat" } });
+  });
+
+  it("lets the user edit a value from the review screen", async () => {
+    const { handleElicitationRequest } = await import("../elicitation-handler.ts");
+    const ui = {
+      select: vi.fn()
+        .mockResolvedValueOnce("Continue")
+        .mockResolvedValueOnce("Enter value")
+        .mockResolvedValueOnce("Edit")
+        .mockResolvedValueOnce("Name (name)")
+        .mockResolvedValueOnce("Enter value")
+        .mockResolvedValueOnce("Submit"),
+      input: vi.fn().mockResolvedValueOnce("Old").mockResolvedValueOnce("New"),
+      notify: vi.fn(),
+    };
+
+    const result = await handleElicitationRequest(
+      { serverName: "demo", ui: ui as any, allowUrl: true },
+      request({
+        mode: "form",
+        message: "Choose a name",
+        requestedSchema: {
+          type: "object",
+          properties: { name: { type: "string", title: "Name" } },
+        },
+      }),
+    );
+
+    expect(ui.input.mock.calls[1]).toEqual(["Name", "Old"]);
+    expect(result).toEqual({ action: "accept", content: { name: "New" } });
+  });
+
+  it("validates form values and lets the user correct invalid input", async () => {
+    const { handleElicitationRequest } = await import("../elicitation-handler.ts");
+    const ui = {
+      select: vi.fn()
+        .mockResolvedValueOnce("Continue")
+        .mockResolvedValueOnce("Enter value")
+        .mockResolvedValueOnce("Enter value")
+        .mockResolvedValueOnce("Submit"),
+      input: vi.fn()
+        .mockResolvedValueOnce("not-an-email")
+        .mockResolvedValueOnce("octocat@example.com"),
+      notify: vi.fn(),
+    };
+
+    const result = await handleElicitationRequest(
+      { serverName: "demo", ui: ui as any, allowUrl: true },
+      request({
+        mode: "form",
+        message: "Contact details",
+        requestedSchema: {
+          type: "object",
+          properties: {
+            email: { type: "string", format: "email" },
+          },
+          required: ["email"],
+        },
+      }),
+    );
+
+    expect(ui.notify).toHaveBeenCalledWith(expect.stringContaining("email"), "error");
+    expect(result).toEqual({ action: "accept", content: { email: "octocat@example.com" } });
+  });
+
+  it.each([
+    ["number", false],
+    ["number", true],
+    ["integer", false],
+    ["integer", true],
+  ] as const)("rejects blank %s input and reprompts when required=%s", async (type, required) => {
+    const { handleElicitationRequest } = await import("../elicitation-handler.ts");
+    const ui = {
+      select: vi.fn()
+        .mockResolvedValueOnce("Continue")
+        .mockResolvedValueOnce("Enter value")
+        .mockResolvedValueOnce("Enter value")
+        .mockResolvedValueOnce("Submit"),
+      input: vi.fn().mockResolvedValueOnce("   ").mockResolvedValueOnce("7"),
+      notify: vi.fn(),
+    };
+
+    const result = await handleElicitationRequest(
+      { serverName: "demo", ui: ui as any, allowUrl: false },
+      request({
+        mode: "form",
+        message: "Choose a quantity",
+        requestedSchema: {
+          type: "object",
+          properties: { quantity: { type } },
+          ...(required ? { required: ["quantity"] } : {}),
+        },
+      }),
+    );
+
+    expect(ui.notify).toHaveBeenCalledWith("Elicitation field quantity must be a number", "error");
+    expect(ui.input).toHaveBeenCalledTimes(2);
+    expect(result).toEqual({ action: "accept", content: { quantity: 7 } });
+  });
+
+  it("maps explicit refusal and dialog dismissal to decline and cancel", async () => {
+    const { handleElicitationRequest } = await import("../elicitation-handler.ts");
+    const params = request({
+      mode: "form",
+      message: "Provide a value",
+      requestedSchema: { type: "object", properties: {} },
+    });
+
+    await expect(handleElicitationRequest({
+      serverName: "demo",
+      ui: { select: vi.fn().mockResolvedValue("Decline") } as any,
+      allowUrl: true,
+    }, params)).resolves.toEqual({ action: "decline" });
+    await expect(handleElicitationRequest({
+      serverName: "demo",
+      ui: { select: vi.fn().mockResolvedValue(undefined) } as any,
+      allowUrl: true,
+    }, params)).resolves.toEqual({ action: "cancel" });
+  });
+
+  it("does not open URL elicitations that are declined or dismissed", async () => {
+    const { handleElicitationRequest } = await import("../elicitation-handler.ts");
+    const params = request({
+      mode: "url",
+      message: "Authorize",
+      elicitationId: "auth-1",
+      url: "https://example.com/authorize",
+    });
+
+    await expect(handleElicitationRequest({
+      serverName: "demo",
+      ui: { select: vi.fn().mockResolvedValue("Decline") } as any,
+      allowUrl: true,
+    }, params)).resolves.toEqual({ action: "decline" });
+    await expect(handleElicitationRequest({
+      serverName: "demo",
+      ui: { select: vi.fn().mockResolvedValue(undefined) } as any,
+      allowUrl: true,
+    }, params)).resolves.toEqual({ action: "cancel" });
+    expect(mocks.open).not.toHaveBeenCalled();
+  });
+
+  it("shows the server, host, and full URL before opening an accepted URL elicitation", async () => {
+    const { handleElicitationRequest } = await import("../elicitation-handler.ts");
+    const onUrlAccepted = vi.fn();
+    const ui = {
+      select: vi.fn().mockResolvedValueOnce("Open"),
+      input: vi.fn(),
+      notify: vi.fn(),
+    };
+    const url = "https://checkout.example.com/authorize?state=a%2Fb";
+
+    const result = await handleElicitationRequest(
+      { serverName: "payments", ui: ui as any, allowUrl: true, onUrlAccepted },
+      request({
+        mode: "url",
+        message: "Authorize the payment provider",
+        elicitationId: "payment-1",
+        url,
+      }),
+    );
+
+    expect(ui.select).toHaveBeenCalledWith([
+      "MCP Browser Request",
+      "Server: payments",
+      "",
+      "Authorize the payment provider",
+      "",
+      "Host: checkout.example.com",
+      `Full URL: ${url}`,
+      "",
+      "Open this URL in your browser?",
+    ].join("\n"), ["Open", "Decline"]);
+    expect(mocks.open).toHaveBeenCalledWith(url);
+    expect(onUrlAccepted).toHaveBeenCalledWith("payment-1");
+    expect(result).toEqual({ action: "accept" });
+  });
+
+  it("rejects URL mode when the client advertised form-only support", async () => {
+    const { handleElicitationRequest } = await import("../elicitation-handler.ts");
+    const ui = { select: vi.fn(), input: vi.fn(), notify: vi.fn() };
+
+    await expect(handleElicitationRequest(
+      { serverName: "demo", ui: ui as any, allowUrl: false },
+      request({
+        mode: "url",
+        message: "Authorize",
+        elicitationId: "auth-1",
+        url: "https://example.com/authorize",
+      }),
+    )).rejects.toMatchObject({ code: -32602 });
+    expect(ui.select).not.toHaveBeenCalled();
+  });
+
+  it("rejects URL schemes that cannot be opened safely in a browser", async () => {
+    const { handleElicitationRequest } = await import("../elicitation-handler.ts");
+    const ui = { select: vi.fn(), input: vi.fn(), notify: vi.fn() };
+
+    await expect(handleElicitationRequest(
+      { serverName: "demo", ui: ui as any, allowUrl: true },
+      request({
+        mode: "url",
+        message: "Open a file",
+        elicitationId: "file-1",
+        url: "file:///etc/passwd",
+      }),
+    )).rejects.toMatchObject({ code: -32602 });
+    expect(ui.select).not.toHaveBeenCalled();
+    expect(mocks.open).not.toHaveBeenCalled();
+  });
+
+  it("cancels URL elicitation when the browser cannot be opened", async () => {
+    const { handleElicitationRequest } = await import("../elicitation-handler.ts");
+    mocks.open.mockRejectedValueOnce(new Error("no browser"));
+    const ui = {
+      select: vi.fn().mockResolvedValueOnce("Open"),
+      input: vi.fn(),
+      notify: vi.fn(),
+    };
+
+    const result = await handleElicitationRequest(
+      { serverName: "demo", ui: ui as any, allowUrl: true },
+      request({
+        mode: "url",
+        message: "Authorize",
+        elicitationId: "auth-1",
+        url: "https://example.com/authorize",
+      }),
+    );
+
+    expect(result).toEqual({ action: "cancel" });
+    expect(ui.notify).toHaveBeenCalledWith(expect.stringContaining("no browser"), "error");
+  });
+
+  it("supports every primitive form field, defaults, and omission", async () => {
+    const { handleElicitationRequest } = await import("../elicitation-handler.ts");
+    const ui = {
+      select: vi.fn()
+        .mockResolvedValueOnce("Continue")
+        .mockResolvedValueOnce("Use default")
+        .mockResolvedValueOnce("Medium (medium)")
+        .mockResolvedValueOnce("No")
+        .mockResolvedValueOnce("Enter value")
+        .mockResolvedValueOnce("Choose values")
+        .mockResolvedValueOnce("Red")
+        .mockResolvedValueOnce("Done")
+        .mockResolvedValueOnce("Omit")
+        .mockResolvedValueOnce("Submit"),
+      input: vi.fn().mockResolvedValueOnce("42"),
+      notify: vi.fn(),
+    };
+
+    const result = await handleElicitationRequest(
+      { serverName: "demo", ui: ui as any, allowUrl: true },
+      request({
+        mode: "form",
+        message: "Configure the operation",
+        requestedSchema: {
+          type: "object",
+          properties: {
+            title: { type: "string", default: "Untitled" },
+            priority: {
+              type: "string",
+              oneOf: [
+                { const: "low", title: "Low" },
+                { const: "medium", title: "Medium" },
+              ],
+            },
+            enabled: { type: "boolean" },
+            count: { type: "integer", minimum: 1, maximum: 100 },
+            colors: {
+              type: "array",
+              items: { type: "string", enum: ["Red", "Blue"] },
+              minItems: 1,
+            },
+            note: { type: "string" },
+          },
+          required: ["priority", "enabled", "count", "colors"],
+        },
+      }),
+    );
+
+    expect(result).toEqual({
+      action: "accept",
+      content: {
+        title: "Untitled",
+        priority: "medium",
+        enabled: false,
+        count: 42,
+        colors: ["Red"],
+      },
+    });
+  });
+});

package/mcp/__tests__/elicitation-sdk-integration.upstream-test.ts

@@ -0,0 +1,140 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { fileURLToPath } from "node:url";
+import type { ExtensionMode, ExtensionUIContext } from "@earendil-works/pi-coding-agent";
+import { createDirectToolExecutor } from "../direct-tools.ts";
+import { isTuiMode } from "../init.ts";
+import { executeCall } from "../proxy-modes.ts";
+import { McpServerManager } from "../server-manager.ts";
+import type { McpExtensionState } from "../state.ts";
+import type { DirectToolSpec, ToolMetadata } from "../types.ts";
+import { UiResourceHandler } from "../ui-resource-handler.ts";
+
+const mocks = vi.hoisted(() => ({ open: vi.fn(async () => undefined) }));
+vi.mock("open", () => ({ default: mocks.open }));
+
+const fixture = fileURLToPath(new URL("./fixtures/elicitation-server.mjs", import.meta.url));
+const definition = { command: process.execPath, args: [fixture] };
+const managers: McpServerManager[] = [];
+
+function createUi(answers: string[] = []): ExtensionUIContext {
+  return {
+    select: vi.fn(async () => answers.shift()),
+    input: vi.fn(async () => "stock-pi-user"),
+    notify: vi.fn(),
+  } as unknown as ExtensionUIContext;
+}
+
+async function createConnectedManager(mode: ExtensionMode, answers: string[] = []) {
+  const ui = createUi(answers);
+  const manager = new McpServerManager();
+  manager.setElicitationConfig({
+    ui,
+    allowUrl: isTuiMode({ hasUI: true, mode }),
+  });
+  await manager.connect("real", definition);
+  managers.push(manager);
+  return { manager, ui };
+}
+
+function createState(manager: McpServerManager, metadata: ToolMetadata[]): McpExtensionState {
+  return {
+    manager,
+    config: { settings: {}, mcpServers: { real: definition } },
+    toolMetadata: new Map([["real", metadata]]),
+    failureTracker: new Map(),
+    uiResourceHandler: new UiResourceHandler(manager),
+    completedUiSessions: [],
+    uiServer: null,
+  } as McpExtensionState;
+}
+
+function resultText(result: { content?: Array<{ type: string; text?: string }> }): string {
+  return result.content?.find(item => item.type === "text")?.text ?? "";
+}
+
+describe("elicitation with the real MCP SDK", () => {
+  beforeEach(() => mocks.open.mockClear());
+
+  afterEach(async () => {
+    await Promise.all(managers.splice(0).map(manager => manager.closeAll()));
+  });
+
+  it.each([
+    ["tui", { form: {}, url: {} }],
+    ["rpc", { form: {} }],
+  ] as const)("advertises stock Pi %s capabilities and completes form elicitation", async (mode, capabilities) => {
+    const { manager } = await createConnectedManager(mode, ["Continue", "Enter value", "Submit"]);
+    const connection = manager.getConnection("real")!;
+
+    const capabilityResult = await connection.client.callTool({ name: "capabilities", arguments: {} });
+    expect(JSON.parse(resultText(capabilityResult))).toEqual(capabilities);
+
+    const formResult = await connection.client.callTool({ name: "form", arguments: {} });
+    expect(JSON.parse(resultText(formResult))).toEqual({
+      action: "accept",
+      content: { name: "stock-pi-user" },
+    });
+  });
+
+  it("rejects URL elicitation over real SDK dispatch in stock Pi RPC mode", async () => {
+    const { manager } = await createConnectedManager("rpc");
+    const connection = manager.getConnection("real")!;
+
+    await expect(connection.client.callTool({ name: "url", arguments: {} })).rejects.toThrow(
+      /does not support URL-mode elicitation requests/,
+    );
+    expect(mocks.open).not.toHaveBeenCalled();
+  });
+
+  it("dispatches URL elicitation and its completion notification over the real SDK", async () => {
+    const { manager, ui } = await createConnectedManager("tui", ["Open"]);
+    const connection = manager.getConnection("real")!;
+
+    const result = await connection.client.callTool({ name: "url", arguments: {} });
+
+    expect(JSON.parse(resultText(result))).toEqual({ action: "accept" });
+    expect(mocks.open).toHaveBeenCalledWith("https://example.com/authorize");
+    expect(ui.notify).toHaveBeenCalledWith(
+      "MCP browser interaction for real completed. You can retry the tool now.",
+      "info",
+    );
+    expect(ui.notify).toHaveBeenCalledTimes(2);
+  });
+
+  it.each([
+    ["proxy tool", { originalName: "url-required" }, "proxy"],
+    ["direct tool", { originalName: "url-required" }, "direct"],
+    ["proxy resource", { originalName: "resource", resourceUri: "test://url-required" }, "proxy"],
+    ["direct resource", { originalName: "resource", resourceUri: "test://url-required" }, "direct"],
+    ["proxy UI resource", { originalName: "app", uiResourceUri: "ui://url-required" }, "proxy"],
+    ["direct UI resource", { originalName: "app", uiResourceUri: "ui://url-required" }, "direct"],
+  ] as const)("handles real -32042 errors from a %s", async (_label, spec, adapter) => {
+    const { manager } = await createConnectedManager("tui", ["Open"]);
+    const metadata: ToolMetadata = {
+      name: `real_${spec.originalName}`,
+      description: "integration test",
+      ...spec,
+    };
+    const state = createState(manager, [metadata]);
+
+    const result = adapter === "proxy"
+      ? await executeCall(state, metadata.name, {}, "real")
+      : await createDirectToolExecutor(
+          () => state,
+          () => null,
+          {
+            serverName: "real",
+            prefixedName: metadata.name,
+            description: metadata.description,
+            ...spec,
+          } as DirectToolSpec,
+        )("id", {});
+
+    expect(result.details).toMatchObject({ error: "url_elicitation_required", action: "accept" });
+    expect(result.content[0]).toMatchObject({
+      type: "text",
+      text: expect.stringContaining("retry the tool"),
+    });
+    expect(mocks.open).toHaveBeenCalledWith("https://example.com/connect");
+  });
+});