[MCP] Adds support for prompts. (#8965)

- Adds support for prompts in MCP server
- Adds `deploy` prompt

Author: mbleigh

CHANGELOG.md

@@ -5,3 +5,4 @@
 - [Added] Support for creating Firestore Enterprise databases using `firestore:databases:create --edition enterprise`. (#8952)
 - [Added] Support for Firestore Enterprise database index configurations. (#8939)
 - [fixed] MCP: The `get_sdk_config` tool now properly returns decoded file content for Android and iOS.
+- [added] MCP: prompts are now supported with a `deploy` prompt as the first available.

src/mcp/index.ts

@@ -8,11 +8,18 @@ import {
   SetLevelRequestSchema,
   ListToolsRequestSchema,
   CallToolResult,
+  ListPromptsRequestSchema,
+  GetPromptRequestSchema,
+  ListPromptsResult,
+  GetPromptResult,
+  GetPromptRequest,
 } from "@modelcontextprotocol/sdk/types.js";
 import { checkFeatureActive, mcpError } from "./util";
 import { ClientConfig, SERVER_FEATURES, ServerFeature } from "./types";
 import { availableTools } from "./tools/index";
 import { ServerTool, ServerToolContext } from "./tool";
+import { availablePrompts } from "./prompts/index";
+import { ServerPrompt, ServerPromptContext } from "./prompt";
 import { configstore } from "../configstore";
 import { Command } from "../command";
 import { requireAuth } from "../requireAuth";
@@ -31,7 +38,7 @@ import { LoggingStdioServerTransport } from "./logging-transport";
 import { isFirebaseStudio } from "../env";
 import { timeoutFallback } from "../timeout";
 
-const SERVER_VERSION = "0.2.0";
+const SERVER_VERSION = "0.3.0";
 
 const cmd = new Command("experimental:mcp");
 
@@ -86,9 +93,17 @@ export class FirebaseMcpServer {
     this.activeFeatures = options.activeFeatures;
     this.startupRoot = options.projectRoot || process.env.PROJECT_ROOT;
     this.server = new Server({ name: "firebase", version: SERVER_VERSION });
-    this.server.registerCapabilities({ tools: { listChanged: true }, logging: {} });
+    this.server.registerCapabilities({
+      tools: { listChanged: true },
+      logging: {},
+      prompts: { listChanged: true },
+    });
+
     this.server.setRequestHandler(ListToolsRequestSchema, this.mcpListTools.bind(this));
     this.server.setRequestHandler(CallToolRequestSchema, this.mcpCallTool.bind(this));
+    this.server.setRequestHandler(ListPromptsRequestSchema, this.mcpListPrompts.bind(this));
+    this.server.setRequestHandler(GetPromptRequestSchema, this.mcpGetPrompt.bind(this));
+
     this.server.oninitialized = async () => {
       const clientInfo = this.server.getClientVersion();
       this.clientInfo = clientInfo;
@@ -211,11 +226,22 @@ export class FirebaseMcpServer {
     return this.availableTools.find((t) => t.mcp.name === name) || null;
   }
 
+  get availablePrompts(): ServerPrompt[] {
+    return availablePrompts(
+      this.activeFeatures?.length ? this.activeFeatures : this.detectedFeatures,
+    );
+  }
+
+  getPrompt(name: string): ServerPrompt | null {
+    return this.availablePrompts.find((p) => p.mcp.name === name) || null;
+  }
+
   setProjectRoot(newRoot: string | null): void {
     this.updateStoredClientConfig({ projectRoot: newRoot });
     this.cachedProjectRoot = newRoot || undefined;
     this.detectedFeatures = undefined; // reset detected features
     void this.server.sendToolListChanged();
+    void this.server.sendPromptListChanged();
   }
 
   async resolveOptions(): Promise<Partial<Options>> {
@@ -271,7 +297,9 @@ export class FirebaseMcpServer {
       (!this.cachedProjectRoot || !existsSync(this.cachedProjectRoot))
     ) {
       return mcpError(
-        `The current project directory '${this.cachedProjectRoot || "<NO PROJECT DIRECTORY FOUND>"}' does not exist. Please use the 'update_firebase_environment' tool to target a different project directory.`,
+        `The current project directory '${
+          this.cachedProjectRoot || "<NO PROJECT DIRECTORY FOUND>"
+        }' does not exist. Please use the 'update_firebase_environment' tool to target a different project directory.`,
       );
     }
 
@@ -324,6 +352,70 @@ export class FirebaseMcpServer {
     }
   }
 
+  async mcpListPrompts(): Promise<ListPromptsResult> {
+    await Promise.all([this.detectActiveFeatures(), this.detectProjectRoot()]);
+    const hasActiveProject = !!(await this.getProjectId());
+    await this.trackGA4("mcp_list_prompts");
+    const skipAutoAuthForStudio = isFirebaseStudio();
+    return {
+      prompts: this.availablePrompts.map((p) => ({
+        name: p.mcp.name,
+        description: p.mcp.description,
+        annotations: p.mcp.annotations,
+        inputSchema: p.mcp.inputSchema,
+      })),
+      _meta: {
+        projectRoot: this.cachedProjectRoot,
+        projectDetected: hasActiveProject,
+        authenticatedUser: await this.getAuthenticatedUser(skipAutoAuthForStudio),
+        activeFeatures: this.activeFeatures,
+        detectedFeatures: this.detectedFeatures,
+      },
+    };
+  }
+
+  async mcpGetPrompt(req: GetPromptRequest): Promise<GetPromptResult> {
+    await this.detectProjectRoot();
+    const promptName = req.params.name;
+    const promptArgs = req.params.arguments;
+    const prompt = this.getPrompt(promptName);
+    if (!prompt) {
+      throw new Error(`Prompt '${promptName}' could not be found.`);
+    }
+
+    let projectId = await this.getProjectId();
+    projectId = projectId || "";
+
+    const skipAutoAuthForStudio = isFirebaseStudio();
+    const accountEmail = await this.getAuthenticatedUser(skipAutoAuthForStudio);
+
+    const options = { projectDir: this.cachedProjectRoot, cwd: this.cachedProjectRoot };
+    const promptsCtx: ServerPromptContext = {
+      projectId: projectId,
+      host: this,
+      config: Config.load(options, true) || new Config({}, options),
+      rc: loadRC(options),
+      accountEmail,
+    };
+
+    try {
+      const messages = await prompt.fn(promptArgs, promptsCtx);
+      await this.trackGA4("mcp_get_prompt", {
+        tool_name: promptName,
+      });
+      return {
+        messages,
+      };
+    } catch (err: unknown) {
+      await this.trackGA4("mcp_get_prompt", {
+        tool_name: promptName,
+        error: 1,
+      });
+      // TODO: should we return mcpError here?
+      throw err;
+    }
+  }
+
   async start(): Promise<void> {
     const transport = process.env.FIREBASE_MCP_DEBUG_LOG
       ? new LoggingStdioServerTransport(process.env.FIREBASE_MCP_DEBUG_LOG)

src/mcp/prompt.ts

@@ -0,0 +1,46 @@
+import { PromptMessage } from "@modelcontextprotocol/sdk/types.js";
+import { z, ZodTypeAny } from "zod";
+import { zodToJsonSchema } from "zod-to-json-schema";
+import type { FirebaseMcpServer } from "./index";
+import type { Config } from "../config";
+import { RC } from "../rc";
+import { cleanSchema } from "./util";
+
+export interface ServerPromptContext {
+  projectId: string;
+  accountEmail: string | null;
+  config: Config;
+  host: FirebaseMcpServer;
+  rc: RC;
+}
+
+export interface ServerPrompt<InputSchema extends ZodTypeAny = ZodTypeAny> {
+  mcp: {
+    name: string;
+    description?: string;
+    inputSchema: any;
+    omitPrefix?: boolean;
+    annotations?: {
+      title?: string;
+    };
+    _meta?: {
+      /** Prompts are grouped by feature. --only can configure what prompts is available. */
+      feature?: string;
+    };
+  };
+  fn: (input: z.infer<InputSchema>, ctx: ServerPromptContext) => Promise<PromptMessage[]>;
+}
+
+export function prompt<InputSchema extends ZodTypeAny>(
+  options: Omit<ServerPrompt<InputSchema>["mcp"], "inputSchema" | "name"> & {
+    name: string;
+    inputSchema: InputSchema;
+    omitPrefix?: boolean;
+  },
+  fn: ServerPrompt<InputSchema>["fn"],
+): ServerPrompt {
+  return {
+    mcp: { ...options, inputSchema: cleanSchema(zodToJsonSchema(options.inputSchema)) },
+    fn,
+  };
+}

src/mcp/prompts/core/deploy.ts

@@ -0,0 +1,59 @@
+import { z } from "zod";
+import { prompt } from "../../prompt";
+
+export const deploy = prompt(
+  {
+    name: "deploy",
+    omitPrefix: true,
+    description: "Use this command to deploy resources to Firebase.",
+    inputSchema: z.object({
+      prompt: z
+        .string()
+        .describe("any specific instructions you wish to provide about deploying")
+        .optional(),
+    }),
+    annotations: {
+      title: "Deploy to Firebase",
+    },
+  },
+  async ({ prompt }, { config, projectId, accountEmail }) => {
+    return [
+      {
+        role: "user" as const,
+        content: {
+          type: "text",
+          text: `
+Your goal is to deploy resources from the current project to Firebase.
+
+Active user: ${accountEmail || "<NONE>"}
+Active project: ${projectId || "<NONE>"}
+
+Contents of \`firebase.json\` config file:
+
+\`\`\`json
+${config.readProjectFile("firebase.json", { fallback: "<FILE DOES NOT EXIST>" })}
+\`\`\`
+
+## User Instructions
+
+${prompt || "<the user didn't supply specific instructions>"}
+
+## Steps
+
+Follow the steps below taking note of any user instructions provided above.
+
+1. If there is no active user, prompt the user to run \`firebase login\` in an interactive terminal before continuing.
+2. If there is no \`firebase.json\` file and the current workspace is a static web application, manually create a \`firebase.json\` with \`"hosting"\` configuration based on the current directory's web app configuration. Add a \`{"hosting": {"predeploy": "<build_script>"}}\` config to build before deploying.
+3. If there is no active project, ask the user if they want to use an existing project or create a new one.
+  3a. If create a new one, use the \`firebase_create_project\` tool.
+  3b. If they want to use an existing one, ask them for a project id (the \`firebase_list_projects\` tool may be helpful).
+4. Only after making sure Firebase has been initialized, run the \`firebase deploy\` shell command to perform the deploy. This may take a few minutes.
+5. If the deploy has errors, attempt to fix them and ask the user clarifying questions as needed.
+6. If the deploy needs \`--force\` to run successfully, ALWAYS prompt the user before running \`firebase deploy --force\`.
+7. If only one specific feature is failing, use command \`firebase deploy --only <feature>\` as you debug.
+`.trim(),
+        },
+      },
+    ];
+  },
+);

src/mcp/prompts/core/index.ts

@@ -0,0 +1,3 @@
+import { deploy } from "./deploy";
+
+export const corePrompts = [deploy];

src/mcp/prompts/index.ts

@@ -0,0 +1,49 @@
+import { ServerFeature } from "../types";
+import { ServerPrompt } from "../prompt";
+import { corePrompts } from "./core";
+
+const prompts: Record<ServerFeature, ServerPrompt[]> = {
+  core: corePrompts,
+  firestore: [],
+  storage: [],
+  dataconnect: [],
+  auth: [],
+  messaging: [],
+  remoteconfig: [],
+  crashlytics: [],
+  apphosting: [],
+  database: [],
+};
+
+function namespacePrompts(
+  promptsToNamespace: ServerPrompt[],
+  feature: ServerFeature,
+): ServerPrompt[] {
+  return promptsToNamespace.map((p) => {
+    const newPrompt = { ...p };
+    newPrompt.mcp = { ...p.mcp };
+    if (newPrompt.mcp.omitPrefix) {
+      // name is as-is
+    } else if (feature === "core") {
+      newPrompt.mcp.name = `firebase:${p.mcp.name}`;
+    } else {
+      newPrompt.mcp.name = `firebase:${feature}:${p.mcp.name}`;
+    }
+    newPrompt.mcp._meta = { ...p.mcp._meta, feature };
+    return newPrompt;
+  });
+}
+
+export function availablePrompts(features?: ServerFeature[]): ServerPrompt[] {
+  const allPrompts: ServerPrompt[] = namespacePrompts(prompts["core"], "core");
+  if (!features) {
+    features = Object.keys(prompts).filter((f) => f !== "core") as ServerFeature[];
+  }
+
+  for (const feature of features) {
+    if (prompts[feature] && feature !== "core") {
+      allPrompts.push(...namespacePrompts(prompts[feature], feature));
+    }
+  }
+  return allPrompts;
+}

src/mcp/tools/index.ts

@@ -13,8 +13,7 @@ import { realtimeDatabaseTools } from "./database/index";
 
 /** availableTools returns the list of MCP tools available given the server flags */
 export function availableTools(activeFeatures?: ServerFeature[]): ServerTool[] {
-  // Core tools are always present.
-  const toolDefs: ServerTool[] = addFeaturePrefix("firebase", coreTools);
+  const toolDefs: ServerTool[] = [];
   if (!activeFeatures?.length) {
     activeFeatures = Object.keys(tools) as ServerFeature[];
   }
@@ -25,6 +24,7 @@ export function availableTools(activeFeatures?: ServerFeature[]): ServerTool[] {
 }
 
 const tools: Record<ServerFeature, ServerTool[]> = {
+  core: addFeaturePrefix("firebase", coreTools),
   firestore: addFeaturePrefix("firestore", firestoreTools),
   auth: addFeaturePrefix("auth", authTools),
   dataconnect: addFeaturePrefix("dataconnect", dataconnectTools),

src/mcp/types.ts

@@ -1,4 +1,5 @@
 export const SERVER_FEATURES = [
+  "core",
   "firestore",
   "storage",
   "dataconnect",

src/mcp/util.ts

@@ -87,6 +87,7 @@ export function commandExistsSync(command: string): boolean {
 }
 
 const SERVER_FEATURE_APIS: Record<ServerFeature, string> = {
+  core: "",
   firestore: firestoreOrigin(),
   storage: storageOrigin(),
   dataconnect: dataconnectOrigin(),

src/track.ts

@@ -24,7 +24,9 @@ type cliEventNames =
   | "function_deploy_group"
   | "mcp_tool_call"
   | "mcp_list_tools"
-  | "mcp_client_connected";
+  | "mcp_client_connected"
+  | "mcp_list_prompts"
+  | "mcp_get_prompt";
 type GA4Property = "cli" | "emulator" | "vscode";
 interface GA4Info {
   measurementId: string;