feat(mcp): Adds MCP resources and a read_resources tool. (#9149)

- Adds `/firebase:init` prompt with placeholder guidance.
- Resources are defined in `src/mcp/resources`.
- Prompts and other output can "link" to resources by saying to use the `read_resources` tool with a particular URI.
- Consolidates context into a single McpContext type.
- Some additional refactoring and cleanup.

Author: mbleigh

.eslintrc.js

@@ -110,7 +110,7 @@ module.exports = {
       rules: {},
     },
     {
-      files: ["src/mcp/tools/**/*.ts", "src/mcp/prompts/**/*.ts"],
+      files: ["src/mcp/tools/**/*.ts", "src/mcp/prompts/**/*.ts", "src/mcp/resources/**/*.ts"],
       rules: { camelcase: "off" },
     },
   ],

src/config.ts

@@ -212,7 +212,7 @@ export class Config {
     return outPath;
   }
 
-  readProjectFile(p: string, options: any = {}) {
+  readProjectFile(p: string, options: { json?: boolean; fallback?: any } = {}) {
     options = options || {};
     try {
       const content = fs.readFileSync(this.path(p), "utf8");

src/mcp/index.ts

@@ -13,13 +13,20 @@ import {
   ListPromptsResult,
   GetPromptResult,
   GetPromptRequest,
+  ListResourcesRequestSchema,
+  ListResourcesResult,
+  ReadResourceRequest,
+  ReadResourceResult,
+  McpError,
+  ErrorCode,
+  ReadResourceRequestSchema,
 } from "@modelcontextprotocol/sdk/types.js";
 import { checkFeatureActive, mcpError } from "./util";
-import { ClientConfig, SERVER_FEATURES, ServerFeature } from "./types";
+import { ClientConfig, McpContext, SERVER_FEATURES, ServerFeature } from "./types";
 import { availableTools } from "./tools/index";
-import { ServerTool, ServerToolContext } from "./tool";
+import { ServerTool } from "./tool";
 import { availablePrompts } from "./prompts/index";
-import { ServerPrompt, ServerPromptContext } from "./prompt";
+import { ServerPrompt } from "./prompt";
 import { configstore } from "../configstore";
 import { Command } from "../command";
 import { requireAuth } from "../requireAuth";
@@ -35,6 +42,7 @@ import { existsSync } from "node:fs";
 import { LoggingStdioServerTransport } from "./logging-transport";
 import { isFirebaseStudio } from "../env";
 import { timeoutFallback } from "../timeout";
+import { resources } from "./resources";
 
 const SERVER_VERSION = "0.3.0";
 
@@ -52,7 +60,7 @@ const orderedLogLevels = [
 ] as const;
 
 export class FirebaseMcpServer {
-  private _ready: boolean = false;
+  private _ready = false;
   private _readyPromises: { resolve: () => void; reject: (err: unknown) => void }[] = [];
   startupRoot?: string;
   cachedProjectDir?: string;
@@ -84,7 +92,7 @@ export class FirebaseMcpServer {
       mcp_client_name: this.clientInfo?.name || "<unknown-client>",
       mcp_client_version: this.clientInfo?.version || "<unknown-version>",
     };
-    trackGA4(event, { ...params, ...clientInfoParams });
+    return trackGA4(event, { ...params, ...clientInfoParams });
   }
 
   constructor(options: { activeFeatures?: ServerFeature[]; projectRoot?: string }) {
@@ -95,18 +103,21 @@ export class FirebaseMcpServer {
       tools: { listChanged: true },
       logging: {},
       prompts: { listChanged: true },
+      resources: {},
     });
 
     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.setRequestHandler(ListResourcesRequestSchema, this.mcpListResources.bind(this));
+    this.server.setRequestHandler(ReadResourceRequestSchema, this.mcpReadResource.bind(this));
 
-    this.server.oninitialized = async () => {
+    const onInitialized = (): void => {
       const clientInfo = this.server.getClientVersion();
       this.clientInfo = clientInfo;
       if (clientInfo?.name) {
-        this.trackGA4("mcp_client_connected");
+        void this.trackGA4("mcp_client_connected");
       }
       if (!this.clientInfo?.name) this.clientInfo = { name: "<unknown-client>" };
 
@@ -116,6 +127,10 @@ export class FirebaseMcpServer {
       }
     };
 
+    this.server.oninitialized = () => {
+      void onInitialized();
+    };
+
     this.server.setRequestHandler(SetLevelRequestSchema, async ({ params }) => {
       this.currentLogLevel = params.level;
       return {};
@@ -261,6 +276,17 @@ export class FirebaseMcpServer {
     }
   }
 
+  private _createMcpContext(projectId: string, accountEmail: string | null): McpContext {
+    const options = { projectDir: this.cachedProjectDir, cwd: this.cachedProjectDir };
+    return {
+      projectId: projectId,
+      host: this,
+      config: Config.load(options, true) || new Config({}, options),
+      rc: loadRC(options),
+      accountEmail,
+    };
+  }
+
   async mcpListTools(): Promise<ListToolsResult> {
     await Promise.all([this.detectActiveFeatures(), this.detectProjectRoot()]);
     const hasActiveProject = !!(await this.getProjectId());
@@ -313,14 +339,7 @@ export class FirebaseMcpServer {
       if (err) return err;
     }
 
-    const options = { projectDir: this.cachedProjectDir, cwd: this.cachedProjectDir };
-    const toolsCtx: ServerToolContext = {
-      projectId: projectId,
-      host: this,
-      config: Config.load(options, true) || new Config({}, options),
-      rc: loadRC(options),
-      accountEmail,
-    };
+    const toolsCtx = this._createMcpContext(projectId, accountEmail);
     try {
       const res = await tool.fn(toolArgs, toolsCtx);
       await this.trackGA4("mcp_tool_call", {
@@ -374,14 +393,7 @@ export class FirebaseMcpServer {
     const skipAutoAuthForStudio = isFirebaseStudio();
     const accountEmail = await this.getAuthenticatedUser(skipAutoAuthForStudio);
 
-    const options = { projectDir: this.cachedProjectDir, cwd: this.cachedProjectDir };
-    const promptsCtx: ServerPromptContext = {
-      projectId: projectId,
-      host: this,
-      config: Config.load(options, true) || new Config({}, options),
-      rc: loadRC(options),
-      accountEmail,
-    };
+    const promptsCtx = this._createMcpContext(projectId, accountEmail);
 
     try {
       const messages = await prompt.fn(promptArgs, promptsCtx);
@@ -401,14 +413,40 @@ export class FirebaseMcpServer {
     }
   }
 
+  async mcpListResources(): Promise<ListResourcesResult> {
+    return {
+      resources: resources.map((r) => r.mcp),
+    };
+  }
+
+  async mcpReadResource(req: ReadResourceRequest): Promise<ReadResourceResult> {
+    const resource = resources.find((r) => r.mcp.uri === req.params.uri);
+
+    let projectId = await this.getProjectId();
+    projectId = projectId || "";
+
+    const skipAutoAuthForStudio = isFirebaseStudio();
+    const accountEmail = await this.getAuthenticatedUser(skipAutoAuthForStudio);
+
+    const resourceCtx = this._createMcpContext(projectId, accountEmail);
+
+    if (!resource) {
+      throw new McpError(
+        ErrorCode.InvalidParams,
+        `Resource '${req.params.uri}' could not be found.`,
+      );
+    }
+    return resource.fn(req.params.uri, resourceCtx);
+  }
+
   async start(): Promise<void> {
     const transport = process.env.FIREBASE_MCP_DEBUG_LOG
       ? new LoggingStdioServerTransport(process.env.FIREBASE_MCP_DEBUG_LOG)
       : new StdioServerTransport();
     await this.server.connect(transport);
   }
 
-  private async log(level: LoggingLevel, message: unknown) {
+  private log(level: LoggingLevel, message: unknown): void {
     let data = message;
 
     // mcp protocol only takes jsons or it errors; for convienence, format
@@ -425,6 +463,6 @@ export class FirebaseMcpServer {
       return;
     }
 
-    if (this._ready) await this.server.sendLoggingMessage({ level, data });
+    if (this._ready) void this.server.sendLoggingMessage({ level, data });
   }
 }

src/mcp/prompt.ts

@@ -1,15 +1,5 @@
 import { PromptMessage } from "@modelcontextprotocol/sdk/types.js";
-import type { FirebaseMcpServer } from "./index";
-import type { Config } from "../config";
-import { RC } from "../rc";
-
-export interface ServerPromptContext {
-  projectId: string;
-  accountEmail: string | null;
-  config: Config;
-  host: FirebaseMcpServer;
-  rc: RC;
-}
+import { McpContext } from "./types";
 
 export interface ServerPrompt {
   mcp: {
@@ -25,7 +15,7 @@ export interface ServerPrompt {
       feature?: string;
     };
   };
-  fn: (args: Record<string, string>, ctx: ServerPromptContext) => Promise<PromptMessage[]>;
+  fn: (args: Record<string, string>, ctx: McpContext) => Promise<PromptMessage[]>;
 }
 
 export function prompt(options: ServerPrompt["mcp"], fn: ServerPrompt["fn"]): ServerPrompt {

src/mcp/prompts/core/index.ts

@@ -1,3 +1,10 @@
+import { init } from "./init";
 import { deploy } from "./deploy";
+import { isEnabled } from "../../../experiments";
 
-export const corePrompts = [deploy];
+const corePrompts = [deploy];
+if (isEnabled("mcpalpha")) {
+  corePrompts.push(init);
+}
+
+export { corePrompts };

src/mcp/prompts/core/init.ts

@@ -0,0 +1,74 @@
+import { getPlatformFromFolder } from "../../../dataconnect/appFinder";
+import { Platform } from "../../../dataconnect/types";
+import { prompt } from "../../prompt";
+
+export const init = prompt(
+  {
+    name: "init",
+    description: "Use this command to setup Firebase for the current workspace.",
+    arguments: [
+      {
+        name: "prompt",
+        description: "any Firebase products you want to use or the problems you're trying to solve",
+        required: false,
+      },
+    ],
+    annotations: {
+      title: "Initialize Firebase",
+    },
+  },
+  async ({ prompt }, { config, projectId, accountEmail }) => {
+    const platform = await getPlatformFromFolder(config.projectDir);
+
+    return [
+      {
+        role: "user" as const,
+        content: {
+          type: "text",
+          text: `
+Your goal is to help the user setup Firebase services in this workspace. Firebase is a large platform with many potential uses, so you will:
+
+1. Detect which Firebase services are already in use in the workspace, if any
+2. Determine which new Firebase services will help the user build their app
+3. Provision and configure the services requested by the user
+
+## Workspace Info
+
+Use this information to determine which Firebase services the user is already using (if any).
+
+Workspace platform: ${[Platform.NONE, Platform.MULTIPLE].includes(platform) ? "<UNABLE TO DETECT>" : platform}
+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, use the \`firebase_login\` tool to help them sign in.
+2. Determine which of the services listed below are the best match for the user's needs based on their instructions or by asking them.
+3. Read the guide for the appropriate services and follow the instructions. If no guides match the user's need, inform the user.
+
+## Available Services
+
+The following Firebase services are available to be configured. Use the Firebase \`read_resources\` tool to load their instructions for further guidance.
+
+- [Backend Services](firebase://guides/init/backend): Read this resource to setup backend services for the user such as user authentication, database, or cloud file storage.
+- [GenAI Services](firebase://guides/init/ai): Read this resource to setup GenAI services for the user such as building agents, LLM usage, unstructured data analysis, image editing, video generation, etc.
+
+UNAVAILABLE SERVICES: Analytics, Remote Config (feature flagging), A/B testing, Crashlytics (crash reporting), and Cloud Messaging (push notifications) are not yet available for setup via this command.
+`.trim(),
+        },
+      },
+    ];
+  },
+);

src/mcp/resource.ts

@@ -0,0 +1,29 @@
+import type { ReadResourceResult } from "@modelcontextprotocol/sdk/types.js";
+import { McpContext } from "./types";
+
+export interface ServerResource {
+  mcp: {
+    uri: string;
+    name: string;
+    description?: string;
+    title?: string;
+    _meta?: {
+      /** Set this on a resource if it *always* requires a signed-in user to work. */
+      requiresAuth?: boolean;
+      /** Set this on a resource if it uses Gemini in Firebase API in any way. */
+      requiresGemini?: boolean;
+    };
+  };
+  fn: (uri: string, ctx: McpContext) => Promise<ReadResourceResult>;
+}
+
+export function resource(
+  options: ServerResource["mcp"],
+  fnOrText: ServerResource["fn"] | string,
+): ServerResource {
+  const fn: ServerResource["fn"] =
+    typeof fnOrText === "string"
+      ? async (uri) => ({ contents: [{ uri, text: fnOrText }] })
+      : fnOrText;
+  return { mcp: options, fn };
+}

src/mcp/resources/guides/init_ai.ts

@@ -0,0 +1,22 @@
+import { resource } from "../../resource";
+
+export const init_ai = resource(
+  {
+    uri: "firebase://guides/init/ai",
+    name: "ai_init_guide",
+    title: "Firebase GenAI Init Guide",
+    description:
+      "guides the coding agent through configuring GenAI capabilities in the current project utilizing Firebase",
+  },
+  async (uri) => {
+    return {
+      contents: [
+        {
+          uri,
+          type: "text",
+          text: `Create ai.ts with import { AI } from "firebase";`,
+        },
+      ],
+    };
+  },
+);