import { MCPTool, MCPInput } from "mcp-framework";
import { z } from "zod";

const schema = z.object({
  task: z.string().describe("The task to perform"),
});

class SetupTool extends MCPTool {
  name = "setup";
  description = "Set up a new project with user preferences";
  schema = schema;

  async execute(input: MCPInput<this>) {
    // Ask the user for their details
    const result = await this.elicit("Please provide your project details", {
      name: { type: "string", description: "Project name", minLength: 1 },
      language: {
        type: "string",
        description: "Programming language",
        enum: ["typescript", "python", "go", "rust"],
      },
      enableTests: {
        type: "boolean",
        description: "Enable test scaffolding?",
        default: true,
      },
    });

    // Handle the three possible responses
    if (result.action === "accept") {
      return {
        project: result.content?.name,
        language: result.content?.language,
        tests: result.content?.enableTests,
      };
    }

    if (result.action === "decline") {
      return "User declined to provide project details";
    }

    // action === "cancel" — user dismissed the dialog
    return "Setup cancelled";
  }
}

export default SetupTool;

import { MCPTool, MCPInput } from "mcp-framework";
import { z } from "zod";

const schema = z.object({
  provider: z.string().describe("OAuth provider name"),
});

class ConnectServiceTool extends MCPTool {
  name = "connect_service";
  description = "Connect to a third-party service via OAuth";
  schema = schema;

  async execute(input: MCPInput<this>) {
    const elicitationId = `oauth-${input.provider}-${Date.now()}`;

    const result = await this.elicitUrl(
      `Please authorize access to your ${input.provider} account`,
      `https://${input.provider}.example.com/oauth/authorize?state=${elicitationId}`,
      elicitationId
    );

    if (result.action === "accept") {
      // User agreed to open the URL — authorization flow started
      return { status: "authorization_started", provider: input.provider };
    }

    return { status: "authorization_declined", provider: input.provider };
  }
}

export default ConnectServiceTool;

const result = await this.elicit("Enter details", { /* schema */ });

switch (result.action) {
  case "accept":
    // Use result.content
    return processData(result.content);
  case "decline":
    return "User declined. Proceeding without additional info.";
  case "cancel":
    return "Operation cancelled.";
}

await this.elicit("Contact info", {
  name: { type: "string", description: "Full name" },           // required
  email: { type: "string", description: "Email", format: "email" }, // required
  phone: { type: "string", description: "Phone", optional: true },  // optional
});

async execute(input: MCPInput<this>) {
  // Step 1: Collect basic info via form
  const basicInfo = await this.elicit("Enter basic info", {
    name: { type: "string", description: "Project name" },
    type: {
      type: "string",
      description: "Project type",
      enum: ["web", "api", "cli"],
    },
  });

  if (basicInfo.action !== "accept") {
    return "Setup cancelled at step 1";
  }

  // Step 2: Connect external service via URL
  const auth = await this.elicitUrl(
    "Connect your GitHub account to import settings",
    "https://github.example.com/oauth/authorize",
    `github-auth-${Date.now()}`
  );

  if (auth.action !== "accept") {
    return { name: basicInfo.content?.name, github: false };
  }

  // Step 3: Final confirmation
  const confirm = await this.elicit("Confirm setup", {
    proceed: {
      type: "boolean",
      description: `Create project "${basicInfo.content?.name}"?`,
      default: true,
    },
  });

  if (confirm.action === "accept" && confirm.content?.proceed) {
    return {
      created: true,
      name: basicInfo.content?.name,
      type: basicInfo.content?.type,
      github: true,
    };
  }

  return "Setup cancelled at confirmation step";
}

async execute(input: MCPInput<this>) {
  try {
    const result = await this.elicit("Enter your name", {
      name: { type: "string", description: "Name" },
    });
    return `Hello, ${result.content?.name}!`;
  } catch (error) {
    // Client doesn't support elicitation — fall back
    return `Hello! (Tip: use a client that supports elicitation for a better experience)`;
  }
}