diff --git a/.eslintrc.js b/.eslintrc.js
index 732995f2831..bd5c3d8003b 100644
--- a/.eslintrc.js
+++ b/.eslintrc.js
@@ -47,6 +47,7 @@ module.exports = {
 
         "@typescript-eslint/no-invalid-this": "error",
         "@typescript-eslint/no-unused-vars": "error", // Unused vars should not exist.
+        "@typescript-eslint/require-await": "off", // sometimes async functions don't do await stuff for valid reasons.
         "no-invalid-this": "off", // Turned off in favor of @typescript-eslint/no-invalid-this.
         "no-unused-vars": "off", // Off in favor of @typescript-eslint/no-unused-vars.
         eqeqeq: ["error", "always", { null: "ignore" }],
diff --git a/.github/ISSUE_TEMPLATE/mcp.md b/.github/ISSUE_TEMPLATE/mcp.md
new file mode 100644
index 00000000000..64089d65833
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/mcp.md
@@ -0,0 +1,26 @@
+---
+name: "🤖 MCP Server"
+about: Report bugs or request features for the Firebase MCP Server.
+title: "[MCP]"
+labels: "api: mcp"
+assignees: ""
+---
+
+<!-- DO NOT DELETE
+validate_template=true
+template_path=.github/ISSUE_TEMPLATE/mcp.md
+-->
+
+## Summary
+
+<!-- what is your bug / feature request / feedback? -->
+
+## Bug Info <!-- please fill this out if you have a bug -->
+
+- **Affected Tool(s):** <!-- Which specific tool(s) were you using when you encountered the issue? -->
+- **MCP Client:** <!-- e.g. "Cursor v0.50.0" -->
+- **Operating System:** <!-- e.g. "Windows 11" or "macOS Sequoia" -->
+
+### Steps to Reproduce
+
+<!-- write a detailed description of how to reproduce>
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 47ae9d448b3..9f0e1e973fc 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,4 +1,5 @@
-- Changed artifact registry cleanup policy error to warn for CI/CD workloads #8513
-- Enhance firebase init apphosting to support local source deploys. (#8479)
-- Fixed issue where `firebase init hosting:github` didn't correctly parse the repo input. (#8536)
-- Add GCP API client functions to support App Hosting deploy from source feature. (#8545)
+- Fixed issue in `init` where users were forced to specify emulator UI port (#8626)
+- Adds MCP tools for App Hosting (#8605)
+- Fixed crash when starting the App Hosting emulator in certain applications (#8624)
+- Fixed issue where, with `webframeworks` enabled, `firebase init hosting` re-prompts users for source. (#8587)
+- Update typescript version in functions template to avoid build issue with @google-cloud/storage depedency (#8194)
diff --git a/firebase-vscode/.gitignore b/firebase-vscode/.gitignore
index c974aeb9293..31f52f88a1b 100644
--- a/firebase-vscode/.gitignore
+++ b/firebase-vscode/.gitignore
@@ -5,4 +5,5 @@ resources/dist
 .vscode-test
 .wdio-vscode-service
 logs
-!*.tgz
\ No newline at end of file
+!*.tgz
+prebuilt-extensions
\ No newline at end of file
diff --git a/firebase-vscode/.vscodeignore b/firebase-vscode/.vscodeignore
index 43d19f15c1a..5109cbc4aa0 100644
--- a/firebase-vscode/.vscodeignore
+++ b/firebase-vscode/.vscodeignore
@@ -20,4 +20,5 @@ node_modules/
 dist/test/
 *.tgz
 package-lock.json
-.wdio-vscode-service/
\ No newline at end of file
+.wdio-vscode-service/
+prebuilt-extensions/
\ No newline at end of file
diff --git a/firebase-vscode/CHANGELOG.md b/firebase-vscode/CHANGELOG.md
index dfb0503f98a..106df28d6f1 100644
--- a/firebase-vscode/CHANGELOG.md
+++ b/firebase-vscode/CHANGELOG.md
@@ -1,5 +1,10 @@
 ## NEXT
 
+## 1.4.0
+
+- Update internal `firebase-tools` dependency to 14.4.0
+- [Added] @data-connect tool callable from the Gemini Code Assist extension.
+
 ## 1.3.1
 
 - Updated internal `firebase-tools` dependency to 14.2.1
diff --git a/firebase-vscode/common/messaging/protocol.ts b/firebase-vscode/common/messaging/protocol.ts
index baa9bc26f6a..5765ddd0f96 100644
--- a/firebase-vscode/common/messaging/protocol.ts
+++ b/firebase-vscode/common/messaging/protocol.ts
@@ -109,6 +109,8 @@ export interface WebviewToExtensionParamsMap {
   /** Clears data from a running data connect emulator */
   "fdc.clear-emulator-data": void;
 
+  "firebase.activate.gemini": void;
+
   // Initialize "result" tab.
   getDataConnectResults: void;
 
diff --git a/firebase-vscode/package-lock.json b/firebase-vscode/package-lock.json
index e50f2750308..f468499b2b3 100644
--- a/firebase-vscode/package-lock.json
+++ b/firebase-vscode/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "firebase-dataconnect-vscode",
-  "version": "1.3.1",
+  "version": "1.4.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "firebase-dataconnect-vscode",
-      "version": "1.3.1",
+      "version": "1.4.0",
       "dependencies": {
         "@preact/signals-core": "^1.4.0",
         "@preact/signals-react": "1.3.6",
@@ -6584,6 +6584,7 @@
       "resolved": "https://registry.npmjs.org/css-loader/-/css-loader-6.11.0.tgz",
       "integrity": "sha512-CTJ+AEQJjq5NzLga5pE39qdiSV56F8ywCIsqNIRF0r7BDgWsN25aazToqAFg7ZrtA/U016xudB3ffgweORxX7g==",
       "dev": true,
+      "license": "MIT",
       "dependencies": {
         "icss-utils": "^5.1.0",
         "postcss": "^8.4.33",
@@ -6669,6 +6670,7 @@
       "resolved": "https://registry.npmjs.org/cssesc/-/cssesc-3.0.0.tgz",
       "integrity": "sha512-/Tb/JcjK111nNScGob5MNtsntNM1aCNUDipB/TkwZFhyDrrE47SOx/18wF2bbjgc3ZzCSKW1T5nt5EbFoAz/Vg==",
       "dev": true,
+      "license": "MIT",
       "bin": {
         "cssesc": "bin/cssesc"
       },
@@ -9584,6 +9586,7 @@
       "resolved": "https://registry.npmjs.org/icss-utils/-/icss-utils-5.1.0.tgz",
       "integrity": "sha512-soFhflCVWLfRNOPU3iv5Z9VUdT44xFRbzjLsEzSr5AQmgqPMTHdU3PMT1Cf1ssx8fLNJDA1juftYl+PUcv3MqA==",
       "dev": true,
+      "license": "ISC",
       "engines": {
         "node": "^10 || ^12 || >= 14"
       },
@@ -12998,6 +13001,7 @@
       "resolved": "https://registry.npmjs.org/postcss-modules-extract-imports/-/postcss-modules-extract-imports-3.1.0.tgz",
       "integrity": "sha512-k3kNe0aNFQDAZGbin48pL2VNidTF0w4/eASDsxlyspobzU3wZQLOGj7L9gfRe0Jo9/4uud09DsjFNH7winGv8Q==",
       "dev": true,
+      "license": "ISC",
       "engines": {
         "node": "^10 || ^12 || >= 14"
       },
@@ -13006,13 +13010,14 @@
       }
     },
     "node_modules/postcss-modules-local-by-default": {
-      "version": "4.0.5",
-      "resolved": "https://registry.npmjs.org/postcss-modules-local-by-default/-/postcss-modules-local-by-default-4.0.5.tgz",
-      "integrity": "sha512-6MieY7sIfTK0hYfafw1OMEG+2bg8Q1ocHCpoWLqOKj3JXlKu4G7btkmM/B7lFubYkYWmRSPLZi5chid63ZaZYw==",
+      "version": "4.2.0",
+      "resolved": "https://registry.npmjs.org/postcss-modules-local-by-default/-/postcss-modules-local-by-default-4.2.0.tgz",
+      "integrity": "sha512-5kcJm/zk+GJDSfw+V/42fJ5fhjL5YbFDl8nVdXkJPLLW+Vf9mTD5Xe0wqIaDnLuL2U6cDNpTr+UQ+v2HWIBhzw==",
       "dev": true,
+      "license": "MIT",
       "dependencies": {
         "icss-utils": "^5.0.0",
-        "postcss-selector-parser": "^6.0.2",
+        "postcss-selector-parser": "^7.0.0",
         "postcss-value-parser": "^4.1.0"
       },
       "engines": {
@@ -13023,12 +13028,13 @@
       }
     },
     "node_modules/postcss-modules-scope": {
-      "version": "3.2.0",
-      "resolved": "https://registry.npmjs.org/postcss-modules-scope/-/postcss-modules-scope-3.2.0.tgz",
-      "integrity": "sha512-oq+g1ssrsZOsx9M96c5w8laRmvEu9C3adDSjI8oTcbfkrTE8hx/zfyobUoWIxaKPO8bt6S62kxpw5GqypEw1QQ==",
+      "version": "3.2.1",
+      "resolved": "https://registry.npmjs.org/postcss-modules-scope/-/postcss-modules-scope-3.2.1.tgz",
+      "integrity": "sha512-m9jZstCVaqGjTAuny8MdgE88scJnCiQSlSrOWcTQgM2t32UBe+MUmFSO5t7VMSfAf/FJKImAxBav8ooCHJXCJA==",
       "dev": true,
+      "license": "ISC",
       "dependencies": {
-        "postcss-selector-parser": "^6.0.4"
+        "postcss-selector-parser": "^7.0.0"
       },
       "engines": {
         "node": "^10 || ^12 || >= 14"
@@ -13042,6 +13048,7 @@
       "resolved": "https://registry.npmjs.org/postcss-modules-values/-/postcss-modules-values-4.0.0.tgz",
       "integrity": "sha512-RDxHkAiEGI78gS2ofyvCsu7iycRv7oqw5xMWn9iMoR0N/7mf9D50ecQqUo5BZ9Zh2vH4bCUR/ktCqbB9m8vJjQ==",
       "dev": true,
+      "license": "ISC",
       "dependencies": {
         "icss-utils": "^5.0.0"
       },
@@ -13053,10 +13060,11 @@
       }
     },
     "node_modules/postcss-selector-parser": {
-      "version": "6.1.2",
-      "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-6.1.2.tgz",
-      "integrity": "sha512-Q8qQfPiZ+THO/3ZrOrO0cJJKfpYCagtMUkXbnEfmgUjwXg6z/WBeOyS9APBBPCTSiDV+s4SwQGu8yFsiMRIudg==",
+      "version": "7.0.0",
+      "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-7.0.0.tgz",
+      "integrity": "sha512-9RbEr1Y7FFfptd/1eEdntyjMwLeghW1bHX9GWjXo19vx4ytPQhANltvVxDggzJl7mnWM+dX28kb6cyS/4iQjlQ==",
       "dev": true,
+      "license": "MIT",
       "dependencies": {
         "cssesc": "^3.0.0",
         "util-deprecate": "^1.0.2"
@@ -13069,7 +13077,8 @@
       "version": "4.2.0",
       "resolved": "https://registry.npmjs.org/postcss-value-parser/-/postcss-value-parser-4.2.0.tgz",
       "integrity": "sha512-1NNCs6uurfkVbeXG4S8JFT9t19m45ICnif8zWLd5oPSZ50QnwMfK+H3jv408d4jw/7Bttv5axS5IiHoLaVNHeQ==",
-      "dev": true
+      "dev": true,
+      "license": "MIT"
     },
     "node_modules/postcss/node_modules/source-map-js": {
       "version": "1.2.1",
diff --git a/firebase-vscode/package.json b/firebase-vscode/package.json
index 50cc33c6077..831c3dff606 100644
--- a/firebase-vscode/package.json
+++ b/firebase-vscode/package.json
@@ -4,12 +4,15 @@
   "publisher": "GoogleCloudTools",
   "icon": "./resources/firebase_dataconnect_logo.png",
   "description": "Firebase Data Connect for VSCode",
-  "version": "1.3.1",
+  "version": "1.4.0",
   "engines": {
     "vscode": "^1.69.0"
   },
   "repository": "https://github.com/firebase/firebase-tools",
   "sideEffects": false,
+  "extensionDependencies": [
+    "google.geminicodeassist"
+  ],
   "categories": [
     "Other"
   ],
@@ -213,6 +216,7 @@
     "test-compile": "npm run copyfiles && webpack --config src/test/webpack.test.js",
     "lint": "eslint src --ext ts",
     "test": "npm run test:unit && npm run test:e2e",
+    "pretest:e2e": "curl -fsSL https://code-server.dev/install.sh | sh -s -- --edge && code-server --install-extension Google.geminicodeassist --extensions-dir ./prebuilt-extensions/",
     "pretest:unit": "npm run test-compile && tsc -p src/test/tsconfig.test.json",
     "test:unit": "node ./dist/test/firebase-vscode/src/test/runTest.js",
     "test:e2e": "npm run test:e2e:empty && npm run test:e2e:fishfood",
diff --git a/firebase-vscode/src/analytics.ts b/firebase-vscode/src/analytics.ts
index 03f9b1dfd1a..1372f4fcf86 100644
--- a/firebase-vscode/src/analytics.ts
+++ b/firebase-vscode/src/analytics.ts
@@ -32,8 +32,13 @@ export enum DATA_CONNECT_EVENT_NAME {
   START_EMULATORS = "start_emulators",
   AUTO_COMPLETE = "auto_complete",
   SESSION_CHAR_COUNT = "session_char_count",
-  EMULATOR_EXPORT ="emulator_export",
+  EMULATOR_EXPORT = "emulator_export",
   SETUP_FIREBASE_BINARY = "setup_firebase_binary",
+  GEMINI_ERROR = "gemini_error",
+  GEMINI_OPERATION_CALL = "gemini_operation_call",
+  GEMINI_SCHEMA_CALL = "gemini_schema_call",
+  GEMINI_SUCCESS = "gemini_success",
+  TRY_GEMINI_CLICKED = "try_gemini_clicked",
 }
 
 export class AnalyticsLogger {
@@ -42,9 +47,9 @@ export class AnalyticsLogger {
   private sessionCharCount = 0; // Track total chars for the session
 
   constructor(context: vscode.ExtensionContext) {
-    this.logger = monospaceEnv.value.isMonospace ? new IDXLogger(new GA4TelemetrySender(pluginLogger), context) : env.createTelemetryLogger(
-      new GA4TelemetrySender(pluginLogger),
-    );
+    this.logger = monospaceEnv.value.isMonospace
+      ? new IDXLogger(new GA4TelemetrySender(pluginLogger), context)
+      : env.createTelemetryLogger(new GA4TelemetrySender(pluginLogger));
 
     let subscriptions: vscode.Disposable[] = [
       vscode.workspace.onDidChangeTextDocument(
@@ -149,13 +154,15 @@ export class AnalyticsLogger {
 }
 
 export class IDXLogger {
-  constructor(private sender: GA4TelemetrySender, private context: vscode.ExtensionContext) {}
+  constructor(
+    private sender: GA4TelemetrySender,
+    private context: vscode.ExtensionContext,
+  ) {}
   public logUsage(eventName: string, data?: any) {
     const packageJson = this.context.extension.packageJSON;
     data = {
       ...data,
-      extversion: packageJson.version,
-      extname: "idx",
+      ...getAnalyticsContext(this.context),
       isidx: "true",
     };
     this.sender.sendEventData(eventName, data);
@@ -207,6 +214,15 @@ class GA4TelemetrySender implements TelemetrySender {
   }
 }
 
+export function getAnalyticsContext(context: vscode.ExtensionContext) {
+  const packageJson = context.extension.packageJSON;
+
+  return {
+    extversion: packageJson.version,
+    extname: monospaceEnv.value.isMonospace ? "idx" : "vscode",
+  };
+}
+
 function addFirebaseBinaryMetadata(data?: Record<string, any> | undefined) {
   const settings = getSettings();
   return { ...data, binary_kind: settings.firebaseBinaryKind };
diff --git a/firebase-vscode/src/data-connect/ai-tools/gca-tool-types.ts b/firebase-vscode/src/data-connect/ai-tools/gca-tool-types.ts
new file mode 100644
index 00000000000..183b81354f4
--- /dev/null
+++ b/firebase-vscode/src/data-connect/ai-tools/gca-tool-types.ts
@@ -0,0 +1,509 @@
+import {
+  CancellationToken,
+  Disposable,
+  MarkdownString,
+  ThemeIcon,
+  Uri,
+} from "vscode";
+
+/**
+ * The public API for Gemini Code Assist to be utilized by external providers to
+ * extend Gemini Code Assist functionality.
+ */
+export interface GeminiCodeAssist extends Disposable {
+  /**
+   * Registers the caller as a tool for Gemini Code Assist.  The tool will be
+   * identified to the end user through the id parameter. The tool will further
+   * identify itself through the extension id.  An extension may choose to
+   * register any number of tools.
+   * @param id The id to use when referring to the tool.  For example this may
+   * be `gemini` so that the tool will be addressed as `@gemini` by the user.
+   * Note that this id cannot be reused by another tool or other entity like
+   * a variable provider.
+   * @param displayName The name of the tool, to be used when referring to the
+   * tool in chat.
+   * @param extensionId The extension that implements the tool.  The tool's
+   * icon will be loaded from this extension by default and used when
+   * displaying the tool's participation in chat.
+   * @param iconPath The path to the tool's icon, can be an icon for any theme,
+   * contain a dark and light icon or be a ThemeIcon type. The iconPath should be a join
+   * of the extension path and the relative path to the icon.
+   * @param command A command for Gemini Code Assist to execute on activation.
+   * If this is specified by the tool registration Gemini Code Assist will wait
+   * for the tool's extension to activate and then execute the command
+   * specified.  This can be used to allow the tool to guarantee registration
+   * whenever Gemini Code Assist is loaded.
+   * @return The tool's registration to be modified by the tool provider with
+   * the capabilities of the tool.
+   */
+  registerTool(
+    id: string,
+    displayName: string,
+    extensionId: string,
+    iconPath?: Uri | { dark: Uri; light: Uri } | ThemeIcon,
+    command?: string,
+  ): GeminiTool;
+}
+
+/**
+ * Represents a tool to Gemini Code Assist.  This allows the external provider
+ * to provide specific services to Gemini Code Assist.  Upon dispose this tool
+ * registration will be removed from Gemini Code Assist for this instance only.
+ * Upon subsequent activations Gemini Code Assist will attempt to execute the
+ * command that was specified in the tool's registration if any was specified.
+ */
+export interface GeminiTool extends Disposable {
+  /**
+   * Registers a handler for chat.  This allows the tool to handle incoming
+   * chat requests.
+   * @param handler The chat handler method that will be called with the
+   * registered tool is called.
+   * @return Disposable for subscription purposes, calling dispose will remove
+   * the registration.
+   */
+  registerChatHandler(handler: ChatHandler): Disposable;
+
+  /**
+   * Registers a variable provider for the tool.  Variable provider ids should
+   * be unique for the tool but other tools may choose to implement the same
+   * provider id.  For example `@bug` could be registered to `@jira` and
+   * `@github`.
+   * @param id The variable provider id, used to isolate typeahead to a specific
+   * variable type.  For example using `@bug` will allow users to limit
+   * typeahead to bugs only instead of anything that can be completed.
+   * @param provider The provider to register, this will provide both static
+   * resolution as well as dynamic resolution.
+   * @return Disposable for removing the variable provider from Gemini Code
+   * Assist.
+   */
+  registerVariableProvider(id: string, provider: VariableProvider): Disposable;
+
+  /**
+   * Registers a slash command provider for the tool.  This allows the tool
+   * to provide slash commands for the user.  For example `/list` can be
+   * registered to the `@jira` tool to list bugs assigned to the user.
+   * @param provider The slash command provider to be registered.
+   * @return Disposable for removing the command provider from Gemini Code
+   * Assist.
+   */
+  registerCommandProvider(provider: CommandProvider): Disposable;
+
+  /**
+   * Registers a suggested prompt provider for the tool.  This allows the tool
+   * to provide suggestions of prompts that the user can either tab complete or
+   * click to use.
+   * @param provider The child provider to be registered.
+   * @return Disposable for removing the suggested prompt provider from Gemini
+   * Code Assist.
+   */
+  registerSuggestedPromptProvider(
+    provider: SuggestedPromptProvider,
+  ): Disposable;
+}
+
+/**
+ * Provides suggested prompts which serve as example queries for the tool.
+ * These suggested prompts allow the user to see specific examples when using
+ * the tool and give some guidance as to helpful prompts as a starting point for
+ * using the tool with Gemini Code Assist.
+ */
+export interface SuggestedPromptProvider {
+  /**
+   * Provides a list of suggested prompts for the tool that will be displayed to
+   * the user as examples or templates for using the tool.  In this text the
+   * user can specify placeholder text as text surrounded by square brackets.
+   * For example a suggested prompt value of `/generate an api specification for
+   * [function]` provided by `apigee` would provide a suggested prompt of
+   * `@apigee /generate an api specification for [function]` and the user would
+   * be prompted to supply a value for the [function] placeholder.
+   */
+  provideSuggestedPrompts(): string[];
+}
+
+/**
+ * Provides the chat handler functionality to Gemini Code Assist, allowing a
+ * tool to extend chat.  Through this handler the tool can service chat
+ * requests, add context for Gemini chat requests, and/or rewrite the prompt
+ * before it is sent to the LLM service.
+ */
+export interface ChatHandler {
+  /**
+   * @param request The chat request, can be used to manipulate the prompt and
+   * reference parts.
+   */
+  (
+    request: ChatRequest,
+    responseStream: ChatResponseStream,
+    token: CancellationToken,
+  ): Promise<void>;
+}
+
+/**
+ * Provides support for variables through the `@` designator.  For example
+ * `@repo` could represent the current repository for a SCM tool.  This
+ * interface allows the tool to provide a static list of variables as well as
+ * a dynamic list.
+ */
+export interface VariableProvider {
+  /**
+   * Allows the tool to return a static list of variables that it supports.
+   * This list is not expected to change as the user is typing.
+   * @return Returns a list of variables instances.
+   */
+  listVariables(): Promise<Variable[]>;
+
+  /**
+   * Allows for dynamic variable support.  This function will allow the tool
+   * to resolve variables as the user types.
+   * @param part Current text part that the user has typed, this is what
+   * currently follows the `@` symbol in the user's prompt.
+   * @param limit The number of typeahead suggestions that the UI will show to
+   * the user at once.
+   * @param token Supports cancellation (user types an additional character).
+   * @return Returns a list of variable instances that match the type ahead.
+   */
+  typeahead(
+    part: string,
+    limit: number,
+    token: CancellationToken,
+  ): Promise<Variable[]>;
+}
+
+/**
+ * Represents a variable instance, the name and description are used to display
+ * the variable to the user.  The variable instance will be passed as is to the
+ * tool, so it can carry any additional context necessary.
+ */
+export interface Variable {
+  /**
+   * The name of the variable, this would be what the variable looks like to the
+   * user.
+   */
+  name: string;
+
+  /**
+   * The optional description of the variable to show the user in the UX.
+   */
+  description?: string | MarkdownString;
+}
+
+/**
+ * Provides support for commands through the `/` designator.  This takes the
+ * form of `@tool /command`.
+ */
+export interface CommandProvider {
+  /**
+   * Lists the slash commands provided by the tool.
+   * @return Command gives a list of the commands provided by the tool.
+   */
+  listCommands(): Promise<CommandDetail[]>;
+}
+
+/**
+ * CommandDetail exports a command along with any other context the tool may
+ * want to have in coordination with the command.
+ */
+export interface CommandDetail {
+  /**
+   * The string that identifies the command in question.
+   */
+  command: string;
+
+  /**
+   * The optional description of the slash command to display to the user.
+   */
+  description?: string | MarkdownString;
+
+  /**
+   * The optional codicon of the slash command.
+   */
+  icon?: string;
+}
+
+/**
+ * CommandPromptPart is the part of the prompt that is associated with a slash
+ * command.
+ */
+export interface CommandPromptPart extends PromptPart {
+  /**
+   * The CommandDetail provided by the CommandProvider's listCommands()
+   * function.
+   */
+  command: CommandDetail;
+}
+
+/**
+ * Provides the context for the chat request.  The context can be used to
+ * provide additional information to the LLM service.
+ */
+export interface ChatRequestContext {
+  /**
+   * Pushes a new context onto the context stack.
+   * @param context The context to push.
+   */
+  push(context: ChatContext | VariableChatContext): void;
+}
+
+/**
+ * Represents a context that can be used to provide additional information to the
+ * LLM service.
+ */
+export interface ChatContext {
+  /**
+   * The id of the reference that this context is associated with.
+   */
+  id: string | Uri;
+
+  /**
+   * Gets the text of the context.
+   */
+  getText(): string;
+}
+
+/**
+ * Represents a context for a variable in the prompt.
+ */
+export interface VariableChatContext extends ChatContext {
+  /**
+   * The variable that this context represents.
+   */
+  variable: Variable;
+}
+
+/**
+ * Represents a chat request which is comprised of a prompt and context.
+ */
+export interface ChatRequest {
+  /**
+   * The prompt of the chat request.  This can be manipulated by the tool.
+   */
+  prompt: ChatPrompt;
+
+  /**
+   * The context for the request.  This can be used by the tool to add context
+   * to the request.
+   */
+  context: ChatRequestContext;
+}
+
+/**
+ * Represents the current chat prompt.
+ */
+export interface ChatPrompt {
+  /**
+   * Used to retrieve all parts of the prompt, including the tool prompts.
+   * @return An array of all parts of the prompt in order that they appear.
+   */
+  getPromptParts(): PromptPart[];
+
+  /**
+   * Removes the specified prompt part.
+   * @param part The prompt part to remove.
+   */
+  deletePromptPart(part: PromptPart): void;
+
+  /**
+   * Splices in prompt part(s) similarly to Array.splice().  This can be used to
+   * insert a number of prompt part(s) (including none) and can remove existing
+   * elements.
+   * @param index The starting index for the splice operation.
+   * @param remove The number of elements to remove.
+   * @param parts The prompt part(s) to insert.
+   */
+  splice(index: number, remove: number, ...parts: PromptPart[]): void;
+
+  /**
+   * Pushes the prompt part(s) into the chat prompt.  These part(s) are appended
+   * similarly to array.push().
+   * @param parts The prompt part(s) to push.
+   */
+  push(...parts: PromptPart[]): void;
+
+  /**
+   * Returns the string representation of the prompt.
+   */
+  fullPrompt(): string;
+
+  /**
+   * The length of the prompt in parts.
+   */
+  length: number;
+}
+
+/**
+ * Represents a prompt part that is provided by a tool.
+ */
+export interface PromptPart {
+  /**
+   * Gets the prompt of the prompt part.
+   */
+  getPrompt(): string;
+}
+
+/**
+ * Represents a prompt part that is provided by a tool.
+ */
+export interface ToolPromptPart extends PromptPart {
+  /**
+   * The id of the tool that provided the prompt part.
+   */
+  toolId: string;
+
+  /**
+   * The command of the prompt part.
+   */
+  command: string;
+}
+
+/**
+ * Represents a prompt part that refers to a variable.
+ */
+export interface VariablePromptPart extends PromptPart {
+  variable: Variable;
+}
+
+/**
+ * Represents a stream of chat responses.  Used by the tool to provide chat
+ * based responses to the user.  This stream can be used to push both partial
+ * responses as well as to close the stream.
+ */
+export interface ChatResponseStream {
+  /**
+   * Pushes a new content onto the response stream.
+   * @param content The content to push.
+   */
+  push(content: MarkdownString | Citation): void;
+
+  /**
+   * Closes the steam and prevents the request from going to the LLM after tool
+   * processing.  This can be utilized by the client for commands that are
+   * client only.  Returning without calling close will result in the processed
+   * prompt and context being sent to the LLM for a result.
+   */
+  close(): void;
+
+  /**
+   * Adds a button handler to code responses that come back from the LLM.  This
+   * allows the tool to present the user with a button attached to this response
+   * and on click process the code response.
+   * @param title The title of the button.
+   * @param handler The handler to execute when the user clicks on the button.
+   * The code block will be sent as an argument to the handler on execution as
+   * CodeHandlerCommandArgs.
+   * @param languageFilter Optional parameter, if this is specified the
+   * language specified on the block will be checked for a match against this
+   * and the button will be displayed on match.  If this is not specified the
+   * buttone will be displayed on any language result.
+   */
+  addCodeHandlerButton(
+    title: string,
+    handler: CodeHandler,
+    options: HandlerButtonOptions,
+  ): void;
+}
+
+/**
+ * Method for handling code responses from the LLM attached to the response via
+ * ChatResponseStream.addCodeHandlerButton.
+ */
+export interface CodeHandler {
+  /**
+   * @param args The code block and language specifiers from the LLM response to
+   * handle.  Called when the user clicks on a CodeHandlerButton.
+   */
+  (args: CodeHandlerCommandArgs): void;
+}
+
+/**
+ * The arguments that are sent when calling the command associated with the
+ * addCodeHandlerButton method.
+ */
+export interface CodeHandlerCommandArgs {
+  /**
+   * The code block that was attached to the code handler button.
+   */
+  codeBlock: string;
+  /**
+   * The language specifier on the code block associated with the code handler
+   * button.
+   */
+  language: string;
+}
+
+/**
+ * Provides options for a code handler button.  This allows the tool to
+ * specialize the way GCA handles specific code blocks when the agent is
+ * involved.
+ */
+export interface HandlerButtonOptions {
+  /**
+   * Optional parameter, if this is specified the language specified on the
+   * block will be checked for a match against this and the button will be
+   * displayed on match.  If this is not specified the button will be displayed
+   * on any language result.
+   */
+  languages?: RegExp;
+
+  /**
+   * Optional, if this is specified the block will be either expanded or
+   * collapsed as specified.  If this is not specified the built in default
+   * handler will be used.
+   */
+  displayType?: BlockDisplayType;
+}
+
+/**
+ * Specifies how code blocks should be handled in chat.
+ */
+export enum BlockDisplayType {
+  /**
+   * The code block will be expanded by default.
+   */
+  Expanded,
+
+  /**
+   * The code block will be collapsed by default.
+   */
+  Collapsed,
+}
+
+/**
+ * Represents the type of citation.
+ */
+export enum CitationType {
+  /**
+   * General citation where the link is from a unspecific source.
+   */
+  Unknown,
+
+  /**
+   * The citation originates from the user's machine, for example a file on the
+   * user's disk.
+   */
+  Local,
+
+  /**
+   * The citation comes from Github.
+   */
+  Github,
+}
+
+/**
+ * Represents a citation.
+ */
+export interface Citation {
+  /**
+   * The URI of the citation.
+   */
+  uri: Uri;
+
+  /**
+   * The license of the citation.
+   */
+  license: string | undefined;
+
+  /**
+   * The type of the citation.
+   */
+  type: CitationType;
+}
diff --git a/firebase-vscode/src/data-connect/ai-tools/gca-tool.ts b/firebase-vscode/src/data-connect/ai-tools/gca-tool.ts
new file mode 100644
index 00000000000..48ebcee666d
--- /dev/null
+++ b/firebase-vscode/src/data-connect/ai-tools/gca-tool.ts
@@ -0,0 +1,230 @@
+import { AnalyticsLogger } from "../../analytics";
+import { ExtensionBrokerImpl } from "../../extension-broker";
+import * as vscode from "vscode";
+import { DataConnectService } from "../service";
+import {
+  ChatPrompt,
+  ChatRequest,
+  ChatResponseStream,
+  CommandDetail,
+  CommandProvider,
+  GeminiCodeAssist,
+} from "./gca-tool-types";
+import { insertToBottomOfActiveFile } from "../file-utils";
+import { ExtensionContext } from "vscode";
+import { Chat, Command } from "./types";
+import { GeminiToolController } from "./tool-controller";
+import { ChatMessage } from "../../dataconnect/cloudAICompanionTypes";
+export const DATACONNECT_TOOL_ID = "data-connect";
+export const DATACONNECT_DISPLAY_NAME = "Data Connect";
+export const SUGGESTED_PROMPTS = [
+  "/generate_schema Create a schema for a pizza store",
+  "/generate_operation Create a mutations for all my types",
+];
+const HELP_MESSAGE = `
+Welcome to the Data Connect Tool.
+Usage:
+  @data-connect /generate_schema <your prompt>\n
+  @data-connect /generate_operation <your prompt>
+`;
+
+export class GCAToolClient {
+  private history: Chat[] = [];
+  private icon = vscode.Uri.joinPath(
+    this.context.extensionUri,
+    "resources",
+    "firebase_dataconnect_logo.svg",
+  );
+  constructor(
+    private context: ExtensionContext,
+    private toolController: GeminiToolController,
+  ) {}
+
+  async activate() {
+    const gemini = vscode.extensions.getExtension<GeminiCodeAssist>(
+      "google.geminicodeassist",
+    );
+    if (!gemini || !gemini.isActive) {
+      throw new Error("Gemini extension not found"); // should never happen, gemini is an extension depedency
+    }
+
+    gemini?.activate().then(async (gca) => {
+      const tool = gca.registerTool(
+        DATACONNECT_TOOL_ID,
+        DATACONNECT_DISPLAY_NAME,
+        "GoogleCloudTools.firebase-dataconnect-vscode",
+        this.icon,
+        "help",
+      );
+      tool.registerChatHandler(this.handleChat.bind(this));
+      tool.registerSuggestedPromptProvider(this);
+      tool.registerCommandProvider(
+        new DataConnectCommandProvider(this.icon.toString()),
+      );
+    });
+  }
+
+  /** implementation of handleChat interface;
+   * We redirect the request to our controller
+   */
+  async handleChat(
+    request: ChatRequest,
+    responseStream: ChatResponseStream,
+    token: vscode.CancellationToken,
+  ): Promise<void> {
+    // Helper just to convert to markdown first
+    function pushToResponseStream(text: string) {
+      const markdown = new vscode.MarkdownString(text);
+      responseStream.push(markdown);
+    }
+
+    // Adds the Graphql code block button "Insert to bottom of file"
+    addCodeHandlers(responseStream);
+
+    let response: ChatMessage[];
+
+    // parse the prompt
+    if (!isPromptValid(request.prompt)) {
+      pushToResponseStream(HELP_MESSAGE);
+      responseStream.close();
+      return;
+    }
+    const content = getPrompt(request.prompt);
+    const command = getCommand(request.prompt);
+
+    // Forward to tool controller
+    try {
+      this.history.push({ author: "USER", content, commandContext: command });
+      response = await this.toolController.handleChat(
+        content,
+        this.history,
+        command,
+      );
+    } catch (error) {
+      let errorMessage = "";
+      if (error instanceof Error) {
+        errorMessage = error.message;
+      } else if (typeof error === "string") {
+        errorMessage = error;
+      }
+
+      pushToResponseStream(errorMessage);
+
+      // reset history on error
+      this.history = [];
+      responseStream.close();
+      return;
+    }
+    const agentMessage = response.pop()?.content;
+
+    if (agentMessage) {
+      this.history.push({ author: "AGENT", content: agentMessage });
+    }
+
+    pushToResponseStream(
+      agentMessage || "Gemini encountered an error. Please try again.}",
+    );
+    responseStream.close();
+  }
+
+  provideSuggestedPrompts(): string[] {
+    return SUGGESTED_PROMPTS;
+  }
+}
+
+class DataConnectCommandProvider implements CommandProvider {
+  schemaCommand: CommandDetail = {
+    command: Command.GENERATE_SCHEMA,
+    description: "Generates a GraphQL schema based on a prompt",
+    icon: this.icon,
+  };
+
+  operationCommand: CommandDetail = {
+    command: Command.GENERATE_OPERATION,
+    description: "Generates a GraphQL query or mutation based on a prompt",
+    icon: this.icon,
+  };
+
+  helpCommand: CommandDetail = {
+    command: "help",
+    description: "Shows this help message",
+    icon: this.icon,
+  };
+  constructor(readonly icon: string) {}
+  listCommands(): Promise<CommandDetail[]> {
+    const commands: CommandDetail[] = [
+      this.schemaCommand,
+      this.operationCommand,
+      // this.helpCommand,
+    ];
+    return Promise.resolve(commands);
+  }
+}
+
+/** Exploring a variable provider for dataconnect introspected types */
+// class DataConnectTypeVariableProvider implements VariableProvider {
+//   constructor(private fdcService: DataConnectService) {}
+//   async listVariables(): Promise<Variable[]> {
+//     const introspection = await this.fdcService.introspect();
+//     console.log(introspection);
+//     return introspection.data!.__schema.types.map((type) => {
+//       return {
+//         name: type.name,
+//         description: type.description as string,
+//       };
+//     });
+//   }
+
+//   typeahead(
+//     part: string,
+//     limit: number,
+//     token: vscode.CancellationToken,
+//   ): Promise<Variable[]> {
+//     throw new Error("Method not implemented.");
+//   }
+// }
+
+// currently only supports a single button
+function addCodeHandlers(responseStream: ChatResponseStream) {
+  responseStream.addCodeHandlerButton(
+    "Insert to bottom of file",
+    ({ codeBlock }) => {
+      insertToBottomOfActiveFile(codeBlock);
+    },
+    { languages: /graphql|graphqllanguage/ },
+  );
+}
+
+// Basic validation function to ensure deterministic command
+function isPromptValid(prompt: ChatPrompt): boolean {
+  if (prompt.length < 2) {
+    return false;
+  }
+  if (prompt.getPromptParts()[0].getPrompt() !== "@data-connect") {
+    return false;
+  }
+
+  return isCommandValid(
+    prompt.getPromptParts()[1].getPrompt().replace("/", ""),
+  );
+}
+
+function isCommandValid(command: string): boolean {
+  return (Object.values(Command) as string[]).includes(command);
+}
+
+// get the /command without the /
+function getCommand(prompt: ChatPrompt): Command {
+  return prompt.getPromptParts()[1].getPrompt().replace("/", "") as Command;
+}
+
+// get the entire prompt without the @tool & /command
+function getPrompt(prompt: ChatPrompt): string {
+  if (
+    prompt.length > 2 &&
+    prompt.getPromptParts()[0].getPrompt() === "@data-connect"
+  ) {
+    return prompt.getPromptParts()[2].getPrompt();
+  }
+  return prompt.fullPrompt();
+}
diff --git a/firebase-vscode/src/data-connect/ai-tools/tool-controller.ts b/firebase-vscode/src/data-connect/ai-tools/tool-controller.ts
new file mode 100644
index 00000000000..500334099b6
--- /dev/null
+++ b/firebase-vscode/src/data-connect/ai-tools/tool-controller.ts
@@ -0,0 +1,289 @@
+import * as fs from "fs";
+import * as path from "path";
+import * as vscode from "vscode";
+import { Signal } from "@preact/signals-core";
+
+import { Result } from "../../result";
+import { AnalyticsLogger } from "../../analytics";
+import { ResolvedDataConnectConfigs } from "../config";
+import { DataConnectService } from "../service";
+import { CloudAICompanionResponse, ChatMessage } from "../../dataconnect/cloudAICompanionTypes";
+import { ObjectTypeDefinitionNode, OperationDefinitionNode } from "graphql";
+import { getHighlightedText, findGqlFiles } from "../file-utils";
+import { CommandContext, Chat, Context, Command, BackendAuthor } from "./types";
+import { DATA_CONNECT_EVENT_NAME } from "../../analytics";
+
+const USER_PREAMBLE = "This is the user's prompt: \n";
+
+const SCHEMA_PROMPT_PREAMBLE =
+  "This is the user's current schema in their code base.: \n";
+
+const NEW_LINE = "\n";
+const HIGHLIGHTED_TEXT_PREAMBLE =
+  "This is the highlighted code in the users active editor: \n";
+
+/**
+ * Logic for talking to CloudCompanion API
+ * Handles Context collection and management
+ *
+ */
+export class GeminiToolController {
+  constructor(
+    private readonly analyticsLogger: AnalyticsLogger,
+    private readonly fdcService: DataConnectService,
+    private configs: Signal<
+      Result<ResolvedDataConnectConfigs | undefined> | undefined
+    >,
+  ) {
+    this.registerCommands();
+  }
+
+  // entry points from vscode to respsective tools
+  private registerCommands(): void {
+    /** Demo only */
+    // vscode.commands.registerCommand(
+    //   "firebase.dataConnect.refineOperation",
+    //   async (ast: ObjectTypeDefinitionNode) => {
+    //     this.highlightActiveType(ast);
+    //     if (env.value.isMonospace) {
+    //       vscode.commands.executeCommand("aichat.prompt", {
+    //         prefillPrompt: "@data-connect /generate_operation ",
+    //       });
+    //     } else {
+    //       // change to prefill when GCA releases feature
+    //       vscode.commands.executeCommand("cloudcode.gemini.chatView.focus");
+    //     }
+    //   },
+    // );
+    /** End Demo only */
+  }
+  private highlightActiveType(ast: ObjectTypeDefinitionNode) {
+    const editor = vscode.window.activeTextEditor;
+    if (!editor || !ast.loc) {
+      // TODO: add a warning, and skip this process
+    } else {
+      // highlight the schema in question
+      const startPostion = new vscode.Position(
+        ast.loc?.startToken.line - 1,
+        ast.loc?.startToken.column - 1,
+      );
+      const endPosition = new vscode.Position(
+        ast.loc?.endToken.line,
+        ast.loc?.endToken.column - 1,
+      );
+      editor.selection = new vscode.Selection(startPostion, endPosition);
+    }
+  }
+
+  /**
+   * Entry point to chat interface;
+   * Builds prompt given chatHistory and generation type
+   * We use some basic heuristics such as
+   *    - presence of previously generated code
+   *    - activeEditor + any highlighted code
+   */
+  public async handleChat(
+    userPrompt: string, // prompt without toolname and command
+    chatHistory: Chat[],
+    command: Command,
+  ): Promise<ChatMessage[]> {
+    let prompt = "";
+    let currentChat: Chat = {
+      author: "USER",
+      content: "to_be_set",
+      commandContext: CommandContext.NO_OP /* to be set */,
+    };
+    let type: "schema" | "operation";
+
+    // set type
+    if (command === Command.GENERATE_OPERATION) {
+      type = "operation";
+      this.analyticsLogger.logger.logUsage(
+        DATA_CONNECT_EVENT_NAME.GEMINI_OPERATION_CALL,
+      );
+    } else if (command === Command.GENERATE_SCHEMA) {
+      type = "schema";
+      this.analyticsLogger.logger.logUsage(
+        DATA_CONNECT_EVENT_NAME.GEMINI_SCHEMA_CALL,
+      );
+    } else {
+      // undetermined process
+      chatHistory.push({
+        author: "MODEL",
+        content:
+          "Gemini is unable to complete that request. Try '/generate_schema' or '/generate_operation' to get started.",
+      });
+      return chatHistory;
+    }
+
+    //TODO: deal with non-open editor situation
+    const currentDocumentPath =
+      vscode.window.activeTextEditor?.document.uri.path;
+
+    // get additional context
+    const schema = await this.collectSchemaText();
+    const highlighted = getHighlightedText();
+
+    // check if highlighted is a single operation
+    if (highlighted) {
+      prompt = prompt.concat(HIGHLIGHTED_TEXT_PREAMBLE, highlighted);
+    }
+
+    // only add schema for operation generation
+    if (schema && command === Command.GENERATE_OPERATION) {
+      prompt = prompt.concat(SCHEMA_PROMPT_PREAMBLE, schema);
+    }
+
+    // finalize prompt w/ user prompt
+    prompt = prompt.concat(USER_PREAMBLE, userPrompt);
+
+    const resp = await this.callGenerateApi(
+      currentDocumentPath || "",
+      prompt,
+      type,
+      this.cleanHistory(chatHistory, type),
+    );
+
+    if (resp.error) {
+      this.analyticsLogger.logger.logUsage(
+        DATA_CONNECT_EVENT_NAME.GEMINI_ERROR,
+      );
+      return [{ author: "MODEL", content: resp.error.message }];
+    }
+
+    return resp.output.messages;
+  }
+
+  // clean history for API consumption
+  public cleanHistory(history: ChatMessage[], type: string): Chat[] {
+    if (type === "operation") {
+      // operation api uses "SYSTEM" to represent API responses
+      return history.map((item) => {
+        if (
+          item.author.toUpperCase() === "MODEL" ||
+          item.author.toUpperCase() === "AGENT"
+        ) {
+          item.author = "SYSTEM";
+        }
+
+        if (item.author.toUpperCase() === "USER") {
+          item.author = "USER"; // set upper case
+        }
+        // remove command context
+        return { author: item.author, content: item.content };
+      });
+    } else {
+      return history.map((item) => {
+        if (
+          item.author.toUpperCase() === "AGENT" ||
+          item.author.toUpperCase() === "SYSTEM"
+        ) {
+          item.author = "MODEL";
+        }
+        item.author = item.author.toUpperCase();
+
+        return {
+          author: item.author,
+          content: item.content,
+        };
+      });
+    }
+  }
+
+  async callGenerateApi(
+    documentPath: string,
+    prompt: string,
+    type: "schema" | "operation",
+    chatHistory: Chat[],
+  ): Promise<CloudAICompanionResponse> {
+    // TODO: Call Gemini API with the document content and context
+    try {
+      const response = await this.fdcService.generateOperation(
+        documentPath,
+        prompt,
+        type,
+        chatHistory,
+      );
+      if (!response) {
+        throw new Error("No response from Cloud AI API");
+      }
+      return response;
+    } catch (error) {
+      throw new Error(`Failed to call Gemini API: ${error}`);
+    }
+  }
+
+  async collectSchemaText(): Promise<string> {
+    try {
+      const service = this.configs?.value?.tryReadValue?.values[0];
+
+      if (!service) {
+        // The entrypoint is not a codelens file, so we can't determine the service.
+        return "";
+      }
+
+      let schema: string = "";
+      const schemaPath = path.join(service.path, service.schemaDir);
+      const schemaFiles = await findGqlFiles(schemaPath);
+      for (const file of schemaFiles) {
+        schema = schema.concat(fs.readFileSync(file, "utf-8"));
+      }
+      return schema;
+    } catch (error) {
+      throw new Error(`Failed to collect GQL files: ${error}`);
+    }
+  }
+
+  /** Demo usage only */
+  private async setupRefineOperation(prompt: string, chatHistory: Chat[]) {
+    const preamble =
+      "This is the GraphQL Operation that was generated previously: ";
+
+    // TODO: more verification
+    const lastChat = chatHistory.pop();
+    let operation = "";
+    if (!lastChat) {
+      // could not find an operation, TODO: response appropriately
+    } else {
+      operation = lastChat.content;
+    }
+
+    return preamble.concat(NEW_LINE, operation);
+  }
+
+  private async setupRefineSchema(prompt: string, chatHistory: Chat[]) {
+    const SCHEMA_PREAMBLE =
+      "This is the GraphQL Schema that was generated previously: \n";
+
+    // TODO: more verification
+    const lastChat = chatHistory.pop();
+    let schema = "";
+    if (!lastChat) {
+      // could not find a schema, use the schema in editor
+      schema = await this.collectSchemaText();
+    } else {
+      schema = lastChat.content;
+    }
+
+    return prompt.concat(SCHEMA_PREAMBLE, schema);
+  }
+
+  private isAuthorBackend(author: string) {
+    return Object.values(BackendAuthor).includes(author);
+  }
+
+  // checks if last chat in the history is a generated code response from a model
+  private isLastChatGenerated(chatHistory: Chat[]): boolean {
+    const lastChat = chatHistory.pop();
+    return (
+      lastChat !== undefined &&
+      this.isAuthorBackend(lastChat.author) &&
+      lastChat.commandContext !== undefined &&
+      lastChat.commandContext !== CommandContext.NO_OP
+    );
+  }
+
+  /** End demo code */
+
+  dispose() {}
+}
diff --git a/firebase-vscode/src/data-connect/ai-tools/types.ts b/firebase-vscode/src/data-connect/ai-tools/types.ts
new file mode 100644
index 00000000000..8d3dbc7df29
--- /dev/null
+++ b/firebase-vscode/src/data-connect/ai-tools/types.ts
@@ -0,0 +1,25 @@
+import { ChatMessage } from "../../dataconnect/cloudAICompanionTypes";
+
+export enum Command {
+  GENERATE_SCHEMA = "generate_schema",
+  GENERATE_OPERATION = "generate_operation",
+}
+export enum Context {
+  REFINE_SCHEMA = "refine_schema",
+  REFINE_OPERATION = "refine_op",
+  NO_OP = "no_op", // not no_operation, it's just a no-op
+}
+// export type CommandContext = Command | Context;
+export const CommandContext = { ...Command, ...Context };
+export type CommandContextType = Command | Context;
+
+// adds context to the ChatMessage type for reasoning
+export interface Chat extends ChatMessage {
+  commandContext?: CommandContextType;
+}
+
+// represents a backend chat response
+export const BackendAuthor = {
+  MODEL: "MODEL", // schema api
+  SYSTEM: "SYSTEM", // operation api
+};
diff --git a/firebase-vscode/src/data-connect/code-lens-provider.ts b/firebase-vscode/src/data-connect/code-lens-provider.ts
index 96bee317b0b..5b9ca2722d2 100644
--- a/firebase-vscode/src/data-connect/code-lens-provider.ts
+++ b/firebase-vscode/src/data-connect/code-lens-provider.ts
@@ -96,8 +96,18 @@ export class OperationCodeLensProvider extends ComputedCodeLensProvider {
         const service = fdcConfigs.findEnclosingServiceForPath(
           document.fileName,
         );
-
         if (service) {
+          // For demo purposes only
+          // codeLenses.push(
+          //   new vscode.CodeLens(range, {
+          //     title: `$(play) Refine Operation`,
+          //     command: "firebase.dataConnect.refineOperation",
+          //     tooltip:
+          //       "Execute the operation (⌘+enter or Ctrl+Enter)",
+          //     arguments: [x, operationLocation, InstanceType.LOCAL],
+          //   }),
+          // );
+
           codeLenses.push(
             new vscode.CodeLens(range, {
               title: `$(play) Run (local)`,
@@ -146,6 +156,18 @@ export class SchemaCodeLensProvider extends ComputedCodeLensProvider {
         const range = new vscode.Range(line, 0, line, 0);
         const documentPath = document.fileName;
 
+        // Add only at top of document
+        // if (line === 0) {
+        //   codeLenses.push(
+        //     new vscode.CodeLens(range, {
+        //       title: `Generate Schema`,
+        //       command: "firebase.dataConnect.generateSchema",
+        //       tooltip: "Generate a new schema",
+        //       arguments: [document.getText(), documentPath],
+        //     }),
+        //   );
+        // }
+
         codeLenses.push(
           new vscode.CodeLens(range, {
             title: `$(database) Add data`,
diff --git a/firebase-vscode/src/data-connect/execution/execution.ts b/firebase-vscode/src/data-connect/execution/execution.ts
index 234ac153f0f..2167e4026a8 100644
--- a/firebase-vscode/src/data-connect/execution/execution.ts
+++ b/firebase-vscode/src/data-connect/execution/execution.ts
@@ -327,12 +327,13 @@ export function registerExecution(
     executionHistoryTreeView,
     vscode.commands.registerCommand(
       "firebase.dataConnect.executeOperation",
-      (ast, location, instanceType: InstanceType) => {
+      async (ast, location, instanceType: InstanceType) => {
         analyticsLogger.logger.logUsage(
           instanceType === InstanceType.LOCAL
             ? DATA_CONNECT_EVENT_NAME.RUN_LOCAL
             : DATA_CONNECT_EVENT_NAME.RUN_PROD,
         );
+        await vscode.window.activeTextEditor?.document.save();
         executeOperation(ast, location, instanceType);
       },
     ),
diff --git a/firebase-vscode/src/data-connect/file-utils.ts b/firebase-vscode/src/data-connect/file-utils.ts
index 3c866c7bc9b..ead61d21f49 100644
--- a/firebase-vscode/src/data-connect/file-utils.ts
+++ b/firebase-vscode/src/data-connect/file-utils.ts
@@ -4,6 +4,7 @@ import * as fs from "fs";
 
 import { dataConnectConfigs } from "./config";
 import { pluginLogger } from "../logger-wrapper";
+import { parse } from "graphql";
 
 export async function checkIfFileExists(file: Uri) {
   try {
@@ -39,8 +40,47 @@ export async function upsertFile(
   await vscode.window.showTextDocument(doc);
 }
 
+export function getHighlightedText(): string {
+  const editor = vscode.window.activeTextEditor;
+  if (!editor) {
+    return "";
+  }
+  const selection = editor.selection;
+
+  const selectionRange = new vscode.Range(
+    selection.start.line,
+    selection.start.character,
+    selection.end.line,
+    selection.end.character,
+  );
+  return editor.document.getText(selectionRange);
+}
+
+export function parseGraphql(content: string) {
+  content = content.replaceAll("```", "");
+  content = content.replaceAll("graphql", "");
+  const documentNode = parse(content);
+  return documentNode.definitions[0];
+}
+
+export function insertToBottomOfActiveFile(text: string) {
+  const editor = vscode.window.activeTextEditor;
+  if (!editor) {
+    return;
+  }
+  const lastLine = editor.document.lineAt(editor.document.lineCount - 1);
+  const escapedText = text.replace(/\$/g, "\\\$"); // escape $ symbols
+
+  editor.insertSnippet(
+    new vscode.SnippetString(`\n\n${escapedText}`),
+    lastLine.range.end,
+  );
+}
+
 // given a file path, compile all gql files for the associated connector
-export async function getConnectorGqlFiles(filePath: string): Promise<string[]> {
+export async function getConnectorGqlFiles(
+  filePath: string,
+): Promise<string[]> {
   const service =
     dataConnectConfigs?.value?.tryReadValue?.findEnclosingServiceForPath(
       filePath || "",
@@ -75,11 +115,15 @@ export function getTextFromFiles(files: string[]): string {
   }, "");
 }
 
-async function findGqlFiles(dir: string): Promise<string[]> {
+export async function findGqlFiles(dir: string): Promise<string[]> {
   try {
     const entries = await fs.promises.readdir(dir, { withFileTypes: true });
     const files = entries
-      .filter((file) => !file.isDirectory() && (file.name.endsWith(".gql") || file.name.endsWith(".graphql")))
+      .filter(
+        (file) =>
+          !file.isDirectory() &&
+          (file.name.endsWith(".gql") || file.name.endsWith(".graphql")),
+      )
       .map((file) => path.join(dir, file.name));
 
     const folders = entries.filter((folder) => folder.isDirectory());
@@ -92,4 +136,4 @@ async function findGqlFiles(dir: string): Promise<string[]> {
     pluginLogger.error(`Failed to find GQL files: ${error}`);
     return [];
   }
-}
+}
\ No newline at end of file
diff --git a/firebase-vscode/src/data-connect/index.ts b/firebase-vscode/src/data-connect/index.ts
index 384f949e5d7..d227d8960c0 100644
--- a/firebase-vscode/src/data-connect/index.ts
+++ b/firebase-vscode/src/data-connect/index.ts
@@ -31,8 +31,10 @@ import { registerWebview } from "../webview";
 import { DataConnectToolkit } from "./toolkit";
 import { registerFdcSdkGeneration } from "./sdk-generation";
 import { registerDiagnostics } from "./diagnostics";
-import { AnalyticsLogger } from "../analytics";
+import { AnalyticsLogger, DATA_CONNECT_EVENT_NAME } from "../analytics";
 import { emulators } from "../init/features";
+import { GCAToolClient } from "./ai-tools/gca-tool";
+import { GeminiToolController } from "./ai-tools/tool-controller";
 
 class CodeActionsProvider implements vscode.CodeActionProvider {
   constructor(
@@ -154,8 +156,26 @@ export function registerFdc(
     authService,
     dataConnectToolkit,
     emulatorController,
+    context,
   );
 
+  /** Gemini Related activations */
+  const toolController = new GeminiToolController(
+    analyticsLogger,
+    fdcService,
+    dataConnectConfigs,
+  );
+  const gcaToolClient = new GCAToolClient(context, toolController);
+
+  gcaToolClient.activate();
+
+  broker.on("firebase.activate.gemini", () => {
+    analyticsLogger.logger.logUsage(DATA_CONNECT_EVENT_NAME.TRY_GEMINI_CLICKED);
+    vscode.commands.executeCommand("cloudcode.gemini.chatView.focus");
+  });
+
+  /** End Gemini activations */
+
   // register codelens
   const operationCodeLensProvider = new OperationCodeLensProvider(
     emulatorController,
@@ -230,6 +250,7 @@ export function registerFdc(
     registerFdcSdkGeneration(broker, analyticsLogger),
     registerTerminalTasks(broker, analyticsLogger),
     operationCodeLensProvider,
+
     vscode.languages.registerCodeLensProvider(
       // **Hack**: For testing purposes, enable code lenses on all graphql files
       // inside the test_projects folder.
@@ -255,6 +276,7 @@ export function registerFdc(
       [{ scheme: "file", language: "yaml", pattern: "**/connector.yaml" }],
       configureSdkCodeLensProvider,
     ),
+    toolController,
     {
       dispose: () => {
         client.stop();
diff --git a/firebase-vscode/src/data-connect/service.ts b/firebase-vscode/src/data-connect/service.ts
index 01893dbc293..be33f00fdec 100644
--- a/firebase-vscode/src/data-connect/service.ts
+++ b/firebase-vscode/src/data-connect/service.ts
@@ -1,4 +1,5 @@
 import fetch, { Response } from "node-fetch";
+import { ExtensionContext } from "vscode";
 import {
   ExecutionResult,
   IntrospectionQuery,
@@ -9,7 +10,7 @@ import { AuthService } from "../auth/service";
 import { UserMockKind } from "../../common/messaging/protocol";
 import { firstWhereDefined } from "../utils/signal";
 import { EmulatorsController } from "../core/emulators";
-import { dataConnectConfigs } from "../data-connect/config";
+import { dataConnectConfigs, VSCODE_ENV_VARS } from "../data-connect/config";
 
 import { firebaseRC } from "../core/config";
 import {
@@ -18,12 +19,23 @@ import {
   executeGraphQL,
   DATACONNECT_API_VERSION,
 } from "../../../src/dataconnect/dataplaneClient";
+
+import {
+  cloudAICompationClient,
+  callCloudAICompanion,
+} from "../../../src/dataconnect/cloudAiCompanionClient";
+
 import {
   ExecuteGraphqlRequest,
   GraphqlResponse,
   GraphqlResponseError,
   Impersonation,
 } from "../dataconnect/types";
+import {
+  CloudAICompanionResponse,
+  CallCloudAiCompanionRequest,
+  ChatMessage,
+} from "../dataconnect/cloudAICompanionTypes";
 import { Client, ClientResponse } from "../../../src/apiv2";
 import { InstanceType } from "./code-lens-provider";
 import { pluginLogger } from "../logger-wrapper";
@@ -37,15 +49,15 @@ export class DataConnectService {
     private authService: AuthService,
     private dataConnectToolkit: DataConnectToolkit,
     private emulatorsController: EmulatorsController,
-  ) { }
+    private context: ExtensionContext,
+  ) {}
 
-  async servicePath(
-    path: string
-  ): Promise<string | undefined> {
+  async servicePath(path: string): Promise<string | undefined> {
     const dataConnectConfigsValue = await firstWhereDefined(dataConnectConfigs);
     // TODO: avoid calling this here and in getApiServicePathByPath
     const serviceId =
-      dataConnectConfigsValue?.tryReadValue?.findEnclosingServiceForPath(path)?.value.serviceId;
+      dataConnectConfigsValue?.tryReadValue?.findEnclosingServiceForPath(path)
+        ?.value.serviceId;
     const projectId = firebaseRC.value?.tryReadValue?.projects?.default;
 
     if (serviceId === undefined || projectId === undefined) {
@@ -82,13 +94,10 @@ export class DataConnectService {
     return response.text();
   }
   private async handleProdResponse(
-    response: ClientResponse<
-      GraphqlResponse | GraphqlResponseError
-    >,
+    response: ClientResponse<GraphqlResponse | GraphqlResponseError>,
   ): Promise<ExecutionResult> {
     if (!(response.status >= 200 && response.status < 300)) {
-      const errorResponse =
-        response as ClientResponse<GraphqlResponseError>;
+      const errorResponse = response as ClientResponse<GraphqlResponseError>;
       throw new DataConnectError(
         `Prod Request failed with status ${response.status}\nError Response: ${JSON.stringify(errorResponse?.body)}`,
       );
@@ -98,13 +107,10 @@ export class DataConnectService {
   }
 
   private async handleEmulatorResponse(
-    response: ClientResponse<
-      GraphqlResponse | GraphqlResponseError
-    >,
+    response: ClientResponse<GraphqlResponse | GraphqlResponseError>,
   ): Promise<ExecutionResult> {
     if (!(response.status >= 200 && response.status < 300)) {
-      const errorResponse =
-        response as ClientResponse<GraphqlResponseError>;
+      const errorResponse = response as ClientResponse<GraphqlResponseError>;
       throw new DataConnectError(
         `Emulator Request failed with status ${response.status}\nError Response: ${JSON.stringify(errorResponse?.body)}`,
       );
@@ -117,7 +123,7 @@ export class DataConnectService {
    *
    * If the JSON is invalid, will throw.
    */
-  private _serializeBody(body: { variables?: string;[key: string]: unknown }) {
+  private _serializeBody(body: { variables?: string; [key: string]: unknown }) {
     if (!body.variables || body.variables.trim().length === 0) {
       body.variables = undefined;
       return JSON.stringify(body);
@@ -190,7 +196,7 @@ export class DataConnectService {
       });
       const resp = await fetch(
         (await this.dataConnectToolkit.getFDCToolkitURL()) +
-        `/v1/projects/p/locations/l/services/${serviceId}:executeGraphqlRead`,
+          `/v1/projects/p/locations/l/services/${serviceId}:executeGraphqlRead`,
         {
           method: "POST",
           headers: {
@@ -236,7 +242,9 @@ export class DataConnectService {
     });
     if (params.instance === InstanceType.PRODUCTION) {
       const client = dataconnectDataplaneClient();
-      pluginLogger.info(`ExecuteGraphQL (${dataconnectOrigin()}) request: ${JSON.stringify(prodBody, undefined, 4)}`);
+      pluginLogger.info(
+        `ExecuteGraphQL (${dataconnectOrigin()}) request: ${JSON.stringify(prodBody, undefined, 4)}`,
+      );
       const resp = await executeGraphQL(client, servicePath, prodBody);
       return this.handleProdResponse(resp);
     } else {
@@ -258,6 +266,32 @@ export class DataConnectService {
   docsLink() {
     return this.dataConnectToolkit.getGeneratedDocsURL();
   }
+
+  // Start cloud section
+
+  async generateOperation(
+    path: string /** currently unused; instead reading the first service config */,
+    naturalLanguageQuery: string,
+    type: "schema" | "operation",
+    chatHistory: ChatMessage[],
+  ): Promise<CloudAICompanionResponse | undefined> {
+    const client = cloudAICompationClient();
+    const servicePath = await this.servicePath(
+      dataConnectConfigs.value?.tryReadValue?.values[0].path as string,
+    );
+
+    if (!servicePath) {
+      return undefined;
+    }
+
+    const request: CallCloudAiCompanionRequest = {
+      servicePath,
+      naturalLanguageQuery,
+      chatHistory,
+    };
+    const resp = await callCloudAICompanion(client, request, type);
+    return resp;
+  }
 }
 
 function parseVariableString(variables: string): Record<string, any> {
@@ -268,7 +302,7 @@ function parseVariableString(variables: string): Record<string, any> {
     return JSON.parse(variables);
   } catch (e: any) {
     throw new Error(
-      "Unable to parse variables as JSON. Double check that that there are no unmatched braces or quotes, or unqouted keys in the variables pane."
+      "Unable to parse variables as JSON. Double check that that there are no unmatched braces or quotes, or unqouted keys in the variables pane.",
     );
   }
 }
diff --git a/firebase-vscode/src/extension.ts b/firebase-vscode/src/extension.ts
index 2682467ca2f..e63cb5a2e04 100644
--- a/firebase-vscode/src/extension.ts
+++ b/firebase-vscode/src/extension.ts
@@ -18,10 +18,7 @@ import {
 } from "./utils/settings";
 import { registerFdc } from "./data-connect";
 import { AuthService } from "./auth/service";
-import {
-  AnalyticsLogger,
-  IDX_METRIC_NOTICE,
-} from "./analytics";
+import { AnalyticsLogger, IDX_METRIC_NOTICE } from "./analytics";
 import { env } from "./core/env";
 
 import { suggestGraphqlSyntaxExtension } from "./data-connect/graphql-syntax-highlighter";
diff --git a/firebase-vscode/src/test/default_wdio.conf.ts b/firebase-vscode/src/test/default_wdio.conf.ts
index 28bbb508be3..6e595db5e7a 100644
--- a/firebase-vscode/src/test/default_wdio.conf.ts
+++ b/firebase-vscode/src/test/default_wdio.conf.ts
@@ -5,13 +5,15 @@ import * as child_process from "child_process";
 import { Notifications } from "./utils/page_objects/editor";
 
 process.env.VSCODE_TEST_MODE = "true";
-
+// used to preload extension dependencies
+const prebuiltExtensionsDir = path.resolve(__dirname, "../../prebuilt-extensions");
 export const vscodeConfigs = {
   browserName: "vscode",
   browserVersion: "1.96.4", // also possible: "insiders" or a specific version e.g. "1.80.0"
   "wdio:vscodeOptions": {
     vscodeArgs: {
       disableExtensions: false,
+      extensionsDir: prebuiltExtensionsDir,
     },
     // points to directory where extension package.json is located
     extensionPath: path.join(__dirname, "..", ".."),
@@ -46,6 +48,7 @@ export const config: WebdriverIO.Config = {
       extensionId: "graphql.vscode-graphql-syntax",
       message: "It is recommended to install GraphQL: Syntax Highlighter",
     });
+    await browser.pause(3000); // temporary fix, since installing the GCA extension takes over the main page
   },
 
   afterTest: async function (test) {
diff --git a/firebase-vscode/src/test/test_projects/empty/.firebaserc b/firebase-vscode/src/test/test_projects/empty/.firebaserc
deleted file mode 100644
index 249b2da209a..00000000000
--- a/firebase-vscode/src/test/test_projects/empty/.firebaserc
+++ /dev/null
@@ -1,7 +0,0 @@
-{
-  "projects": {
-    "default": "demo-project"
-  },
-  "targets": {},
-  "etags": {}
-}
\ No newline at end of file
diff --git a/firebase-vscode/src/test/tsconfig.test.json b/firebase-vscode/src/test/tsconfig.test.json
index a600802dfa4..41d059ceedc 100644
--- a/firebase-vscode/src/test/tsconfig.test.json
+++ b/firebase-vscode/src/test/tsconfig.test.json
@@ -9,7 +9,7 @@
     "sourceMap": true,
     "allowSyntheticDefaultImports": true,
     "skipLibCheck": true,
-
+    "resolveJsonModule": true,
     //"moduleResolution": "node",
     "outDir": "../../dist/test",
     "rootDirs": ["../", "../../common/", "../../../src/"],
diff --git a/firebase-vscode/src/test/utils/install-extensions.ts b/firebase-vscode/src/test/utils/install-extensions.ts
index b178f505952..807bce7f073 100644
--- a/firebase-vscode/src/test/utils/install-extensions.ts
+++ b/firebase-vscode/src/test/utils/install-extensions.ts
@@ -2,7 +2,7 @@ import { execSync } from "child_process";
 
 async function installExtensions() {
   // List of extensions to install
-  const extensions: string[] = ["graphql.vscode-graphql-syntax"];
+  const extensions: string[] = ["graphql.vscode-graphql-syntax", "google.geminicodeassist"];
 
   // Install each extension
   extensions.forEach((extension) => {
diff --git a/firebase-vscode/webviews/SidebarApp.tsx b/firebase-vscode/webviews/SidebarApp.tsx
index 305bca0d2a8..ebe4b5ba392 100644
--- a/firebase-vscode/webviews/SidebarApp.tsx
+++ b/firebase-vscode/webviews/SidebarApp.tsx
@@ -74,7 +74,8 @@ function EmulatorsPanel() {
         <>
           <Spacer size="medium"></Spacer>
           <label>
-            Emulator start-up is taking a while. In case of error, click refresh.
+            Emulator start-up is taking a while. In case of error, click
+            refresh.
           </label>
           <VSCodeProgressRing></VSCodeProgressRing>
           <Spacer size="medium"></Spacer>
@@ -106,9 +107,11 @@ function EmulatorsPanel() {
       </VSCodeButton>
       <Spacer size="xsmall" />
       <Label level={3}>
-        <a onClick={() => {
-          broker.send("fdc.open-emulator-settings")
-        }}>
+        <a
+          onClick={() => {
+            broker.send("fdc.open-emulator-settings");
+          }}
+        >
           Configure emulator
         </a>
       </Label>
@@ -153,8 +156,6 @@ function DataConnect() {
       </Label>
 
       <Spacer size="xlarge" />
-
-      <Spacer size="small" />
       <VSCodeButton onClick={() => broker.send("fdc.deploy-all")}>
         Deploy to production
       </VSCodeButton>
@@ -165,10 +166,27 @@ function DataConnect() {
           Deploying schema and connectors
         </a>
       </Label>
+      <Spacer size="xlarge"></Spacer>
+      <Label level={2}>Generate Schema and Operations (Preview)</Label>
+      <Spacer size="medium"></Spacer>
+      <VSCodeButton
+        appearance="secondary"
+        onClick={() => {
+          broker.send("firebase.activate.gemini");
+        }}
+      >
+        Try Gemini with @data-connect
+      </VSCodeButton>
+      <Spacer size="xsmall" />
+      <Label level={3}>
+        See also:{" "}
+        <a href="https://firebase.google.com/docs/gemini-in-firebase#how-gemini-in-firebase-uses-your-data">
+          Gemini in Firebase Usage and Terms
+        </a>
+      </Label>
     </>
   );
 }
-
 function Content() {
   useEffect(() => {
     broker.send("getDocsLink");
diff --git a/npm-shrinkwrap.json b/npm-shrinkwrap.json
index 9be32acb4e1..eca4071d1d0 100644
--- a/npm-shrinkwrap.json
+++ b/npm-shrinkwrap.json
@@ -1,12 +1,12 @@
 {
   "name": "firebase-tools",
-  "version": "14.3.1",
+  "version": "14.4.0",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "firebase-tools",
-      "version": "14.3.1",
+      "version": "14.4.0",
       "license": "MIT",
       "dependencies": {
         "@electric-sql/pglite": "^0.2.16",
@@ -41,6 +41,7 @@
         "gaxios": "^6.7.0",
         "glob": "^10.4.1",
         "google-auth-library": "^9.11.0",
+        "ignore": "^7.0.4",
         "js-yaml": "^3.14.1",
         "jsonwebtoken": "^9.0.0",
         "leven": "^3.1.0",
@@ -1417,6 +1418,15 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
+    "node_modules/@eslint/eslintrc/node_modules/ignore": {
+      "version": "5.3.2",
+      "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.3.2.tgz",
+      "integrity": "sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==",
+      "dev": true,
+      "engines": {
+        "node": ">= 4"
+      }
+    },
     "node_modules/@eslint/eslintrc/node_modules/js-yaml": {
       "version": "4.1.0",
       "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.0.tgz",
@@ -5515,6 +5525,15 @@
         }
       }
     },
+    "node_modules/@typescript-eslint/eslint-plugin/node_modules/ignore": {
+      "version": "5.3.2",
+      "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.3.2.tgz",
+      "integrity": "sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==",
+      "dev": true,
+      "engines": {
+        "node": ">= 4"
+      }
+    },
     "node_modules/@typescript-eslint/eslint-plugin/node_modules/ms": {
       "version": "2.1.2",
       "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz",
@@ -9543,6 +9562,15 @@
         "node": ">=8"
       }
     },
+    "node_modules/eslint/node_modules/ignore": {
+      "version": "5.3.2",
+      "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.3.2.tgz",
+      "integrity": "sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==",
+      "dev": true,
+      "engines": {
+        "node": ">= 4"
+      }
+    },
     "node_modules/eslint/node_modules/js-yaml": {
       "version": "4.1.0",
       "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.0.tgz",
@@ -11102,6 +11130,15 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
+    "node_modules/globby/node_modules/ignore": {
+      "version": "5.3.2",
+      "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.3.2.tgz",
+      "integrity": "sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==",
+      "dev": true,
+      "engines": {
+        "node": ">= 4"
+      }
+    },
     "node_modules/globrex": {
       "version": "0.1.2",
       "resolved": "https://registry.npmjs.org/globrex/-/globrex-0.1.2.tgz",
@@ -12334,10 +12371,9 @@
       ]
     },
     "node_modules/ignore": {
-      "version": "5.2.0",
-      "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.2.0.tgz",
-      "integrity": "sha512-CmxgYGiEPCLhfLnpPp1MoRmifwEIOgjcHXxOBjv7mY96c+eWScsOP9c112ZyLdWHi0FxHjI+4uVhKYp/gcdRmQ==",
-      "dev": true,
+      "version": "7.0.4",
+      "resolved": "https://registry.npmjs.org/ignore/-/ignore-7.0.4.tgz",
+      "integrity": "sha512-gJzzk+PQNznz8ysRrC0aOkBNVRBDtE1n53IqyqEf3PXrYwomFs5q4pGMizBMJF+ykh03insJ27hB8gSrD2Hn8A==",
       "engines": {
         "node": ">= 4"
       }
@@ -22614,6 +22650,12 @@
             "type-fest": "^0.20.2"
           }
         },
+        "ignore": {
+          "version": "5.3.2",
+          "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.3.2.tgz",
+          "integrity": "sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==",
+          "dev": true
+        },
         "js-yaml": {
           "version": "4.1.0",
           "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.0.tgz",
@@ -25855,6 +25897,12 @@
             "ms": "2.1.2"
           }
         },
+        "ignore": {
+          "version": "5.3.2",
+          "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.3.2.tgz",
+          "integrity": "sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==",
+          "dev": true
+        },
         "ms": {
           "version": "2.1.2",
           "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz",
@@ -28624,6 +28672,12 @@
           "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==",
           "dev": true
         },
+        "ignore": {
+          "version": "5.3.2",
+          "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.3.2.tgz",
+          "integrity": "sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==",
+          "dev": true
+        },
         "js-yaml": {
           "version": "4.1.0",
           "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.0.tgz",
@@ -29880,6 +29934,14 @@
         "ignore": "^5.2.0",
         "merge2": "^1.4.1",
         "slash": "^3.0.0"
+      },
+      "dependencies": {
+        "ignore": {
+          "version": "5.3.2",
+          "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.3.2.tgz",
+          "integrity": "sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==",
+          "dev": true
+        }
       }
     },
     "globrex": {
@@ -30841,10 +30903,9 @@
       "integrity": "sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA=="
     },
     "ignore": {
-      "version": "5.2.0",
-      "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.2.0.tgz",
-      "integrity": "sha512-CmxgYGiEPCLhfLnpPp1MoRmifwEIOgjcHXxOBjv7mY96c+eWScsOP9c112ZyLdWHi0FxHjI+4uVhKYp/gcdRmQ==",
-      "dev": true
+      "version": "7.0.4",
+      "resolved": "https://registry.npmjs.org/ignore/-/ignore-7.0.4.tgz",
+      "integrity": "sha512-gJzzk+PQNznz8ysRrC0aOkBNVRBDtE1n53IqyqEf3PXrYwomFs5q4pGMizBMJF+ykh03insJ27hB8gSrD2Hn8A=="
     },
     "import-fresh": {
       "version": "3.3.0",
diff --git a/package.json b/package.json
index 859d5263da7..6330e0be2ab 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "firebase-tools",
-  "version": "14.3.1",
+  "version": "14.4.0",
   "description": "Command-Line Interface for Firebase",
   "main": "./lib/index.js",
   "bin": {
@@ -132,6 +132,7 @@
     "gaxios": "^6.7.0",
     "glob": "^10.4.1",
     "google-auth-library": "^9.11.0",
+    "ignore": "^7.0.4",
     "js-yaml": "^3.14.1",
     "jsonwebtoken": "^9.0.0",
     "leven": "^3.1.0",
diff --git a/schema/connector-yaml.json b/schema/connector-yaml.json
index 127ff352d80..729a747d128 100644
--- a/schema/connector-yaml.json
+++ b/schema/connector-yaml.json
@@ -90,6 +90,18 @@
           ],
           "description": "Configuration for a generated Javascript SDK"
         },
+        "dartSdk": {
+          "oneOf": [
+            { "$ref": "#/definitions/dartSdk" },
+            {
+              "type": "array",
+              "items": {
+                "$ref": "#/definitions/dartSdk"
+              }
+            }
+          ],
+          "description": "Configuration for a generated Dart SDK"
+        },
         "kotlinSdk": {
           "oneOf": [
             { "$ref": "#/definitions/kotlinSdk" },
diff --git a/schema/extension-yaml.json b/schema/extension-yaml.json
index 6440c59e937..1b27c881f06 100644
--- a/schema/extension-yaml.json
+++ b/schema/extension-yaml.json
@@ -218,8 +218,11 @@
                   "description": "The name or pattern of the resource to trigger on"
                 },
                 "eventFilters": {
-                  "type": "string",
-                  "description": "Filters that further limit the events to listen to."
+                  "type": "array",
+                  "description": "Filters that further limit the events to listen to.",
+                  "items": {
+                    "$ref": "#/definitions/eventFilter"
+                  }
                 },
                 "channel": {
                   "type": "string",
@@ -327,6 +330,16 @@
           "description": "A description of the event"
         }
       }
+    },
+    "eventFilter": {
+      "type": "object",
+      "properties": {
+        "attribute": {
+          "type": "string",
+          "description": "The event attribute to filter on",
+          "value": "The value to filter for"
+        }
+      }
     }
   },
   "properties": {
diff --git a/schema/firebase-config.json b/schema/firebase-config.json
index bdab2cf8be1..b0e531545b5 100644
--- a/schema/firebase-config.json
+++ b/schema/firebase-config.json
@@ -275,16 +275,12 @@
                 },
                 "runtime": {
                     "enum": [
-                        "nodejs10",
-                        "nodejs12",
-                        "nodejs14",
-                        "nodejs16",
-                        "nodejs18",
                         "nodejs20",
                         "nodejs22",
                         "python310",
                         "python311",
-                        "python312"
+                        "python312",
+                        "python313"
                     ],
                     "type": "string"
                 },
diff --git a/scripts/mcp-tests/gemini-smoke-test.ts b/scripts/mcp-tests/gemini-smoke-test.ts
new file mode 100644
index 00000000000..fcb268b59e2
--- /dev/null
+++ b/scripts/mcp-tests/gemini-smoke-test.ts
@@ -0,0 +1,70 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+
+if (!process.env.GEMINI_API_KEY) {
+  console.error("Must set GEMINI_API_KEY to run this smoke test.");
+  process.exit(1);
+}
+
+const client = new Client({
+  name: "firebase-mcp-smoke-tester",
+  version: "0.0.1",
+});
+
+await client.connect(
+  new StdioClientTransport({
+    command: "../../lib/bin/firebase.js",
+    args: [
+      "experimental:mcp",
+      "--only",
+      "firestore,dataconnect,messaging,remoteconfig,crashlytics,auth,storage,apphosting",
+    ],
+  }),
+);
+
+const { tools } = await client.listTools();
+
+const geminiTools = tools.map((tool) => {
+  return {
+    name: tool.name,
+    description: tool.description,
+    parameters: tool.inputSchema,
+  };
+});
+
+const response = await fetch(
+  `https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent?key=${process.env.GEMINI_API_KEY}`,
+  {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+    },
+    body: JSON.stringify({
+      toolConfig: {
+        functionCallingConfig: { mode: "auto" },
+      },
+      tools: [{ functionDeclarations: geminiTools }],
+      contents: [
+        {
+          parts: [{ text: "Call the firebase_list_apps tool." }],
+        },
+      ],
+    }),
+  },
+);
+
+if (response.status === 200) {
+  console.dir(await response.json(), { depth: null });
+
+  console.log("✅ Passed smoke test!");
+  process.exit(0);
+} else {
+  const rtext = await response.text();
+  try {
+    console.dir(JSON.parse(rtext), { depth: null });
+  } catch (e) {
+    console.log(rtext);
+  }
+  console.error("ERROR: Got non-200 response from smoke test.");
+  process.exit(1);
+}
diff --git a/scripts/mcp-tests/package-lock.json b/scripts/mcp-tests/package-lock.json
new file mode 100644
index 00000000000..f642b185e6f
--- /dev/null
+++ b/scripts/mcp-tests/package-lock.json
@@ -0,0 +1,1553 @@
+{
+  "name": "mcp-tests",
+  "version": "1.0.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "mcp-tests",
+      "version": "1.0.0",
+      "license": "ISC",
+      "dependencies": {
+        "@modelcontextprotocol/sdk": "^1.11.5",
+        "tsx": "^4.19.4"
+      },
+      "devDependencies": {
+        "typescript": "^5.8.3"
+      }
+    },
+    "node_modules/@esbuild/aix-ppc64": {
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.25.4.tgz",
+      "integrity": "sha512-1VCICWypeQKhVbE9oW/sJaAmjLxhVqacdkvPLEjwlttjfwENRSClS8EjBz0KzRyFSCPDIkuXW34Je/vk7zdB7Q==",
+      "cpu": [
+        "ppc64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "aix"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/android-arm": {
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.25.4.tgz",
+      "integrity": "sha512-QNdQEps7DfFwE3hXiU4BZeOV68HHzYwGd0Nthhd3uCkkEKK7/R6MTgM0P7H7FAs5pU/DIWsviMmEGxEoxIZ+ZQ==",
+      "cpu": [
+        "arm"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/android-arm64": {
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.25.4.tgz",
+      "integrity": "sha512-bBy69pgfhMGtCnwpC/x5QhfxAz/cBgQ9enbtwjf6V9lnPI/hMyT9iWpR1arm0l3kttTr4L0KSLpKmLp/ilKS9A==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/android-x64": {
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.25.4.tgz",
+      "integrity": "sha512-TVhdVtQIFuVpIIR282btcGC2oGQoSfZfmBdTip2anCaVYcqWlZXGcdcKIUklfX2wj0JklNYgz39OBqh2cqXvcQ==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/darwin-arm64": {
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.25.4.tgz",
+      "integrity": "sha512-Y1giCfM4nlHDWEfSckMzeWNdQS31BQGs9/rouw6Ub91tkK79aIMTH3q9xHvzH8d0wDru5Ci0kWB8b3up/nl16g==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/darwin-x64": {
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.25.4.tgz",
+      "integrity": "sha512-CJsry8ZGM5VFVeyUYB3cdKpd/H69PYez4eJh1W/t38vzutdjEjtP7hB6eLKBoOdxcAlCtEYHzQ/PJ/oU9I4u0A==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/freebsd-arm64": {
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.25.4.tgz",
+      "integrity": "sha512-yYq+39NlTRzU2XmoPW4l5Ifpl9fqSk0nAJYM/V/WUGPEFfek1epLHJIkTQM6bBs1swApjO5nWgvr843g6TjxuQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/freebsd-x64": {
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.25.4.tgz",
+      "integrity": "sha512-0FgvOJ6UUMflsHSPLzdfDnnBBVoCDtBTVyn/MrWloUNvq/5SFmh13l3dvgRPkDihRxb77Y17MbqbCAa2strMQQ==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-arm": {
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.25.4.tgz",
+      "integrity": "sha512-kro4c0P85GMfFYqW4TWOpvmF8rFShbWGnrLqlzp4X1TNWjRY3JMYUfDCtOxPKOIY8B0WC8HN51hGP4I4hz4AaQ==",
+      "cpu": [
+        "arm"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-arm64": {
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.25.4.tgz",
+      "integrity": "sha512-+89UsQTfXdmjIvZS6nUnOOLoXnkUTB9hR5QAeLrQdzOSWZvNSAXAtcRDHWtqAUtAmv7ZM1WPOOeSxDzzzMogiQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-ia32": {
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.25.4.tgz",
+      "integrity": "sha512-yTEjoapy8UP3rv8dB0ip3AfMpRbyhSN3+hY8mo/i4QXFeDxmiYbEKp3ZRjBKcOP862Ua4b1PDfwlvbuwY7hIGQ==",
+      "cpu": [
+        "ia32"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-loong64": {
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.25.4.tgz",
+      "integrity": "sha512-NeqqYkrcGzFwi6CGRGNMOjWGGSYOpqwCjS9fvaUlX5s3zwOtn1qwg1s2iE2svBe4Q/YOG1q6875lcAoQK/F4VA==",
+      "cpu": [
+        "loong64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-mips64el": {
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.25.4.tgz",
+      "integrity": "sha512-IcvTlF9dtLrfL/M8WgNI/qJYBENP3ekgsHbYUIzEzq5XJzzVEV/fXY9WFPfEEXmu3ck2qJP8LG/p3Q8f7Zc2Xg==",
+      "cpu": [
+        "mips64el"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-ppc64": {
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.25.4.tgz",
+      "integrity": "sha512-HOy0aLTJTVtoTeGZh4HSXaO6M95qu4k5lJcH4gxv56iaycfz1S8GO/5Jh6X4Y1YiI0h7cRyLi+HixMR+88swag==",
+      "cpu": [
+        "ppc64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-riscv64": {
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.25.4.tgz",
+      "integrity": "sha512-i8JUDAufpz9jOzo4yIShCTcXzS07vEgWzyX3NH2G7LEFVgrLEhjwL3ajFE4fZI3I4ZgiM7JH3GQ7ReObROvSUA==",
+      "cpu": [
+        "riscv64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-s390x": {
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.25.4.tgz",
+      "integrity": "sha512-jFnu+6UbLlzIjPQpWCNh5QtrcNfMLjgIavnwPQAfoGx4q17ocOU9MsQ2QVvFxwQoWpZT8DvTLooTvmOQXkO51g==",
+      "cpu": [
+        "s390x"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-x64": {
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.25.4.tgz",
+      "integrity": "sha512-6e0cvXwzOnVWJHq+mskP8DNSrKBr1bULBvnFLpc1KY+d+irZSgZ02TGse5FsafKS5jg2e4pbvK6TPXaF/A6+CA==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/netbsd-arm64": {
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.25.4.tgz",
+      "integrity": "sha512-vUnkBYxZW4hL/ie91hSqaSNjulOnYXE1VSLusnvHg2u3jewJBz3YzB9+oCw8DABeVqZGg94t9tyZFoHma8gWZQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/netbsd-x64": {
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.25.4.tgz",
+      "integrity": "sha512-XAg8pIQn5CzhOB8odIcAm42QsOfa98SBeKUdo4xa8OvX8LbMZqEtgeWE9P/Wxt7MlG2QqvjGths+nq48TrUiKw==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/openbsd-arm64": {
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.25.4.tgz",
+      "integrity": "sha512-Ct2WcFEANlFDtp1nVAXSNBPDxyU+j7+tId//iHXU2f/lN5AmO4zLyhDcpR5Cz1r08mVxzt3Jpyt4PmXQ1O6+7A==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/openbsd-x64": {
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.25.4.tgz",
+      "integrity": "sha512-xAGGhyOQ9Otm1Xu8NT1ifGLnA6M3sJxZ6ixylb+vIUVzvvd6GOALpwQrYrtlPouMqd/vSbgehz6HaVk4+7Afhw==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/sunos-x64": {
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.25.4.tgz",
+      "integrity": "sha512-Mw+tzy4pp6wZEK0+Lwr76pWLjrtjmJyUB23tHKqEDP74R3q95luY/bXqXZeYl4NYlvwOqoRKlInQialgCKy67Q==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "sunos"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/win32-arm64": {
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.25.4.tgz",
+      "integrity": "sha512-AVUP428VQTSddguz9dO9ngb+E5aScyg7nOeJDrF1HPYu555gmza3bDGMPhmVXL8svDSoqPCsCPjb265yG/kLKQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/win32-ia32": {
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.25.4.tgz",
+      "integrity": "sha512-i1sW+1i+oWvQzSgfRcxxG2k4I9n3O9NRqy8U+uugaT2Dy7kLO9Y7wI72haOahxceMX8hZAzgGou1FhndRldxRg==",
+      "cpu": [
+        "ia32"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/win32-x64": {
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.25.4.tgz",
+      "integrity": "sha512-nOT2vZNw6hJ+z43oP1SPea/G/6AbN6X+bGNhNuq8NtRHy4wsMhw765IKLNmnjek7GvjWBYQ8Q5VBoYTFg9y1UQ==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@modelcontextprotocol/sdk": {
+      "version": "1.11.5",
+      "resolved": "https://registry.npmjs.org/@modelcontextprotocol/sdk/-/sdk-1.11.5.tgz",
+      "integrity": "sha512-gS7Q7IHpKxjVaNLMUZyTtatZ63ca3h418zPPntAhu/MvG5yfz/8HMcDAOpvpQfx3V3dsw9QQxk8RuFNrQhLlgA==",
+      "license": "MIT",
+      "dependencies": {
+        "ajv": "^8.17.1",
+        "content-type": "^1.0.5",
+        "cors": "^2.8.5",
+        "cross-spawn": "^7.0.5",
+        "eventsource": "^3.0.2",
+        "express": "^5.0.1",
+        "express-rate-limit": "^7.5.0",
+        "pkce-challenge": "^5.0.0",
+        "raw-body": "^3.0.0",
+        "zod": "^3.23.8",
+        "zod-to-json-schema": "^3.24.1"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/accepts": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/accepts/-/accepts-2.0.0.tgz",
+      "integrity": "sha512-5cvg6CtKwfgdmVqY1WIiXKc3Q1bkRqGLi+2W/6ao+6Y7gu/RCwRuAhGEzh5B4KlszSuTLgZYuqFqo5bImjNKng==",
+      "license": "MIT",
+      "dependencies": {
+        "mime-types": "^3.0.0",
+        "negotiator": "^1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/ajv": {
+      "version": "8.17.1",
+      "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.17.1.tgz",
+      "integrity": "sha512-B/gBuNg5SiMTrPkC+A2+cW0RszwxYmn6VYxB/inlBStS5nx6xHIt/ehKRhIMhqusl7a8LjQoZnjCs5vhwxOQ1g==",
+      "license": "MIT",
+      "dependencies": {
+        "fast-deep-equal": "^3.1.3",
+        "fast-uri": "^3.0.1",
+        "json-schema-traverse": "^1.0.0",
+        "require-from-string": "^2.0.2"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/epoberezkin"
+      }
+    },
+    "node_modules/body-parser": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-2.2.0.tgz",
+      "integrity": "sha512-02qvAaxv8tp7fBa/mw1ga98OGm+eCbqzJOKoRt70sLmfEEi+jyBYVTDGfCL/k06/4EMk/z01gCe7HoCH/f2LTg==",
+      "license": "MIT",
+      "dependencies": {
+        "bytes": "^3.1.2",
+        "content-type": "^1.0.5",
+        "debug": "^4.4.0",
+        "http-errors": "^2.0.0",
+        "iconv-lite": "^0.6.3",
+        "on-finished": "^2.4.1",
+        "qs": "^6.14.0",
+        "raw-body": "^3.0.0",
+        "type-is": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/bytes": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/bytes/-/bytes-3.1.2.tgz",
+      "integrity": "sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/call-bind-apply-helpers": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz",
+      "integrity": "sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==",
+      "license": "MIT",
+      "dependencies": {
+        "es-errors": "^1.3.0",
+        "function-bind": "^1.1.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/call-bound": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/call-bound/-/call-bound-1.0.4.tgz",
+      "integrity": "sha512-+ys997U96po4Kx/ABpBCqhA9EuxJaQWDQg7295H4hBphv3IZg0boBKuwYpt4YXp6MZ5AmZQnU/tyMTlRpaSejg==",
+      "license": "MIT",
+      "dependencies": {
+        "call-bind-apply-helpers": "^1.0.2",
+        "get-intrinsic": "^1.3.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/content-disposition": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/content-disposition/-/content-disposition-1.0.0.tgz",
+      "integrity": "sha512-Au9nRL8VNUut/XSzbQA38+M78dzP4D+eqg3gfJHMIHHYa3bg067xj1KxMUWj+VULbiZMowKngFFbKczUrNJ1mg==",
+      "license": "MIT",
+      "dependencies": {
+        "safe-buffer": "5.2.1"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/content-type": {
+      "version": "1.0.5",
+      "resolved": "https://registry.npmjs.org/content-type/-/content-type-1.0.5.tgz",
+      "integrity": "sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/cookie": {
+      "version": "0.7.2",
+      "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.7.2.tgz",
+      "integrity": "sha512-yki5XnKuf750l50uGTllt6kKILY4nQ1eNIQatoXEByZ5dWgnKqbnqmTrBE5B4N7lrMJKQ2ytWMiTO2o0v6Ew/w==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/cookie-signature": {
+      "version": "1.2.2",
+      "resolved": "https://registry.npmjs.org/cookie-signature/-/cookie-signature-1.2.2.tgz",
+      "integrity": "sha512-D76uU73ulSXrD1UXF4KE2TMxVVwhsnCgfAyTg9k8P6KGZjlXKrOLe4dJQKI3Bxi5wjesZoFXJWElNWBjPZMbhg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.6.0"
+      }
+    },
+    "node_modules/cors": {
+      "version": "2.8.5",
+      "resolved": "https://registry.npmjs.org/cors/-/cors-2.8.5.tgz",
+      "integrity": "sha512-KIHbLJqu73RGr/hnbrO9uBeixNGuvSQjul/jdFvS/KFSIH1hWVd1ng7zOHx+YrEfInLG7q4n6GHQ9cDtxv/P6g==",
+      "license": "MIT",
+      "dependencies": {
+        "object-assign": "^4",
+        "vary": "^1"
+      },
+      "engines": {
+        "node": ">= 0.10"
+      }
+    },
+    "node_modules/cross-spawn": {
+      "version": "7.0.6",
+      "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz",
+      "integrity": "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==",
+      "license": "MIT",
+      "dependencies": {
+        "path-key": "^3.1.0",
+        "shebang-command": "^2.0.0",
+        "which": "^2.0.1"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/debug": {
+      "version": "4.4.1",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.1.tgz",
+      "integrity": "sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ==",
+      "license": "MIT",
+      "dependencies": {
+        "ms": "^2.1.3"
+      },
+      "engines": {
+        "node": ">=6.0"
+      },
+      "peerDependenciesMeta": {
+        "supports-color": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/depd": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/depd/-/depd-2.0.0.tgz",
+      "integrity": "sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/dunder-proto": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/dunder-proto/-/dunder-proto-1.0.1.tgz",
+      "integrity": "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==",
+      "license": "MIT",
+      "dependencies": {
+        "call-bind-apply-helpers": "^1.0.1",
+        "es-errors": "^1.3.0",
+        "gopd": "^1.2.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/ee-first": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/ee-first/-/ee-first-1.1.1.tgz",
+      "integrity": "sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow==",
+      "license": "MIT"
+    },
+    "node_modules/encodeurl": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-2.0.0.tgz",
+      "integrity": "sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/es-define-property": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.1.tgz",
+      "integrity": "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/es-errors": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/es-errors/-/es-errors-1.3.0.tgz",
+      "integrity": "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/es-object-atoms": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.1.1.tgz",
+      "integrity": "sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA==",
+      "license": "MIT",
+      "dependencies": {
+        "es-errors": "^1.3.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/esbuild": {
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.25.4.tgz",
+      "integrity": "sha512-8pgjLUcUjcgDg+2Q4NYXnPbo/vncAY4UmyaCm0jZevERqCHZIaWwdJHkf8XQtu4AxSKCdvrUbT0XUr1IdZzI8Q==",
+      "hasInstallScript": true,
+      "license": "MIT",
+      "bin": {
+        "esbuild": "bin/esbuild"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "optionalDependencies": {
+        "@esbuild/aix-ppc64": "0.25.4",
+        "@esbuild/android-arm": "0.25.4",
+        "@esbuild/android-arm64": "0.25.4",
+        "@esbuild/android-x64": "0.25.4",
+        "@esbuild/darwin-arm64": "0.25.4",
+        "@esbuild/darwin-x64": "0.25.4",
+        "@esbuild/freebsd-arm64": "0.25.4",
+        "@esbuild/freebsd-x64": "0.25.4",
+        "@esbuild/linux-arm": "0.25.4",
+        "@esbuild/linux-arm64": "0.25.4",
+        "@esbuild/linux-ia32": "0.25.4",
+        "@esbuild/linux-loong64": "0.25.4",
+        "@esbuild/linux-mips64el": "0.25.4",
+        "@esbuild/linux-ppc64": "0.25.4",
+        "@esbuild/linux-riscv64": "0.25.4",
+        "@esbuild/linux-s390x": "0.25.4",
+        "@esbuild/linux-x64": "0.25.4",
+        "@esbuild/netbsd-arm64": "0.25.4",
+        "@esbuild/netbsd-x64": "0.25.4",
+        "@esbuild/openbsd-arm64": "0.25.4",
+        "@esbuild/openbsd-x64": "0.25.4",
+        "@esbuild/sunos-x64": "0.25.4",
+        "@esbuild/win32-arm64": "0.25.4",
+        "@esbuild/win32-ia32": "0.25.4",
+        "@esbuild/win32-x64": "0.25.4"
+      }
+    },
+    "node_modules/escape-html": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/escape-html/-/escape-html-1.0.3.tgz",
+      "integrity": "sha512-NiSupZ4OeuGwr68lGIeym/ksIZMJodUGOSCZ/FSnTxcrekbvqrgdUxlJOMpijaKZVjAJrWrGs/6Jy8OMuyj9ow==",
+      "license": "MIT"
+    },
+    "node_modules/etag": {
+      "version": "1.8.1",
+      "resolved": "https://registry.npmjs.org/etag/-/etag-1.8.1.tgz",
+      "integrity": "sha512-aIL5Fx7mawVa300al2BnEE4iNvo1qETxLrPI/o05L7z6go7fCw1J6EQmbK4FmJ2AS7kgVF/KEZWufBfdClMcPg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/eventsource": {
+      "version": "3.0.7",
+      "resolved": "https://registry.npmjs.org/eventsource/-/eventsource-3.0.7.tgz",
+      "integrity": "sha512-CRT1WTyuQoD771GW56XEZFQ/ZoSfWid1alKGDYMmkt2yl8UXrVR4pspqWNEcqKvVIzg6PAltWjxcSSPrboA4iA==",
+      "license": "MIT",
+      "dependencies": {
+        "eventsource-parser": "^3.0.1"
+      },
+      "engines": {
+        "node": ">=18.0.0"
+      }
+    },
+    "node_modules/eventsource-parser": {
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/eventsource-parser/-/eventsource-parser-3.0.2.tgz",
+      "integrity": "sha512-6RxOBZ/cYgd8usLwsEl+EC09Au/9BcmCKYF2/xbml6DNczf7nv0MQb+7BA2F+li6//I+28VNlQR37XfQtcAJuA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=18.0.0"
+      }
+    },
+    "node_modules/express": {
+      "version": "5.1.0",
+      "resolved": "https://registry.npmjs.org/express/-/express-5.1.0.tgz",
+      "integrity": "sha512-DT9ck5YIRU+8GYzzU5kT3eHGA5iL+1Zd0EutOmTE9Dtk+Tvuzd23VBU+ec7HPNSTxXYO55gPV/hq4pSBJDjFpA==",
+      "license": "MIT",
+      "dependencies": {
+        "accepts": "^2.0.0",
+        "body-parser": "^2.2.0",
+        "content-disposition": "^1.0.0",
+        "content-type": "^1.0.5",
+        "cookie": "^0.7.1",
+        "cookie-signature": "^1.2.1",
+        "debug": "^4.4.0",
+        "encodeurl": "^2.0.0",
+        "escape-html": "^1.0.3",
+        "etag": "^1.8.1",
+        "finalhandler": "^2.1.0",
+        "fresh": "^2.0.0",
+        "http-errors": "^2.0.0",
+        "merge-descriptors": "^2.0.0",
+        "mime-types": "^3.0.0",
+        "on-finished": "^2.4.1",
+        "once": "^1.4.0",
+        "parseurl": "^1.3.3",
+        "proxy-addr": "^2.0.7",
+        "qs": "^6.14.0",
+        "range-parser": "^1.2.1",
+        "router": "^2.2.0",
+        "send": "^1.1.0",
+        "serve-static": "^2.2.0",
+        "statuses": "^2.0.1",
+        "type-is": "^2.0.1",
+        "vary": "^1.1.2"
+      },
+      "engines": {
+        "node": ">= 18"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/express"
+      }
+    },
+    "node_modules/express-rate-limit": {
+      "version": "7.5.0",
+      "resolved": "https://registry.npmjs.org/express-rate-limit/-/express-rate-limit-7.5.0.tgz",
+      "integrity": "sha512-eB5zbQh5h+VenMPM3fh+nw1YExi5nMr6HUCR62ELSP11huvxm/Uir1H1QEyTkk5QX6A58pX6NmaTMceKZ0Eodg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 16"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/express-rate-limit"
+      },
+      "peerDependencies": {
+        "express": "^4.11 || 5 || ^5.0.0-beta.1"
+      }
+    },
+    "node_modules/fast-deep-equal": {
+      "version": "3.1.3",
+      "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz",
+      "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==",
+      "license": "MIT"
+    },
+    "node_modules/fast-uri": {
+      "version": "3.0.6",
+      "resolved": "https://registry.npmjs.org/fast-uri/-/fast-uri-3.0.6.tgz",
+      "integrity": "sha512-Atfo14OibSv5wAp4VWNsFYE1AchQRTv9cBGWET4pZWHzYshFSS9NQI6I57rdKn9croWVMbYFbLhJ+yJvmZIIHw==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/fastify"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/fastify"
+        }
+      ],
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/finalhandler": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/finalhandler/-/finalhandler-2.1.0.tgz",
+      "integrity": "sha512-/t88Ty3d5JWQbWYgaOGCCYfXRwV1+be02WqYYlL6h0lEiUAMPM8o8qKGO01YIkOHzka2up08wvgYD0mDiI+q3Q==",
+      "license": "MIT",
+      "dependencies": {
+        "debug": "^4.4.0",
+        "encodeurl": "^2.0.0",
+        "escape-html": "^1.0.3",
+        "on-finished": "^2.4.1",
+        "parseurl": "^1.3.3",
+        "statuses": "^2.0.1"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/forwarded": {
+      "version": "0.2.0",
+      "resolved": "https://registry.npmjs.org/forwarded/-/forwarded-0.2.0.tgz",
+      "integrity": "sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/fresh": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/fresh/-/fresh-2.0.0.tgz",
+      "integrity": "sha512-Rx/WycZ60HOaqLKAi6cHRKKI7zxWbJ31MhntmtwMoaTeF7XFH9hhBp8vITaMidfljRQ6eYWCKkaTK+ykVJHP2A==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/fsevents": {
+      "version": "2.3.3",
+      "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",
+      "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==",
+      "hasInstallScript": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
+      }
+    },
+    "node_modules/function-bind": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz",
+      "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/get-intrinsic": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.3.0.tgz",
+      "integrity": "sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==",
+      "license": "MIT",
+      "dependencies": {
+        "call-bind-apply-helpers": "^1.0.2",
+        "es-define-property": "^1.0.1",
+        "es-errors": "^1.3.0",
+        "es-object-atoms": "^1.1.1",
+        "function-bind": "^1.1.2",
+        "get-proto": "^1.0.1",
+        "gopd": "^1.2.0",
+        "has-symbols": "^1.1.0",
+        "hasown": "^2.0.2",
+        "math-intrinsics": "^1.1.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/get-proto": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/get-proto/-/get-proto-1.0.1.tgz",
+      "integrity": "sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==",
+      "license": "MIT",
+      "dependencies": {
+        "dunder-proto": "^1.0.1",
+        "es-object-atoms": "^1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/get-tsconfig": {
+      "version": "4.10.1",
+      "resolved": "https://registry.npmjs.org/get-tsconfig/-/get-tsconfig-4.10.1.tgz",
+      "integrity": "sha512-auHyJ4AgMz7vgS8Hp3N6HXSmlMdUyhSUrfBF16w153rxtLIEOE+HGqaBppczZvnHLqQJfiHotCYpNhl0lUROFQ==",
+      "license": "MIT",
+      "dependencies": {
+        "resolve-pkg-maps": "^1.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/privatenumber/get-tsconfig?sponsor=1"
+      }
+    },
+    "node_modules/gopd": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.2.0.tgz",
+      "integrity": "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/has-symbols": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.1.0.tgz",
+      "integrity": "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/hasown": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.2.tgz",
+      "integrity": "sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==",
+      "license": "MIT",
+      "dependencies": {
+        "function-bind": "^1.1.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/http-errors": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-2.0.0.tgz",
+      "integrity": "sha512-FtwrG/euBzaEjYeRqOgly7G0qviiXoJWnvEH2Z1plBdXgbyjv34pHTSb9zoeHMyDy33+DWy5Wt9Wo+TURtOYSQ==",
+      "license": "MIT",
+      "dependencies": {
+        "depd": "2.0.0",
+        "inherits": "2.0.4",
+        "setprototypeof": "1.2.0",
+        "statuses": "2.0.1",
+        "toidentifier": "1.0.1"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/iconv-lite": {
+      "version": "0.6.3",
+      "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.6.3.tgz",
+      "integrity": "sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw==",
+      "license": "MIT",
+      "dependencies": {
+        "safer-buffer": ">= 2.1.2 < 3.0.0"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/inherits": {
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
+      "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==",
+      "license": "ISC"
+    },
+    "node_modules/ipaddr.js": {
+      "version": "1.9.1",
+      "resolved": "https://registry.npmjs.org/ipaddr.js/-/ipaddr.js-1.9.1.tgz",
+      "integrity": "sha512-0KI/607xoxSToH7GjN1FfSbLoU0+btTicjsQSWQlh/hZykN8KpmMf7uYwPW3R+akZ6R/w18ZlXSHBYXiYUPO3g==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.10"
+      }
+    },
+    "node_modules/is-promise": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/is-promise/-/is-promise-4.0.0.tgz",
+      "integrity": "sha512-hvpoI6korhJMnej285dSg6nu1+e6uxs7zG3BYAm5byqDsgJNWwxzM6z6iZiAgQR4TJ30JmBTOwqZUw3WlyH3AQ==",
+      "license": "MIT"
+    },
+    "node_modules/isexe": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz",
+      "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==",
+      "license": "ISC"
+    },
+    "node_modules/json-schema-traverse": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz",
+      "integrity": "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==",
+      "license": "MIT"
+    },
+    "node_modules/math-intrinsics": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.1.0.tgz",
+      "integrity": "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/media-typer": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/media-typer/-/media-typer-1.1.0.tgz",
+      "integrity": "sha512-aisnrDP4GNe06UcKFnV5bfMNPBUw4jsLGaWwWfnH3v02GnBuXX2MCVn5RbrWo0j3pczUilYblq7fQ7Nw2t5XKw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/merge-descriptors": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/merge-descriptors/-/merge-descriptors-2.0.0.tgz",
+      "integrity": "sha512-Snk314V5ayFLhp3fkUREub6WtjBfPdCPY1Ln8/8munuLuiYhsABgBVWsozAG+MWMbVEvcdcpbi9R7ww22l9Q3g==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/mime-db": {
+      "version": "1.54.0",
+      "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.54.0.tgz",
+      "integrity": "sha512-aU5EJuIN2WDemCcAp2vFBfp/m4EAhWJnUNSSw0ixs7/kXbd6Pg64EmwJkNdFhB8aWt1sH2CTXrLxo/iAGV3oPQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/mime-types": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-3.0.1.tgz",
+      "integrity": "sha512-xRc4oEhT6eaBpU1XF7AjpOFD+xQmXNB5OVKwp4tqCuBpHLS/ZbBDrc07mYTDqVMg6PfxUjjNp85O6Cd2Z/5HWA==",
+      "license": "MIT",
+      "dependencies": {
+        "mime-db": "^1.54.0"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/ms": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+      "license": "MIT"
+    },
+    "node_modules/negotiator": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/negotiator/-/negotiator-1.0.0.tgz",
+      "integrity": "sha512-8Ofs/AUQh8MaEcrlq5xOX0CQ9ypTF5dl78mjlMNfOK08fzpgTHQRQPBxcPlEtIw0yRpws+Zo/3r+5WRby7u3Gg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/object-assign": {
+      "version": "4.1.1",
+      "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz",
+      "integrity": "sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/object-inspect": {
+      "version": "1.13.4",
+      "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.13.4.tgz",
+      "integrity": "sha512-W67iLl4J2EXEGTbfeHCffrjDfitvLANg0UlX3wFUUSTx92KXRFegMHUVgSqE+wvhAbi4WqjGg9czysTV2Epbew==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/on-finished": {
+      "version": "2.4.1",
+      "resolved": "https://registry.npmjs.org/on-finished/-/on-finished-2.4.1.tgz",
+      "integrity": "sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg==",
+      "license": "MIT",
+      "dependencies": {
+        "ee-first": "1.1.1"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/once": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz",
+      "integrity": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==",
+      "license": "ISC",
+      "dependencies": {
+        "wrappy": "1"
+      }
+    },
+    "node_modules/parseurl": {
+      "version": "1.3.3",
+      "resolved": "https://registry.npmjs.org/parseurl/-/parseurl-1.3.3.tgz",
+      "integrity": "sha512-CiyeOxFT/JZyN5m0z9PfXw4SCBJ6Sygz1Dpl0wqjlhDEGGBP1GnsUVEL0p63hoG1fcj3fHynXi9NYO4nWOL+qQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/path-key": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz",
+      "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/path-to-regexp": {
+      "version": "8.2.0",
+      "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-8.2.0.tgz",
+      "integrity": "sha512-TdrF7fW9Rphjq4RjrW0Kp2AW0Ahwu9sRGTkS6bvDi0SCwZlEZYmcfDbEsTz8RVk0EHIS/Vd1bv3JhG+1xZuAyQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=16"
+      }
+    },
+    "node_modules/pkce-challenge": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/pkce-challenge/-/pkce-challenge-5.0.0.tgz",
+      "integrity": "sha512-ueGLflrrnvwB3xuo/uGob5pd5FN7l0MsLf0Z87o/UQmRtwjvfylfc9MurIxRAWywCYTgrvpXBcqjV4OfCYGCIQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=16.20.0"
+      }
+    },
+    "node_modules/proxy-addr": {
+      "version": "2.0.7",
+      "resolved": "https://registry.npmjs.org/proxy-addr/-/proxy-addr-2.0.7.tgz",
+      "integrity": "sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg==",
+      "license": "MIT",
+      "dependencies": {
+        "forwarded": "0.2.0",
+        "ipaddr.js": "1.9.1"
+      },
+      "engines": {
+        "node": ">= 0.10"
+      }
+    },
+    "node_modules/qs": {
+      "version": "6.14.0",
+      "resolved": "https://registry.npmjs.org/qs/-/qs-6.14.0.tgz",
+      "integrity": "sha512-YWWTjgABSKcvs/nWBi9PycY/JiPJqOD4JA6o9Sej2AtvSGarXxKC3OQSk4pAarbdQlKAh5D4FCQkJNkW+GAn3w==",
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "side-channel": "^1.1.0"
+      },
+      "engines": {
+        "node": ">=0.6"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/range-parser": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/range-parser/-/range-parser-1.2.1.tgz",
+      "integrity": "sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/raw-body": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/raw-body/-/raw-body-3.0.0.tgz",
+      "integrity": "sha512-RmkhL8CAyCRPXCE28MMH0z2PNWQBNk2Q09ZdxM9IOOXwxwZbN+qbWaatPkdkWIKL2ZVDImrN/pK5HTRz2PcS4g==",
+      "license": "MIT",
+      "dependencies": {
+        "bytes": "3.1.2",
+        "http-errors": "2.0.0",
+        "iconv-lite": "0.6.3",
+        "unpipe": "1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/require-from-string": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/require-from-string/-/require-from-string-2.0.2.tgz",
+      "integrity": "sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/resolve-pkg-maps": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/resolve-pkg-maps/-/resolve-pkg-maps-1.0.0.tgz",
+      "integrity": "sha512-seS2Tj26TBVOC2NIc2rOe2y2ZO7efxITtLZcGSOnHHNOQ7CkiUBfw0Iw2ck6xkIhPwLhKNLS8BO+hEpngQlqzw==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/privatenumber/resolve-pkg-maps?sponsor=1"
+      }
+    },
+    "node_modules/router": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/router/-/router-2.2.0.tgz",
+      "integrity": "sha512-nLTrUKm2UyiL7rlhapu/Zl45FwNgkZGaCpZbIHajDYgwlJCOzLSk+cIPAnsEqV955GjILJnKbdQC1nVPz+gAYQ==",
+      "license": "MIT",
+      "dependencies": {
+        "debug": "^4.4.0",
+        "depd": "^2.0.0",
+        "is-promise": "^4.0.0",
+        "parseurl": "^1.3.3",
+        "path-to-regexp": "^8.0.0"
+      },
+      "engines": {
+        "node": ">= 18"
+      }
+    },
+    "node_modules/safe-buffer": {
+      "version": "5.2.1",
+      "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz",
+      "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/feross"
+        },
+        {
+          "type": "patreon",
+          "url": "https://www.patreon.com/feross"
+        },
+        {
+          "type": "consulting",
+          "url": "https://feross.org/support"
+        }
+      ],
+      "license": "MIT"
+    },
+    "node_modules/safer-buffer": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz",
+      "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==",
+      "license": "MIT"
+    },
+    "node_modules/send": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/send/-/send-1.2.0.tgz",
+      "integrity": "sha512-uaW0WwXKpL9blXE2o0bRhoL2EGXIrZxQ2ZQ4mgcfoBxdFmQold+qWsD2jLrfZ0trjKL6vOw0j//eAwcALFjKSw==",
+      "license": "MIT",
+      "dependencies": {
+        "debug": "^4.3.5",
+        "encodeurl": "^2.0.0",
+        "escape-html": "^1.0.3",
+        "etag": "^1.8.1",
+        "fresh": "^2.0.0",
+        "http-errors": "^2.0.0",
+        "mime-types": "^3.0.1",
+        "ms": "^2.1.3",
+        "on-finished": "^2.4.1",
+        "range-parser": "^1.2.1",
+        "statuses": "^2.0.1"
+      },
+      "engines": {
+        "node": ">= 18"
+      }
+    },
+    "node_modules/serve-static": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/serve-static/-/serve-static-2.2.0.tgz",
+      "integrity": "sha512-61g9pCh0Vnh7IutZjtLGGpTA355+OPn2TyDv/6ivP2h/AdAVX9azsoxmg2/M6nZeQZNYBEwIcsne1mJd9oQItQ==",
+      "license": "MIT",
+      "dependencies": {
+        "encodeurl": "^2.0.0",
+        "escape-html": "^1.0.3",
+        "parseurl": "^1.3.3",
+        "send": "^1.2.0"
+      },
+      "engines": {
+        "node": ">= 18"
+      }
+    },
+    "node_modules/setprototypeof": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/setprototypeof/-/setprototypeof-1.2.0.tgz",
+      "integrity": "sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw==",
+      "license": "ISC"
+    },
+    "node_modules/shebang-command": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz",
+      "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==",
+      "license": "MIT",
+      "dependencies": {
+        "shebang-regex": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/shebang-regex": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz",
+      "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/side-channel": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.1.0.tgz",
+      "integrity": "sha512-ZX99e6tRweoUXqR+VBrslhda51Nh5MTQwou5tnUDgbtyM0dBgmhEDtWGP/xbKn6hqfPRHujUNwz5fy/wbbhnpw==",
+      "license": "MIT",
+      "dependencies": {
+        "es-errors": "^1.3.0",
+        "object-inspect": "^1.13.3",
+        "side-channel-list": "^1.0.0",
+        "side-channel-map": "^1.0.1",
+        "side-channel-weakmap": "^1.0.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/side-channel-list": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/side-channel-list/-/side-channel-list-1.0.0.tgz",
+      "integrity": "sha512-FCLHtRD/gnpCiCHEiJLOwdmFP+wzCmDEkc9y7NsYxeF4u7Btsn1ZuwgwJGxImImHicJArLP4R0yX4c2KCrMrTA==",
+      "license": "MIT",
+      "dependencies": {
+        "es-errors": "^1.3.0",
+        "object-inspect": "^1.13.3"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/side-channel-map": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/side-channel-map/-/side-channel-map-1.0.1.tgz",
+      "integrity": "sha512-VCjCNfgMsby3tTdo02nbjtM/ewra6jPHmpThenkTYh8pG9ucZ/1P8So4u4FGBek/BjpOVsDCMoLA/iuBKIFXRA==",
+      "license": "MIT",
+      "dependencies": {
+        "call-bound": "^1.0.2",
+        "es-errors": "^1.3.0",
+        "get-intrinsic": "^1.2.5",
+        "object-inspect": "^1.13.3"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/side-channel-weakmap": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/side-channel-weakmap/-/side-channel-weakmap-1.0.2.tgz",
+      "integrity": "sha512-WPS/HvHQTYnHisLo9McqBHOJk2FkHO/tlpvldyrnem4aeQp4hai3gythswg6p01oSoTl58rcpiFAjF2br2Ak2A==",
+      "license": "MIT",
+      "dependencies": {
+        "call-bound": "^1.0.2",
+        "es-errors": "^1.3.0",
+        "get-intrinsic": "^1.2.5",
+        "object-inspect": "^1.13.3",
+        "side-channel-map": "^1.0.1"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/statuses": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/statuses/-/statuses-2.0.1.tgz",
+      "integrity": "sha512-RwNA9Z/7PrK06rYLIzFMlaF+l73iwpzsqRIFgbMLbTcLD6cOao82TaWefPXQvB2fOC4AjuYSEndS7N/mTCbkdQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/toidentifier": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/toidentifier/-/toidentifier-1.0.1.tgz",
+      "integrity": "sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.6"
+      }
+    },
+    "node_modules/tsx": {
+      "version": "4.19.4",
+      "resolved": "https://registry.npmjs.org/tsx/-/tsx-4.19.4.tgz",
+      "integrity": "sha512-gK5GVzDkJK1SI1zwHf32Mqxf2tSJkNx+eYcNly5+nHvWqXUJYUkWBQtKauoESz3ymezAI++ZwT855x5p5eop+Q==",
+      "license": "MIT",
+      "dependencies": {
+        "esbuild": "~0.25.0",
+        "get-tsconfig": "^4.7.5"
+      },
+      "bin": {
+        "tsx": "dist/cli.mjs"
+      },
+      "engines": {
+        "node": ">=18.0.0"
+      },
+      "optionalDependencies": {
+        "fsevents": "~2.3.3"
+      }
+    },
+    "node_modules/type-is": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/type-is/-/type-is-2.0.1.tgz",
+      "integrity": "sha512-OZs6gsjF4vMp32qrCbiVSkrFmXtG/AZhY3t0iAMrMBiAZyV9oALtXO8hsrHbMXF9x6L3grlFuwW2oAz7cav+Gw==",
+      "license": "MIT",
+      "dependencies": {
+        "content-type": "^1.0.5",
+        "media-typer": "^1.1.0",
+        "mime-types": "^3.0.0"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/typescript": {
+      "version": "5.8.3",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.8.3.tgz",
+      "integrity": "sha512-p1diW6TqL9L07nNxvRMM7hMMw4c5XOo/1ibL4aAIGmSAt9slTE1Xgw5KWuof2uTOvCg9BY7ZRi+GaF+7sfgPeQ==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "bin": {
+        "tsc": "bin/tsc",
+        "tsserver": "bin/tsserver"
+      },
+      "engines": {
+        "node": ">=14.17"
+      }
+    },
+    "node_modules/unpipe": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/unpipe/-/unpipe-1.0.0.tgz",
+      "integrity": "sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/vary": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/vary/-/vary-1.1.2.tgz",
+      "integrity": "sha512-BNGbWLfd0eUPabhkXUVm0j8uuvREyTh5ovRa/dyow/BqAbZJyC+5fU+IzQOzmAKzYqYRAISoRhdQr3eIZ/PXqg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/which": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz",
+      "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==",
+      "license": "ISC",
+      "dependencies": {
+        "isexe": "^2.0.0"
+      },
+      "bin": {
+        "node-which": "bin/node-which"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/wrappy": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",
+      "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==",
+      "license": "ISC"
+    },
+    "node_modules/zod": {
+      "version": "3.25.17",
+      "resolved": "https://registry.npmjs.org/zod/-/zod-3.25.17.tgz",
+      "integrity": "sha512-8hQzQ/kMOIFbwOgPrm9Sf9rtFHpFUMy4HvN0yEB0spw14aYi0uT5xG5CE2DB9cd51GWNsz+DNO7se1kztHMKnw==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/colinhacks"
+      }
+    },
+    "node_modules/zod-to-json-schema": {
+      "version": "3.24.5",
+      "resolved": "https://registry.npmjs.org/zod-to-json-schema/-/zod-to-json-schema-3.24.5.tgz",
+      "integrity": "sha512-/AuWwMP+YqiPbsJx5D6TfgRTc4kTLjsh5SOcd4bLsfUg2RcEXrFMJl1DGgdHy2aCfsIA/cr/1JM0xcB2GZji8g==",
+      "license": "ISC",
+      "peerDependencies": {
+        "zod": "^3.24.1"
+      }
+    }
+  }
+}
diff --git a/scripts/mcp-tests/package.json b/scripts/mcp-tests/package.json
new file mode 100644
index 00000000000..722d9297df1
--- /dev/null
+++ b/scripts/mcp-tests/package.json
@@ -0,0 +1,20 @@
+{
+  "name": "mcp-tests",
+  "version": "1.0.0",
+  "main": "index.js",
+  "type": "module",
+  "scripts": {
+    "test": "tsx ./gemini-smoke-test.ts"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "description": "",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.11.5",
+    "tsx": "^4.19.4"
+  },
+  "devDependencies": {
+    "typescript": "^5.8.3"
+  }
+}
diff --git a/scripts/mcp-tests/tsconfig.json b/scripts/mcp-tests/tsconfig.json
new file mode 100644
index 00000000000..5ac568d3134
--- /dev/null
+++ b/scripts/mcp-tests/tsconfig.json
@@ -0,0 +1,7 @@
+{
+  "compilerOptions": {
+    "target": "es2022",
+    "module": "NodeNext",
+    "skipLibCheck": true
+  }
+}
diff --git a/scripts/publish/firebase-docker-image/cloudbuild.yaml b/scripts/publish/firebase-docker-image/cloudbuild.yaml
index 8b34ace80bc..0bfdbbc1ab4 100644
--- a/scripts/publish/firebase-docker-image/cloudbuild.yaml
+++ b/scripts/publish/firebase-docker-image/cloudbuild.yaml
@@ -13,7 +13,7 @@ steps:
     entrypoint: "sh"
     args:
       - "-c"
-      - "docker build -t us-docker.pkg.dev/$PROJECT_ID/us/firebase:$(cat /workspace/version_number.txt) -t us-docker.pkg.dev/$PROJECT_ID/us/firebase:latest -f ./Dockerfile ."
+      - "docker build -t us-docker.pkg.dev/$PROJECT_ID/us/firebase:$(cat /workspace/version_number.txt) -t us-docker.pkg.dev/$PROJECT_ID/us/firebase:latest -t us-docker.pkg.dev/$PROJECT_ID/us/firebase:public-image-$(cat /workspace/version_number.txt) -f ./Dockerfile ."
 
 images:
   - "us-docker.pkg.dev/$PROJECT_ID/us/firebase"
diff --git a/src/api.ts b/src/api.ts
index b76c2185d48..66e1c0cc173 100755
--- a/src/api.ts
+++ b/src/api.ts
@@ -125,6 +125,10 @@ export const rtdbMetadataOrigin = () =>
   utils.envOverride("FIREBASE_RTDB_METADATA_URL", "https://metadata-dot-firebase-prod.appspot.com");
 export const remoteConfigApiOrigin = () =>
   utils.envOverride("FIREBASE_REMOTE_CONFIG_URL", "https://firebaseremoteconfig.googleapis.com");
+export const messagingApiOrigin = () =>
+  utils.envOverride("FIREBASE_MESSAGING_CONFIG_URL", "https://fcm.googleapis.com");
+export const crashlyticsApiOrigin = () =>
+  utils.envOverride("FIREBASE_CRASHLYTICS_URL", "https://firebasecrashlytics.googleapis.com");
 export const resourceManagerOrigin = () =>
   utils.envOverride("FIREBASE_RESOURCEMANAGER_URL", "https://cloudresourcemanager.googleapis.com");
 export const rulesOrigin = () =>
@@ -165,6 +169,8 @@ export const cloudSQLAdminOrigin = () =>
   utils.envOverride("CLOUD_SQL_URL", "https://sqladmin.googleapis.com");
 export const vertexAIOrigin = () =>
   utils.envOverride("VERTEX_AI_URL", "https://aiplatform.googleapis.com");
+export const cloudAiCompanionOrigin = () =>
+  utils.envOverride("CLOUD_AI_COMPANION_URL", "https://cloudaicompanion.googleapis.com");
 
 /** Gets scopes that have been set. */
 export function getScopes(): string[] {
diff --git a/src/apphosting/backend.ts b/src/apphosting/backend.ts
index 66d37afedb1..c675a75b8e2 100644
--- a/src/apphosting/backend.ts
+++ b/src/apphosting/backend.ts
@@ -14,7 +14,7 @@ import {
   secretManagerOrigin,
 } from "../api";
 import { Backend, BackendOutputOnlyFields, API_VERSION } from "../gcp/apphosting";
-import { addServiceAccountToRoles } from "../gcp/resourceManager";
+import { addServiceAccountToRoles, getIamPolicy } from "../gcp/resourceManager";
 import * as iam from "../gcp/iam";
 import { FirebaseError, getErrStatus, getError } from "../error";
 import { input, confirm, select, checkbox, search, Choice } from "../prompt";
@@ -76,14 +76,7 @@ export async function doSetup(
   webAppName: string | null,
   serviceAccount: string | null,
 ): Promise<void> {
-  await Promise.all([
-    ensure(projectId, developerConnectOrigin(), "apphosting", true),
-    ensure(projectId, cloudbuildOrigin(), "apphosting", true),
-    ensure(projectId, secretManagerOrigin(), "apphosting", true),
-    ensure(projectId, cloudRunApiOrigin(), "apphosting", true),
-    ensure(projectId, artifactRegistryDomain(), "apphosting", true),
-    ensure(projectId, iamOrigin(), "apphosting", true),
-  ]);
+  await ensureRequiredApisEnabled(projectId);
 
   // Hack: Because IAM can take ~45 seconds to propagate, we provision the service account as soon as
   // possible to reduce the likelihood that the subsequent Cloud Build fails. See b/336862200.
@@ -179,6 +172,44 @@ export async function doSetup(
   logSuccess(`Your backend is now deployed at:\n\thttps://${backend.uri}`);
 }
 
+/**
+ * Setup up a new App Hosting backend to deploy from source.
+ */
+export async function doSetupSourceDeploy(
+  projectId: string,
+  backendId: string,
+): Promise<{ backend: Backend; location: string }> {
+  const location = await promptLocation(
+    projectId,
+    "Select a primary region to host your backend:\n",
+  );
+  const webApp = await webApps.getOrCreateWebApp(projectId, null, backendId);
+  if (!webApp) {
+    logWarning(`Firebase web app not set`);
+  }
+  const createBackendSpinner = ora("Creating your new backend...").start();
+  const backend = await createBackend(projectId, location, backendId, null, undefined, webApp?.id);
+  createBackendSpinner.succeed(`Successfully created backend!\n\t${backend.name}\n`);
+  return {
+    backend,
+    location,
+  };
+}
+
+/**
+ * Check that all GCP APIs required for App Hosting are enabled.
+ */
+export async function ensureRequiredApisEnabled(projectId: string): Promise<void> {
+  await Promise.all([
+    ensure(projectId, developerConnectOrigin(), "apphosting", true),
+    ensure(projectId, cloudbuildOrigin(), "apphosting", true),
+    ensure(projectId, secretManagerOrigin(), "apphosting", true),
+    ensure(projectId, cloudRunApiOrigin(), "apphosting", true),
+    ensure(projectId, artifactRegistryDomain(), "apphosting", true),
+    ensure(projectId, iamOrigin(), "apphosting", true),
+  ]);
+}
+
 /**
  * Set up a new App Hosting-type Developer Connect GitRepoLink, optionally with a specific connection ID
  */
@@ -218,6 +249,7 @@ export async function createGitRepoLink(
 export async function ensureAppHostingComputeServiceAccount(
   projectId: string,
   serviceAccount: string | null,
+  deployFromSource = false,
 ): Promise<void> {
   const sa = serviceAccount || defaultComputeServiceAccountEmail(projectId);
   const name = `projects/${projectId}/serviceAccounts/${sa}`;
@@ -242,6 +274,29 @@ export async function ensureAppHostingComputeServiceAccount(
       );
     }
   }
+  // N.B. To deploy from source, the App Hosting Compute Service Account must have
+  // the storage.objectViewer IAM role. For firebase-tools <= 14.3.0, the CLI does
+  // not add the objectViewer role, which means all existing customers will need to
+  // add it before deploying from source.
+  if (deployFromSource) {
+    const policy = await getIamPolicy(projectId);
+    const objectViewerBinding = policy.bindings.find(
+      (binding) => binding.role === "roles/storage.objectViewer",
+    );
+    if (
+      !objectViewerBinding ||
+      !objectViewerBinding.members.includes(
+        `serviceAccount:${defaultComputeServiceAccountEmail(projectId)}`,
+      )
+    ) {
+      await addServiceAccountToRoles(
+        projectId,
+        defaultComputeServiceAccountEmail(projectId),
+        ["roles/storage.objectViewer"],
+        /* skipAccountLookup= */ true,
+      );
+    }
+  }
 }
 
 /**
@@ -333,6 +388,7 @@ async function provisionDefaultComputeServiceAccount(projectId: string): Promise
       "roles/firebaseapphosting.computeRunner",
       "roles/firebase.sdkAdminServiceAgent",
       "roles/developerconnect.readTokenAccessor",
+      "roles/storage.objectViewer",
     ],
     /* skipAccountLookup= */ true,
   );
diff --git a/src/apphosting/secrets/dialogs.spec.ts b/src/apphosting/secrets/dialogs.spec.ts
index 656ff0e94a6..7b0b8a6767c 100644
--- a/src/apphosting/secrets/dialogs.spec.ts
+++ b/src/apphosting/secrets/dialogs.spec.ts
@@ -34,9 +34,9 @@ describe("dialogs", () => {
   };
 
   describe("toMetadata", () => {
-    it("handles explicit account", () => {
+    it("handles explicit account", async () => {
       // Note: passing in out of order to verify the results are sorted.
-      const metadata = dialogs.toMetadata("number", [modernA2, modernA]);
+      const metadata = await dialogs.toMetadata("number", [modernA2, modernA]);
 
       expect(metadata).to.deep.equal([
         { location: "l", id: "modernA", buildServiceAccount: "a", runServiceAccount: "a" },
@@ -44,26 +44,26 @@ describe("dialogs", () => {
       ]);
     });
 
-    it("handles fallback for legacy SAs", () => {
-      const metadata = dialogs.toMetadata("number", [modernA, legacy]);
+    it("handles fallback for legacy SAs", async () => {
+      const metadata = await dialogs.toMetadata("number", [modernA, legacy]);
 
       expect(metadata).to.deep.equal([
         {
           location: "l",
           id: "legacy",
-          ...secrets.serviceAccountsForBackend("number", legacy),
+          ...(await secrets.serviceAccountsForBackend("number", legacy)),
         },
         { location: "l", id: "modernA", buildServiceAccount: "a", runServiceAccount: "a" },
       ]);
     });
 
-    it("sorts by location first and id second", () => {
-      const metadata = dialogs.toMetadata("number", [legacy, modernA, modernA2]);
+    it("sorts by location first and id second", async () => {
+      const metadata = await dialogs.toMetadata("number", [legacy, modernA, modernA2]);
       expect(metadata).to.deep.equal([
         {
           location: "l",
           id: "legacy",
-          ...secrets.serviceAccountsForBackend("number", legacy),
+          ...(await secrets.serviceAccountsForBackend("number", legacy)),
         },
         { location: "l", id: "modernA", buildServiceAccount: "a", runServiceAccount: "a" },
         { location: "l2", id: "modernA2", buildServiceAccount: "a", runServiceAccount: "a" },
@@ -81,8 +81,10 @@ describe("dialogs", () => {
   });
 
   describe("tableForBackends", () => {
-    it("uses 'service account' header if all backends use one service account", () => {
-      const table = dialogs.tableForBackends(dialogs.toMetadata("number", [modernA, modernB]));
+    it("uses 'service account' header if all backends use one service account", async () => {
+      const table = dialogs.tableForBackends(
+        await dialogs.toMetadata("number", [modernA, modernB]),
+      );
       expect(table[0]).to.deep.equal(["location", "backend", "service account"]);
       expect(table[1]).to.deep.equal([
         ["l", "modernA", "a"],
@@ -90,9 +92,9 @@ describe("dialogs", () => {
       ]);
     });
 
-    it("uses 'service accounts' header if any backend uses more than one service accont", () => {
-      const table = dialogs.tableForBackends(dialogs.toMetadata("number", [legacy, modernA]));
-      const legacyAccounts = secrets.serviceAccountsForBackend("number", legacy);
+    it("uses 'service accounts' header if any backend uses more than one service accont", async () => {
+      const table = dialogs.tableForBackends(await dialogs.toMetadata("number", [legacy, modernA]));
+      const legacyAccounts = await secrets.serviceAccountsForBackend("number", legacy);
       expect(table[0]).to.deep.equal(["location", "backend", "service accounts"]);
       expect(table[1]).to.deep.equal([
         [
@@ -219,7 +221,7 @@ describe("dialogs", () => {
         unreachable: [],
       });
       prompt.confirm.resolves(true);
-      const accounts = secrets.serviceAccountsForBackend("number", legacy);
+      const accounts = await secrets.serviceAccountsForBackend("number", legacy);
 
       await expect(
         dialogs.selectBackendServiceAccounts("number", "id", {}),
@@ -248,7 +250,7 @@ describe("dialogs", () => {
         unreachable: [],
       });
       prompt.confirm.resolves(false);
-      const legacyAccounts = secrets.serviceAccountsForBackend("number", legacy);
+      const legacyAccounts = await secrets.serviceAccountsForBackend("number", legacy);
 
       await expect(
         dialogs.selectBackendServiceAccounts("number", "id", {}),
@@ -337,7 +339,7 @@ describe("dialogs", () => {
         unreachable: [],
       });
       prompt.checkbox.resolves(["a", "b"]);
-      const legacyAccounts = secrets.serviceAccountsForBackend("number", legacy);
+      const legacyAccounts = await secrets.serviceAccountsForBackend("number", legacy);
 
       await expect(
         dialogs.selectBackendServiceAccounts("number", "id", {}),
@@ -365,7 +367,7 @@ describe("dialogs", () => {
         unreachable: [],
       });
       prompt.checkbox.resolves([]);
-      const legacyAccounts = secrets.serviceAccountsForBackend("number", legacy);
+      const legacyAccounts = await secrets.serviceAccountsForBackend("number", legacy);
 
       await expect(
         dialogs.selectBackendServiceAccounts("number", "id", {}),
diff --git a/src/apphosting/secrets/dialogs.ts b/src/apphosting/secrets/dialogs.ts
index 4f87958dfc2..50e8e74269c 100644
--- a/src/apphosting/secrets/dialogs.ts
+++ b/src/apphosting/secrets/dialogs.ts
@@ -20,15 +20,15 @@ interface BackendMetadata {
 /**
  * Creates sorted BackendMetadata for a list of Backends.
  */
-export function toMetadata(
+export async function toMetadata(
   projectNumber: string,
   backends: apphosting.Backend[],
-): BackendMetadata[] {
+): Promise<BackendMetadata[]> {
   const metadata: BackendMetadata[] = [];
   for (const backend of backends) {
     // Splits format projects/<unused>/locations/<location>/backends/<id>
     const [, , , location, , id] = backend.name.split("/");
-    metadata.push({ location, id, ...serviceAccountsForBackend(projectNumber, backend) });
+    metadata.push({ location, id, ...(await serviceAccountsForBackend(projectNumber, backend)) });
   }
   return metadata.sort((left, right) => {
     const cmplocation = left.location.localeCompare(right.location);
@@ -140,13 +140,13 @@ export async function selectBackendServiceAccounts(
         "To use this secret, your backend's service account must be granted access. Would you like to grant access now?",
     });
     if (grant) {
-      return toMulti(serviceAccountsForBackend(projectNumber, listBackends.backends[0]));
+      return toMulti(await serviceAccountsForBackend(projectNumber, listBackends.backends[0]));
     }
     utils.logBullet(GRANT_ACCESS_IN_FUTURE);
     return { buildServiceAccounts: [], runServiceAccounts: [] };
   }
 
-  const metadata: BackendMetadata[] = toMetadata(projectNumber, listBackends.backends);
+  const metadata: BackendMetadata[] = await toMetadata(projectNumber, listBackends.backends);
 
   if (metadata.every(matchesServiceAccounts(metadata[0]))) {
     utils.logBullet("To use this secret, your backend's service account must be granted access.");
diff --git a/src/apphosting/secrets/index.spec.ts b/src/apphosting/secrets/index.spec.ts
index 3f969967bae..810f38e6439 100644
--- a/src/apphosting/secrets/index.spec.ts
+++ b/src/apphosting/secrets/index.spec.ts
@@ -33,21 +33,21 @@ describe("secrets", () => {
   });
 
   describe("serviceAccountsForbackend", () => {
-    it("uses explicit account", () => {
+    it("uses explicit account", async () => {
       const backend = {
         serviceAccount: "sa",
       } as any as apphosting.Backend;
-      expect(secrets.serviceAccountsForBackend("number", backend)).to.deep.equal({
+      expect(await secrets.serviceAccountsForBackend("number", backend)).to.deep.equal({
         buildServiceAccount: "sa",
         runServiceAccount: "sa",
       });
     });
 
-    it("has a fallback for legacy SAs", () => {
+    it("has a fallback for legacy SAs", async () => {
       const backend = {} as any as apphosting.Backend;
-      expect(secrets.serviceAccountsForBackend("number", backend)).to.deep.equal({
+      expect(await secrets.serviceAccountsForBackend("number", backend)).to.deep.equal({
         buildServiceAccount: gcb.getDefaultServiceAccount("number"),
-        runServiceAccount: gce.getDefaultServiceAccount("number"),
+        runServiceAccount: await gce.getDefaultServiceAccount("number"),
       });
     });
   });
diff --git a/src/apphosting/secrets/index.ts b/src/apphosting/secrets/index.ts
index 481f4124926..54b14380f49 100644
--- a/src/apphosting/secrets/index.ts
+++ b/src/apphosting/secrets/index.ts
@@ -42,10 +42,10 @@ export function toMulti(accounts: ServiceAccounts): MultiServiceAccounts {
  * Finds the explicit service account used for a backend or, for legacy cases,
  * the defaults for GCB and compute.
  */
-export function serviceAccountsForBackend(
+export async function serviceAccountsForBackend(
   projectNumber: string,
   backend: apphosting.Backend,
-): ServiceAccounts {
+): Promise<ServiceAccounts> {
   if (backend.serviceAccount) {
     return {
       buildServiceAccount: backend.serviceAccount,
@@ -53,8 +53,8 @@ export function serviceAccountsForBackend(
     };
   }
   return {
-    buildServiceAccount: gcb.getDefaultServiceAccount(projectNumber),
-    runServiceAccount: gce.getDefaultServiceAccount(projectNumber),
+    buildServiceAccount: gcb.getDefaultServiceAccount(projectNumber), // TOOD: Look this up via API
+    runServiceAccount: await gce.getDefaultServiceAccount(projectNumber),
   };
 }
 
diff --git a/src/auth.ts b/src/auth.ts
index ca5ac502130..8bdbe6b2d8b 100644
--- a/src/auth.ts
+++ b/src/auth.ts
@@ -105,6 +105,23 @@ export function getAllAccounts(): Account[] {
   return res;
 }
 
+/**
+ * Throw an error if the provided email is not a signed-in user.
+ */
+export function assertAccount(email: string, options?: { mcp?: boolean }) {
+  const allAccounts = getAllAccounts();
+  const accountExists = allAccounts.some((a) => a.user.email === email);
+  if (!accountExists) {
+    throw new FirebaseError(
+      `Account ${email} does not exist, ${
+        options?.mcp
+          ? `use the 'firebase_get_environment' tool to see available accounts or instruct the user to use the 'firebase login:add' terminal command to add a new account.`
+          : `run "${clc.bold("firebase login:list")} to see valid accounts`
+      }`,
+    );
+  }
+}
+
 /**
  * Set the globally active account. Modifies the options object
  * and sets global refresh token state.
@@ -210,7 +227,19 @@ export function setProjectAccount(projectDir: string, email: string) {
 /**
  * Set the global default account.
  */
-export function setGlobalDefaultAccount(account: Account) {
+export function setGlobalDefaultAccount(accountOrEmail: string | Account) {
+  let account: Account;
+  if (typeof accountOrEmail === "string") {
+    const accountFromEmail = getAllAccounts().find((acc) => acc.user.email === accountOrEmail)!;
+    if (!accountFromEmail)
+      throw new FirebaseError(
+        `Account '${accountOrEmail}' is not a signed-in user on this device.`,
+      );
+    account = accountFromEmail;
+  } else {
+    account = accountOrEmail;
+  }
+
   configstore.set("user", account.user);
   configstore.set("tokens", account.tokens);
 
diff --git a/src/bin/mcp.ts b/src/bin/mcp.ts
index 1ca0f208406..b166e377eb8 100644
--- a/src/bin/mcp.ts
+++ b/src/bin/mcp.ts
@@ -4,6 +4,8 @@ import { useFileLogger } from "../logger";
 import { FirebaseMcpServer } from "../mcp/index";
 import { parseArgs } from "util";
 import { SERVER_FEATURES, ServerFeature } from "../mcp/types";
+import { markdownDocsOfTools } from "../mcp/tools/index.js";
+import { resolve } from "path";
 
 const STARTUP_MESSAGE = `
 This is a running process of the Firebase MCP server. This command should only be executed by an MCP client. An example MCP client configuration might be:
@@ -23,14 +25,22 @@ export async function mcp(): Promise<void> {
     options: {
       only: { type: "string", default: "" },
       dir: { type: "string" },
+      "generate-tool-list": { type: "boolean", default: false },
     },
     allowPositionals: true,
   });
+  if (values["generate-tool-list"]) {
+    console.log(markdownDocsOfTools());
+    return;
+  }
   useFileLogger();
   const activeFeatures = (values.only || "")
     .split(",")
     .filter((f) => SERVER_FEATURES.includes(f as ServerFeature)) as ServerFeature[];
-  const server = new FirebaseMcpServer({ activeFeatures, projectRoot: values.dir });
+  const server = new FirebaseMcpServer({
+    activeFeatures,
+    projectRoot: values.dir ? resolve(values.dir) : undefined,
+  });
   await server.start();
   if (process.stdin.isTTY) process.stderr.write(STARTUP_MESSAGE);
 }
diff --git a/src/checkValidTargetFilters.ts b/src/checkValidTargetFilters.ts
index 211deeaf33d..46ee10a9ebf 100644
--- a/src/checkValidTargetFilters.ts
+++ b/src/checkValidTargetFilters.ts
@@ -30,6 +30,7 @@ const FILTERABLE_TARGETS = new Set([
   "storage",
   "database",
   "dataconnect",
+  "apphosting",
 ]);
 
 /**
diff --git a/src/command.ts b/src/command.ts
index e01858a964a..325654c7953 100644
--- a/src/command.ts
+++ b/src/command.ts
@@ -311,7 +311,7 @@ export class Command {
 
     if (getInheritedOption(options, "json")) {
       options.nonInteractive = true;
-    } else {
+    } else if (!options.isMCP) {
       useConsoleLoggers();
     }
 
diff --git a/src/commands/apphosting-secrets-grantaccess.ts b/src/commands/apphosting-secrets-grantaccess.ts
index ad495f29d11..cf7b500074a 100644
--- a/src/commands/apphosting-secrets-grantaccess.ts
+++ b/src/commands/apphosting-secrets-grantaccess.ts
@@ -71,7 +71,9 @@ export const command = new Command("apphosting:secrets:grantaccess <secretNames>
       backend = await apphosting.getBackend(projectId, location, backendId);
     }
 
-    const accounts = secrets.toMulti(secrets.serviceAccountsForBackend(projectNumber, backend));
+    const accounts = secrets.toMulti(
+      await secrets.serviceAccountsForBackend(projectNumber, backend),
+    );
 
     await Promise.allSettled(
       secretList.map((secretName) =>
diff --git a/src/commands/deploy.ts b/src/commands/deploy.ts
index 322d18cadd8..5b3e036138b 100644
--- a/src/commands/deploy.ts
+++ b/src/commands/deploy.ts
@@ -23,6 +23,7 @@ export const VALID_DEPLOY_TARGETS = [
   "remoteconfig",
   "extensions",
   "dataconnect",
+  "apphosting",
 ];
 export const TARGET_PERMISSIONS: Record<(typeof VALID_DEPLOY_TARGETS)[number], string[]> = {
   database: ["firebasedatabase.instances.update"],
diff --git a/src/commands/init.ts b/src/commands/init.ts
index 358f017876b..11b6f98fe07 100644
--- a/src/commands/init.ts
+++ b/src/commands/init.ts
@@ -48,7 +48,7 @@ let choices: {
   },
   {
     value: "apphosting",
-    name: "App Hosting: Configure an apphosting.yaml file for App Hosting",
+    name: "App Hosting: Enable web app deployments with App Hosting",
     checked: false,
     hidden: false,
   },
@@ -230,12 +230,9 @@ export async function initAction(feature: string, options: Options): Promise<voi
   await init(setup, config, options);
 
   logger.info();
-  utils.logBullet("Writing configuration info to " + clc.bold("firebase.json") + "...");
   config.writeProjectFile("firebase.json", setup.config);
-  utils.logBullet("Writing project information to " + clc.bold(".firebaserc") + "...");
   config.writeProjectFile(".firebaserc", setup.rcfile);
   if (!fsutils.fileExistsSync(config.path(".gitignore"))) {
-    utils.logBullet("Writing gitignore file to " + clc.bold(".gitignore") + "...");
     config.writeProjectFile(".gitignore", GITIGNORE_TEMPLATE);
   }
   logger.info();
diff --git a/src/commands/login-use.ts b/src/commands/login-use.ts
index 15ea0f04fbd..93338e669b7 100644
--- a/src/commands/login-use.ts
+++ b/src/commands/login-use.ts
@@ -1,5 +1,3 @@
-import * as clc from "colorette";
-
 import { Command } from "../command";
 import * as utils from "../utils";
 import * as auth from "../auth";
@@ -10,16 +8,7 @@ export const command = new Command("login:use <email>")
     "set the default account to use for this project directory or the global default account if not in a Firebase project directory",
   )
   .action((email: string, options: any) => {
-    const allAccounts = auth.getAllAccounts();
-    const accountExists = allAccounts.some((a) => a.user.email === email);
-    if (!accountExists) {
-      throw new FirebaseError(
-        `Account ${email} does not exist, run "${clc.bold(
-          "firebase login:list",
-        )}" to see valid accounts`,
-      );
-    }
-
+    auth.assertAccount(email);
     const projectDir = options.projectRoot as string | null;
 
     // if current directory is a Firebase project directory, set the default account for this project directory
@@ -37,22 +26,13 @@ export const command = new Command("login:use <email>")
       if (options.user.email === email) {
         throw new FirebaseError(`Already using account ${email} for the global default account.`);
       }
-      const newDefaultAccount = allAccounts.find((a) => a.user.email === email);
-      if (!newDefaultAccount) {
-        // should never happen
-        throw new FirebaseError(
-          `Account ${email} does not exist, run "${clc.bold(
-            "firebase login:list",
-          )}" to see valid accounts`,
-        );
-      }
       const oldDefaultAccount = auth.getGlobalDefaultAccount();
       if (!oldDefaultAccount) {
         // should never happen
         throw new FirebaseError("Could not determine global default account");
       }
       // set new default account and removes it from additional accounts
-      auth.setGlobalDefaultAccount(newDefaultAccount);
+      auth.setGlobalDefaultAccount(email);
       // add old default account as additional account
       auth.addAdditionalAccount(oldDefaultAccount);
 
diff --git a/src/config.ts b/src/config.ts
index 2b5c46a9bea..ab7cd7e188d 100644
--- a/src/config.ts
+++ b/src/config.ts
@@ -216,13 +216,21 @@ export class Config {
     }
   }
 
-  writeProjectFile(p: string, content: any) {
-    if (typeof content !== "string") {
-      content = JSON.stringify(content, null, 2) + "\n";
+  writeProjectFile(p: string, content: any): void {
+    const path = this.path(p);
+    fs.ensureFileSync(path);
+    fs.writeFileSync(path, stringifyContent(content), "utf8");
+    switch (p) {
+      case "firebase.json":
+        utils.logSuccess("Wrote configuration info to " + clc.bold("firebase.json"));
+        break;
+      case ".firebaserc":
+        utils.logSuccess("Wrote project information to " + clc.bold(".firebaserc"));
+        break;
+      default:
+        utils.logSuccess("Wrote " + clc.bold(p));
+        break;
     }
-
-    fs.ensureFileSync(this.path(p));
-    fs.writeFileSync(this.path(p), content, "utf8");
   }
 
   projectFileExists(p: string): boolean {
@@ -233,36 +241,45 @@ export class Config {
     fs.removeSync(this.path(p));
   }
 
-  async askWriteProjectFile(
+  async confirmWriteProjectFile(
     path: string,
     content: any,
-    force?: boolean,
     confirmByDefault?: boolean,
-  ): Promise<void> {
+  ): Promise<boolean> {
     const writeTo = this.path(path);
-    let next = true;
-    if (typeof content !== "string") {
-      content = JSON.stringify(content, null, 2) + "\n";
+    if (!fsutils.fileExistsSync(writeTo)) {
+      return true;
     }
-    let existingContent: string | undefined;
-    if (fsutils.fileExistsSync(writeTo)) {
-      existingContent = fsutils.readFile(writeTo);
+    const existingContent = fsutils.readFile(writeTo);
+    const newContent = stringifyContent(content);
+    if (existingContent === newContent) {
+      utils.logBullet(clc.bold(path) + " is unchanged");
+      return false;
     }
-    if (existingContent && existingContent !== content && !force) {
-      next = await confirm({
-        message: "File " + clc.underline(path) + " already exists. Overwrite?",
-        default: !!confirmByDefault,
-      });
+    const shouldWrite = await confirm({
+      message: "File " + clc.underline(path) + " already exists. Overwrite?",
+      default: !!confirmByDefault,
+    });
+    if (!shouldWrite) {
+      utils.logBullet("Skipping write of " + clc.bold(path));
+      return false;
     }
+    return true;
+  }
 
-    if (existingContent === content) {
-      utils.logBullet(clc.bold(path) + " is unchanged");
-    } else if (next) {
-      this.writeProjectFile(path, content);
-      utils.logSuccess("Wrote " + clc.bold(path));
-    } else {
-      utils.logBullet("Skipping write of " + clc.bold(path));
+  async askWriteProjectFile(
+    path: string,
+    content: any,
+    force?: boolean,
+    confirmByDefault?: boolean,
+  ): Promise<void> {
+    if (!force) {
+      const shouldWrite = await this.confirmWriteProjectFile(path, content, confirmByDefault);
+      if (!shouldWrite) {
+        return;
+      }
     }
+    this.writeProjectFile(path, content);
   }
 
   public static load(options: any, allowMissing?: boolean): Config | null {
@@ -304,3 +321,10 @@ export class Config {
     });
   }
 }
+
+function stringifyContent(content: any): string {
+  if (typeof content === "string") {
+    return content;
+  }
+  return JSON.stringify(content, null, 2) + "\n";
+}
diff --git a/src/crashlytics/listTopIssues.ts b/src/crashlytics/listTopIssues.ts
new file mode 100644
index 00000000000..59eb1847710
--- /dev/null
+++ b/src/crashlytics/listTopIssues.ts
@@ -0,0 +1,53 @@
+import { Client } from "../apiv2";
+import { logger } from "../logger";
+import { FirebaseError } from "../error";
+import { crashlyticsApiOrigin } from "../api";
+
+const TIMEOUT = 10000;
+
+const apiClient = new Client({
+  urlPrefix: crashlyticsApiOrigin(),
+  apiVersion: "v1alpha",
+});
+
+export async function listTopIssues(
+  projectId: string,
+  appId: string,
+  issueCount: number,
+): Promise<string> {
+  try {
+    const queryParams = new URLSearchParams();
+    queryParams.set("page_size", `${issueCount}`);
+
+    const requestProjectId = parseProjectId(appId);
+    if (requestProjectId === undefined) {
+      throw new FirebaseError("Unable to get the projectId from the AppId.");
+    }
+
+    const response = await apiClient.request<void, string>({
+      method: "GET",
+      headers: {
+        "Content-Type": "application/json",
+      },
+      path: `/projects/${requestProjectId}/apps/${appId}/reports/topIssues`,
+      queryParams: queryParams,
+      timeout: TIMEOUT,
+    });
+
+    return response.body;
+  } catch (err: any) {
+    logger.debug(err.message);
+    throw new FirebaseError(
+      `Failed to fetch the top issues for the Firebase Project ${projectId}, AppId ${appId}. Error: ${err}.`,
+      { original: err },
+    );
+  }
+}
+
+function parseProjectId(appId: string): string | undefined {
+  const appIdParts = appId.split(":");
+  if (appIdParts.length > 1) {
+    return appIdParts[1];
+  }
+  return undefined;
+}
diff --git a/src/dataconnect/cloudAICompanionClient.ts b/src/dataconnect/cloudAICompanionClient.ts
new file mode 100644
index 00000000000..1e6544b2b60
--- /dev/null
+++ b/src/dataconnect/cloudAICompanionClient.ts
@@ -0,0 +1,106 @@
+import { Client } from "../apiv2";
+import { cloudAiCompanionOrigin } from "../api";
+import {
+  CloudAICompanionResponse,
+  CloudAICompanionRequest,
+  CloudAICompanionInput,
+  ClientContext,
+  CallCloudAiCompanionRequest,
+} from "./cloudAICompanionTypes";
+import { FirebaseError } from "../error";
+
+const CLOUD_AI_COMPANION_VERSION = "v1";
+const CLIENT_CONTEXT_NAME_IDENTIFIER = "firebase_vscode";
+const FIREBASE_CHAT_REQUEST_CONTEXT_TYPE_NAME =
+  "type.googleapis.com/google.cloud.cloudaicompanion.v1main.FirebaseChatRequestContext";
+const FDC_SCHEMA_EXPERIENCE_CONTEXT = "/appeco/firebase/fdc-schema-generator";
+const FDC_OPERATION_EXPERIENCE_CONTEXT = "/appeco/firebase/fdc-query-generator";
+const USER_AUTHOR = "USER";
+type GENERATION_TYPE = "schema" | "operation";
+
+export function cloudAICompationClient(): Client {
+  return new Client({
+    urlPrefix: cloudAiCompanionOrigin(),
+    apiVersion: CLOUD_AI_COMPANION_VERSION,
+    auth: true,
+  });
+}
+
+export async function callCloudAICompanion(
+  client: Client,
+  vscodeRequest: CallCloudAiCompanionRequest,
+  type: GENERATION_TYPE,
+): Promise<CloudAICompanionResponse> {
+  const request = buildRequest(vscodeRequest, type);
+  const { projectId } = getServiceParts(vscodeRequest.servicePath);
+
+  const instance = toChatResourceName(projectId);
+
+  try {
+    const res = await client.post<CloudAICompanionRequest, CloudAICompanionResponse>(
+      `${instance}:completeTask`,
+      request,
+    );
+    return res.body;
+  } catch (error: unknown) {
+    return { output: { messages: [] }, error: error as FirebaseError };
+  }
+}
+
+function buildRequest(
+  { servicePath, naturalLanguageQuery, chatHistory }: CallCloudAiCompanionRequest,
+  type: GENERATION_TYPE,
+): CloudAICompanionRequest {
+  const { serviceId } = getServiceParts(servicePath);
+  const input: CloudAICompanionInput = {
+    messages: [
+      ...chatHistory,
+      {
+        author: USER_AUTHOR,
+        content: naturalLanguageQuery,
+      },
+    ],
+  };
+
+  const clientContext: ClientContext = {
+    name: CLIENT_CONTEXT_NAME_IDENTIFIER,
+    // TODO: determine if we should pass vscode version; // version: ideContext.ver,
+    additionalContext: {
+      "@type": FIREBASE_CHAT_REQUEST_CONTEXT_TYPE_NAME,
+      fdcInfo: {
+        serviceId,
+        fdcServiceName: servicePath,
+        requiresQuery: true,
+      },
+    },
+  };
+
+  return {
+    input,
+    clientContext,
+    experienceContext: {
+      experience:
+        type === "schema" ? FDC_SCHEMA_EXPERIENCE_CONTEXT : FDC_OPERATION_EXPERIENCE_CONTEXT,
+    },
+  };
+}
+
+function toChatResourceName(projectId: string): string {
+  return `projects/${projectId}/locations/global/instances/default`;
+}
+
+/** Gets service name parts */
+interface ServiceParts {
+  projectId: string;
+  locationId: string;
+  serviceId: string;
+}
+function getServiceParts(name: string): ServiceParts {
+  const match = name.match(/projects\/([^/]*)\/locations\/([^/]*)\/services\/([^/]*)/);
+
+  if (!match) {
+    throw new Error(`Invalid service name: ${name}`);
+  }
+
+  return { projectId: match[1], locationId: match[2], serviceId: match[3] };
+}
diff --git a/src/dataconnect/cloudAICompanionTypes.ts b/src/dataconnect/cloudAICompanionTypes.ts
new file mode 100644
index 00000000000..4f126d283ca
--- /dev/null
+++ b/src/dataconnect/cloudAICompanionTypes.ts
@@ -0,0 +1,71 @@
+import { FirebaseError } from "../error";
+
+export interface CallCloudAiCompanionRequest {
+  servicePath: string;
+  naturalLanguageQuery: string;
+  chatHistory: ChatMessage[];
+}
+
+export interface CloudAICompanionInput {
+  preamble?: string;
+  messages: CloudAICompanionMessage[];
+}
+
+export interface CloudAICompanionMessage {
+  content: string;
+  author: string;
+}
+
+export interface ExperienceContext {
+  experience?: string;
+  agent?: string;
+  task?: string;
+}
+export interface ClientContext {
+  name: string;
+  additionalContext: {
+    "@type": string;
+    fdcInfo: {
+      serviceId: string;
+      fdcServiceName: string;
+      requiresQuery: boolean;
+    };
+  };
+}
+
+export interface CloudAICompanionRequest {
+  messageId?: string;
+  topic?: string;
+  input: CloudAICompanionInput;
+
+  // product context -- required
+  experienceContext: ExperienceContext;
+
+  // Client context (e.g. IDE name, version, etc)
+  clientContext?: ClientContext;
+
+  // Unused
+  // // The GCP resources that the code generation process needs to reference
+  // backendResourcesContext?: BackendResourcesContext;
+
+  // // Additional user content not captured in the `input` field above
+  // inputDataContext?: InputDataContext;
+}
+
+export interface CloudAICompanionResponse {
+  output: {
+    messages: ChatMessage[];
+  };
+  error?: FirebaseError;
+}
+
+export interface FdcRequestInfo {
+  serviceId: string;
+  fdcServiceName: string;
+  requiresQuery: boolean;
+}
+
+export interface ChatMessage {
+  content: string;
+  author: string;
+}
diff --git a/src/deploy/apphosting/args.ts b/src/deploy/apphosting/args.ts
new file mode 100644
index 00000000000..7c94697e120
--- /dev/null
+++ b/src/deploy/apphosting/args.ts
@@ -0,0 +1,7 @@
+import { AppHostingSingle } from "../../firebaseConfig";
+
+export interface Context {
+  backendConfigs: Map<string, AppHostingSingle>;
+  backendLocations: Map<string, string>;
+  backendStorageUris: Map<string, string>;
+}
diff --git a/src/deploy/apphosting/deploy.spec.ts b/src/deploy/apphosting/deploy.spec.ts
new file mode 100644
index 00000000000..0fafc735494
--- /dev/null
+++ b/src/deploy/apphosting/deploy.spec.ts
@@ -0,0 +1,129 @@
+import { expect } from "chai";
+import * as sinon from "sinon";
+import { Config } from "../../config";
+import { FirebaseError } from "../../error";
+import { AppHostingSingle } from "../../firebaseConfig";
+import * as gcs from "../../gcp/storage";
+import { RC } from "../../rc";
+import { Context } from "./args";
+import deploy from "./deploy";
+import * as util from "./util";
+import * as fs from "fs";
+import * as getProjectNumber from "../../getProjectNumber";
+
+const BASE_OPTS = {
+  cwd: "/",
+  configPath: "/",
+  except: "",
+  force: false,
+  nonInteractive: false,
+  interactive: false,
+  debug: false,
+  filteredTargets: [],
+  rc: new RC(),
+  json: false,
+};
+
+function initializeContext(): Context {
+  return {
+    backendConfigs: new Map<string, AppHostingSingle>([
+      [
+        "foo",
+        {
+          backendId: "foo",
+          rootDir: "/",
+          ignore: [],
+        },
+      ],
+    ]),
+    backendLocations: new Map<string, string>([["foo", "us-central1"]]),
+    backendStorageUris: new Map<string, string>(),
+  };
+}
+
+describe("apphosting", () => {
+  let getBucketStub: sinon.SinonStub;
+  let createBucketStub: sinon.SinonStub;
+  let uploadObjectStub: sinon.SinonStub;
+  let createArchiveStub: sinon.SinonStub;
+  let createReadStreamStub: sinon.SinonStub;
+  let getProjectNumberStub: sinon.SinonStub;
+
+  beforeEach(() => {
+    getProjectNumberStub = sinon
+      .stub(getProjectNumber, "getProjectNumber")
+      .throws("Unexpected getProjectNumber call");
+    getBucketStub = sinon.stub(gcs, "getBucket").throws("Unexpected getBucket call");
+    createBucketStub = sinon.stub(gcs, "createBucket").throws("Unexpected createBucket call");
+    uploadObjectStub = sinon.stub(gcs, "uploadObject").throws("Unexpected uploadObject call");
+    createArchiveStub = sinon.stub(util, "createArchive").throws("Unexpected createArchive call");
+    createReadStreamStub = sinon
+      .stub(fs, "createReadStream")
+      .throws("Unexpected createReadStream call");
+  });
+
+  afterEach(() => {
+    sinon.verifyAndRestore();
+  });
+
+  describe("deploy", () => {
+    const opts = {
+      ...BASE_OPTS,
+      projectId: "my-project",
+      only: "apphosting",
+      config: new Config({
+        apphosting: {
+          backendId: "foo",
+          rootDir: "/",
+          ignore: [],
+        },
+      }),
+    };
+
+    it("creates regional GCS bucket if one doesn't exist yet", async () => {
+      const context = initializeContext();
+      getProjectNumberStub.resolves("000000000000");
+      getBucketStub.onFirstCall().rejects(
+        new FirebaseError("error", {
+          original: new FirebaseError("original error", { status: 404 }),
+        }),
+      );
+      createBucketStub.resolves();
+      createArchiveStub.resolves({
+        projectSourcePath: "my-project/",
+        zippedSourcePath: "path/to/foo-1234.zip",
+      });
+      uploadObjectStub.resolves({
+        bucket: "firebaseapphosting-sources-12345678-us-central1",
+        object: "foo-1234",
+      });
+      createReadStreamStub.resolves();
+
+      await deploy(context, opts);
+
+      expect(createBucketStub).to.be.calledOnce;
+    });
+
+    it("correctly creates and sets storage URIs", async () => {
+      const context = initializeContext();
+      getProjectNumberStub.resolves("000000000000");
+      getBucketStub.resolves();
+      createBucketStub.resolves();
+      createArchiveStub.resolves({
+        projectSourcePath: "my-project/",
+        zippedSourcePath: "path/to/foo-1234.zip",
+      });
+      uploadObjectStub.resolves({
+        bucket: "firebaseapphosting-sources-12345678-us-central1",
+        object: "foo-1234",
+      });
+      createReadStreamStub.resolves();
+
+      await deploy(context, opts);
+
+      expect(context.backendStorageUris.get("foo")).to.equal(
+        "gs://firebaseapphosting-sources-000000000000-us-central1/foo-1234.zip",
+      );
+    });
+  });
+});
diff --git a/src/deploy/apphosting/deploy.ts b/src/deploy/apphosting/deploy.ts
new file mode 100644
index 00000000000..06def5ef56a
--- /dev/null
+++ b/src/deploy/apphosting/deploy.ts
@@ -0,0 +1,97 @@
+import * as fs from "fs";
+import * as path from "path";
+import { FirebaseError, getErrStatus } from "../../error";
+import * as gcs from "../../gcp/storage";
+import { getProjectNumber } from "../../getProjectNumber";
+import { Options } from "../../options";
+import { needProjectId } from "../../projectUtils";
+import { logLabeledBullet, logLabeledWarning } from "../../utils";
+import { Context } from "./args";
+import { createArchive } from "./util";
+
+/**
+ * Zips and uploads App Hosting source code to Google Cloud Storage in preparation for
+ * build and deployment. Creates storage buckets if necessary.
+ */
+export default async function (context: Context, options: Options): Promise<void> {
+  const projectId = needProjectId(options);
+  options.projectNumber = await getProjectNumber(options);
+  if (!context.backendConfigs) {
+    return;
+  }
+
+  // Ensure that a bucket exists in each region that a backend is or will be deployed to
+  for (const loc of context.backendLocations.values()) {
+    const bucketName = `firebaseapphosting-sources-${options.projectNumber}-${loc.toLowerCase()}`;
+    try {
+      await gcs.getBucket(bucketName);
+    } catch (err) {
+      const errStatus = getErrStatus((err as FirebaseError).original);
+      // Unfortunately, requests for a non-existent bucket from the GCS API sometimes return 403 responses as well as 404s.
+      // We must attempt to create a new bucket on both 403s and 404s.
+      if (errStatus === 403 || errStatus === 404) {
+        logLabeledBullet(
+          "apphosting",
+          `Creating Cloud Storage bucket in ${loc} to store App Hosting source code uploads at ${bucketName}...`,
+        );
+        try {
+          await gcs.createBucket(projectId, {
+            name: bucketName,
+            location: loc,
+            lifecycle: {
+              rule: [
+                {
+                  action: {
+                    type: "Delete",
+                  },
+                  condition: {
+                    age: 30,
+                  },
+                },
+              ],
+            },
+          });
+        } catch (err) {
+          if (getErrStatus((err as FirebaseError).original) === 403) {
+            logLabeledWarning(
+              "apphosting",
+              "Failed to create Cloud Storage bucket because user does not have sufficient permissions. " +
+                "See https://cloud.google.com/storage/docs/access-control/iam-roles for more details on " +
+                "IAM roles that are able to create a Cloud Storage bucket, and ask your project administrator " +
+                "to grant you one of those roles.",
+            );
+            throw (err as FirebaseError).original;
+          }
+        }
+      } else {
+        throw err;
+      }
+    }
+  }
+
+  for (const cfg of context.backendConfigs.values()) {
+    const { projectSourcePath, zippedSourcePath } = await createArchive(cfg, options.projectRoot);
+    const backendLocation = context.backendLocations.get(cfg.backendId);
+    if (!backendLocation) {
+      throw new FirebaseError(
+        `Failed to find location for backend ${cfg.backendId}. Please contact support with the contents of your firebase-debug.log to report your issue.`,
+      );
+    }
+    logLabeledBullet(
+      "apphosting",
+      `Uploading source code at ${projectSourcePath} for backend ${cfg.backendId}...`,
+    );
+    const { bucket, object } = await gcs.uploadObject(
+      {
+        file: zippedSourcePath,
+        stream: fs.createReadStream(zippedSourcePath),
+      },
+      `firebaseapphosting-sources-${options.projectNumber}-${backendLocation.toLowerCase()}`,
+    );
+    logLabeledBullet("apphosting", `Source code uploaded at gs://${bucket}/${object}`);
+    context.backendStorageUris.set(
+      cfg.backendId,
+      `gs://firebaseapphosting-sources-${options.projectNumber}-${backendLocation.toLowerCase()}/${path.basename(zippedSourcePath)}`,
+    );
+  }
+}
diff --git a/src/deploy/apphosting/index.ts b/src/deploy/apphosting/index.ts
new file mode 100644
index 00000000000..6827ff14f87
--- /dev/null
+++ b/src/deploy/apphosting/index.ts
@@ -0,0 +1,5 @@
+import prepare from "./prepare";
+import deploy from "./deploy";
+import release from "./release";
+
+export { prepare, deploy, release };
diff --git a/src/deploy/apphosting/prepare.spec.ts b/src/deploy/apphosting/prepare.spec.ts
new file mode 100644
index 00000000000..369f1f88640
--- /dev/null
+++ b/src/deploy/apphosting/prepare.spec.ts
@@ -0,0 +1,247 @@
+import { expect } from "chai";
+import * as sinon from "sinon";
+import * as backend from "../../apphosting/backend";
+import { Config } from "../../config";
+import * as apiEnabled from "../../ensureApiEnabled";
+import { AppHostingSingle } from "../../firebaseConfig";
+import * as apphosting from "../../gcp/apphosting";
+import * as devconnect from "../../gcp/devConnect";
+import * as prompt from "../../prompt";
+import { RC } from "../../rc";
+import { Context } from "./args";
+import prepare, { getBackendConfigs } from "./prepare";
+
+const BASE_OPTS = {
+  cwd: "/",
+  configPath: "/",
+  except: "",
+  force: false,
+  nonInteractive: false,
+  interactive: false,
+  debug: false,
+  filteredTargets: [],
+  rc: new RC(),
+  json: false,
+};
+
+function initializeContext(): Context {
+  return {
+    backendConfigs: new Map<string, AppHostingSingle>(),
+    backendLocations: new Map<string, string>(),
+    backendStorageUris: new Map<string, string>(),
+  };
+}
+
+describe("apphosting", () => {
+  const opts = {
+    ...BASE_OPTS,
+    projectId: "my-project",
+    only: "apphosting",
+    config: new Config({
+      apphosting: {
+        backendId: "foo",
+        rootDir: "/",
+        ignore: [],
+      },
+    }),
+  };
+
+  let confirmStub: sinon.SinonStub;
+  let checkboxStub: sinon.SinonStub;
+  let doSetupSourceDeployStub: sinon.SinonStub;
+  let listBackendsStub: sinon.SinonStub;
+  let getGitRepositoryLinkStub: sinon.SinonStub;
+
+  beforeEach(() => {
+    sinon.stub(opts.config, "writeProjectFile").returns();
+    confirmStub = sinon.stub(prompt, "confirm").throws("Unexpected confirm call");
+    checkboxStub = sinon.stub(prompt, "checkbox").throws("Unexpected checkbox scall");
+    doSetupSourceDeployStub = sinon
+      .stub(backend, "doSetupSourceDeploy")
+      .throws("Unexpected doSetupSourceDeploy call");
+    listBackendsStub = sinon
+      .stub(apphosting, "listBackends")
+      .throws("Unexpected listBackends call");
+    sinon.stub(backend, "ensureAppHostingComputeServiceAccount").resolves();
+    sinon.stub(apiEnabled, "ensure").resolves();
+    getGitRepositoryLinkStub = sinon
+      .stub(devconnect, "getGitRepositoryLink")
+      .throws("Unexpected getGitRepositoryLink call");
+  });
+
+  afterEach(() => {
+    sinon.verifyAndRestore();
+  });
+
+  describe("prepare", () => {
+    it("links to existing backend if it already exists", async () => {
+      const context = initializeContext();
+      listBackendsStub.onFirstCall().resolves({
+        backends: [
+          {
+            name: "projects/my-project/locations/us-central1/backends/foo",
+          },
+        ],
+      });
+
+      await prepare(context, opts);
+
+      expect(context.backendLocations.get("foo")).to.equal("us-central1");
+      expect(context.backendConfigs.get("foo")).to.deep.equal({
+        backendId: "foo",
+        rootDir: "/",
+        ignore: [],
+      });
+    });
+
+    it("creates a backend if it doesn't exist yet", async () => {
+      const context = initializeContext();
+      listBackendsStub.onFirstCall().resolves({
+        backends: [],
+      });
+      doSetupSourceDeployStub.resolves({ location: "us-central1" });
+      confirmStub.resolves(true);
+      checkboxStub.resolves(["foo"]);
+
+      await prepare(context, opts);
+
+      expect(doSetupSourceDeployStub).to.be.calledWith("my-project", "foo");
+      expect(context.backendLocations.get("foo")).to.equal("us-central1");
+      expect(context.backendConfigs.get("foo")).to.deep.equal({
+        backendId: "foo",
+        rootDir: "/",
+        ignore: [],
+      });
+    });
+
+    it("skips backend deployment if alwaysDeployFromSource is false", async () => {
+      const optsWithAlwaysDeploy = {
+        ...opts,
+        config: new Config({
+          apphosting: {
+            backendId: "foo",
+            rootDir: "/",
+            ignore: [],
+            alwaysDeployFromSource: false,
+          },
+        }),
+      };
+      const context = initializeContext();
+      listBackendsStub.onFirstCall().resolves({
+        backends: [
+          {
+            name: "projects/my-project/locations/us-central1/backends/foo",
+            codebase: {
+              repository: "remote-repo.git",
+            },
+          },
+        ],
+      });
+
+      await prepare(context, optsWithAlwaysDeploy);
+
+      expect(context.backendLocations.get("foo")).to.equal(undefined);
+      expect(context.backendConfigs.get("foo")).to.deep.equal(undefined);
+    });
+
+    it("prompts user if codebase is already connected and alwaysDeployFromSource is undefined", async () => {
+      const context = initializeContext();
+      listBackendsStub.onFirstCall().resolves({
+        backends: [
+          {
+            name: "projects/my-project/locations/us-central1/backends/foo",
+            codebase: {
+              repository:
+                "projects/my-project/locations/us-central1/connections/my-connection/gitRepositoryLinks/foo",
+            },
+          },
+        ],
+      });
+      getGitRepositoryLinkStub.onFirstCall().resolves({
+        cloneUri: "github.com/my-org/foo.git",
+      });
+      confirmStub.onFirstCall().resolves(true);
+
+      await prepare(context, opts);
+
+      expect(context.backendLocations.get("foo")).to.equal("us-central1");
+      expect(context.backendConfigs.get("foo")).to.deep.equal({
+        backendId: "foo",
+        rootDir: "/",
+        ignore: [],
+        alwaysDeployFromSource: true,
+      });
+    });
+  });
+
+  describe("getBackendConfigs", () => {
+    const apphostingConfig = [
+      {
+        backendId: "foo",
+        rootDir: "/",
+        ignore: [],
+      },
+      {
+        backendId: "bar",
+        rootDir: "/",
+        ignore: [],
+      },
+    ];
+
+    it("selects all backends when no --only is passed", () => {
+      const configs = getBackendConfigs({
+        ...BASE_OPTS,
+        only: "",
+        config: new Config({
+          apphosting: apphostingConfig,
+        }),
+      });
+
+      expect(configs).to.deep.equal(apphostingConfig);
+    });
+
+    it("selects all backends when --apphosting is passed", () => {
+      const configs = getBackendConfigs({
+        ...BASE_OPTS,
+        only: "apphosting",
+        config: new Config({
+          apphosting: apphostingConfig,
+        }),
+      });
+
+      expect(configs).to.deep.equal(apphostingConfig);
+    });
+
+    it("selects App Hosting backends when multiple product filters are passed", () => {
+      const configs = getBackendConfigs({
+        ...BASE_OPTS,
+        only: "functions,apphosting",
+        config: new Config({
+          functions: {},
+          hosting: {},
+          apphosting: apphostingConfig,
+        }),
+      });
+
+      expect(configs).to.deep.equal(apphostingConfig);
+    });
+
+    it("selects a specific App Hosting backend", () => {
+      const configs = getBackendConfigs({
+        ...BASE_OPTS,
+        only: "apphosting:foo",
+        config: new Config({
+          apphosting: apphostingConfig,
+        }),
+      });
+
+      expect(configs).to.deep.equal([
+        {
+          backendId: "foo",
+          rootDir: "/",
+          ignore: [],
+        },
+      ]);
+    });
+  });
+});
diff --git a/src/deploy/apphosting/prepare.ts b/src/deploy/apphosting/prepare.ts
new file mode 100644
index 00000000000..116509afe86
--- /dev/null
+++ b/src/deploy/apphosting/prepare.ts
@@ -0,0 +1,190 @@
+import * as path from "path";
+import {
+  doSetupSourceDeploy,
+  ensureAppHostingComputeServiceAccount,
+  ensureRequiredApisEnabled,
+} from "../../apphosting/backend";
+import { AppHostingMultiple, AppHostingSingle } from "../../firebaseConfig";
+import { ensureApiEnabled, listBackends, parseBackendName } from "../../gcp/apphosting";
+import { getGitRepositoryLink, parseGitRepositoryLinkName } from "../../gcp/devConnect";
+import { Options } from "../../options";
+import { needProjectId } from "../../projectUtils";
+import { checkbox, confirm } from "../../prompt";
+import { logLabeledBullet, logLabeledWarning } from "../../utils";
+import { Context } from "./args";
+import { FirebaseError } from "../../error";
+
+/**
+ * Prepare backend targets to deploy from source. Checks that all required APIs are enabled,
+ * and that the App Hosting Compute Service Account exists and has the necessary IAM roles.
+ */
+export default async function (context: Context, options: Options): Promise<void> {
+  const projectId = needProjectId(options);
+  await ensureApiEnabled(options);
+  await ensureRequiredApisEnabled(projectId);
+  try {
+    await ensureAppHostingComputeServiceAccount(
+      projectId,
+      /* serviceAccount= */ "",
+      /* deployFromSource= */ true,
+    );
+  } catch (err) {
+    if ((err as FirebaseError).status === 400) {
+      logLabeledWarning(
+        "apphosting",
+        "Your App Hosting compute service account is still being provisioned. Please try again in a few moments.",
+      );
+    }
+    throw err;
+  }
+
+  context.backendConfigs = new Map<string, AppHostingSingle>();
+  context.backendLocations = new Map<string, string>();
+  context.backendStorageUris = new Map<string, string>();
+
+  const configs = getBackendConfigs(options);
+  const { backends } = await listBackends(projectId, "-");
+
+  const foundBackends: AppHostingSingle[] = [];
+  const notFoundBackends: AppHostingSingle[] = [];
+  const ambiguousBackends: AppHostingSingle[] = [];
+  for (const cfg of configs) {
+    const filteredBackends = backends.filter(
+      (backend) => parseBackendName(backend.name).id === cfg.backendId,
+    );
+    if (filteredBackends.length === 0) {
+      notFoundBackends.push(cfg);
+    } else if (filteredBackends.length === 1) {
+      foundBackends.push(cfg);
+    } else {
+      ambiguousBackends.push(cfg);
+    }
+  }
+
+  // log warning for each ambiguous backend
+  for (const cfg of ambiguousBackends) {
+    const filteredBackends = backends.filter(
+      (backend) => parseBackendName(backend.name).id === cfg.backendId,
+    );
+    const locations = filteredBackends.map((b) => parseBackendName(b.name).location);
+    logLabeledWarning(
+      "apphosting",
+      `You have multiple backends with the same ${cfg.backendId} ID in regions: ${locations.join(", ")}. This is not allowed until we can support more locations. ` +
+        "Please delete and recreate any backends that share an ID with another backend.",
+    );
+  }
+
+  if (foundBackends.length > 0) {
+    logLabeledBullet(
+      "apphosting",
+      `Found backend(s) ${foundBackends.map((cfg) => cfg.backendId).join(", ")}`,
+    );
+  }
+  for (const cfg of foundBackends) {
+    const filteredBackends = backends.filter(
+      (backend) => parseBackendName(backend.name).id === cfg.backendId,
+    );
+    if (cfg.alwaysDeployFromSource === false) {
+      continue;
+    }
+    const backend = filteredBackends[0];
+    const { location } = parseBackendName(backend.name);
+    // We prompt the user for confirmation if they are attempting to deploy from source
+    // when the backend already has a remote repo connected. We force deploy if the command
+    // is run with the --force flag.
+    if (cfg.alwaysDeployFromSource === undefined && backend.codebase?.repository) {
+      const { connectionName, id } = parseGitRepositoryLinkName(backend.codebase.repository);
+      const gitRepositoryLink = await getGitRepositoryLink(projectId, location, connectionName, id);
+
+      if (!options.force) {
+        const confirmDeploy = await confirm({
+          default: true,
+          message: `${cfg.backendId} is linked to the remote repository at ${gitRepositoryLink.cloneUri}. Are you sure you want to deploy your local source?`,
+        });
+        cfg.alwaysDeployFromSource = confirmDeploy;
+        const configPath = path.join(options.projectRoot || "", "firebase.json");
+        options.config.writeProjectFile(configPath, options.config.src);
+        logLabeledBullet(
+          "apphosting",
+          `On future invocations of "firebase deploy", your local source will be deployed to ${cfg.backendId}. You can edit this setting in your firebase.json at any time.`,
+        );
+        if (!confirmDeploy) {
+          logLabeledWarning("apphosting", `Skipping deployment of backend ${cfg.backendId}`);
+          continue;
+        }
+      }
+    }
+    context.backendConfigs.set(cfg.backendId, cfg);
+    context.backendLocations.set(cfg.backendId, location);
+  }
+
+  if (notFoundBackends.length === 0) {
+    return;
+  }
+  if (options.force) {
+    logLabeledWarning(
+      "apphosting",
+      `Skipping deployments of backend(s) ${notFoundBackends.map((cfg) => cfg.backendId).join(", ")}; ` +
+        "the backend(s) do not exist yet and we cannot create them for you because you must choose primary regions for each one. " +
+        "Please run 'firebase deploy' without the --force flag, or 'firebase apphosting:backends:create' to create the backend, " +
+        "then retry deployment.",
+    );
+    return;
+  }
+  const confirmCreate = await confirm({
+    default: true,
+    message: `Did not find backend(s) ${notFoundBackends.map((cfg) => cfg.backendId).join(", ")}. Do you want to create them (you'll have the option to select which to create in the next step)?`,
+  });
+  if (!confirmCreate) {
+    return;
+  }
+  const selected = await checkbox<string>({
+    message: "Which backends do you want to create and deploy to?",
+    choices: notFoundBackends.map((cfg) => cfg.backendId),
+  });
+  const selectedBackends = selected.map((id) =>
+    notFoundBackends.find((backend) => backend.backendId === id),
+  ) as AppHostingSingle[];
+  for (const cfg of selectedBackends) {
+    logLabeledBullet("apphosting", `Creating a new backend ${cfg.backendId}...`);
+    const { location } = await doSetupSourceDeploy(projectId, cfg.backendId);
+    context.backendConfigs.set(cfg.backendId, cfg);
+    context.backendLocations.set(cfg.backendId, location);
+  }
+  return;
+}
+
+/**
+ * Exported for unit testing. Filters backend configs based on user input.
+ */
+export function getBackendConfigs(options: Options): AppHostingMultiple {
+  if (!options.config.src.apphosting) {
+    return [];
+  }
+  const backendConfigs = Array.isArray(options.config.src.apphosting)
+    ? options.config.src.apphosting
+    : [options.config.src.apphosting];
+  // If no --only specifier is passed, return all backend configs
+  if (!options.only) {
+    return backendConfigs;
+  }
+  const selectors = options.only.split(",");
+  const backendIds: string[] = [];
+  for (const selector of selectors) {
+    // if the user passes the "apphosting" selector, we default to deploying all backends
+    // listed in the user's firebase.json App Hosting config.
+    if (selector === "apphosting") {
+      return backendConfigs;
+    }
+    if (selector.startsWith("apphosting:")) {
+      const backendId = selector.replace("apphosting:", "");
+      if (backendId.length > 0) {
+        backendIds.push(backendId);
+      }
+    }
+  }
+  if (backendIds.length === 0) {
+    return [];
+  }
+  return backendConfigs.filter((cfg) => backendIds.includes(cfg.backendId));
+}
diff --git a/src/deploy/apphosting/release.spec.ts b/src/deploy/apphosting/release.spec.ts
new file mode 100644
index 00000000000..6083a99ccb6
--- /dev/null
+++ b/src/deploy/apphosting/release.spec.ts
@@ -0,0 +1,77 @@
+import * as sinon from "sinon";
+import * as rollout from "../../apphosting/rollout";
+import { Config } from "../../config";
+import { AppHostingSingle } from "../../firebaseConfig";
+import { RC } from "../../rc";
+import { Context } from "./args";
+import release from "./release";
+import { expect } from "chai";
+
+const BASE_OPTS = {
+  cwd: "/",
+  configPath: "/",
+  except: "",
+  force: false,
+  nonInteractive: false,
+  interactive: false,
+  debug: false,
+  filteredTargets: [],
+  rc: new RC(),
+  json: false,
+};
+
+function initializeContext(): Context {
+  return {
+    backendConfigs: new Map<string, AppHostingSingle>([
+      [
+        "foo",
+        {
+          backendId: "foo",
+          rootDir: "/",
+          ignore: [],
+        },
+      ],
+    ]),
+    backendLocations: new Map<string, string>([["foo", "us-central1"]]),
+    backendStorageUris: new Map<string, string>([
+      ["foo", "gs://firebaseapphosting-sources-us-central1/foo-1234.zip"],
+    ]),
+  };
+}
+
+describe("apphosting", () => {
+  let orchestrateRolloutStub: sinon.SinonStub;
+
+  beforeEach(() => {
+    orchestrateRolloutStub = sinon
+      .stub(rollout, "orchestrateRollout")
+      .throws("Unexpected orchestrateRollout call");
+  });
+
+  afterEach(() => {
+    sinon.verifyAndRestore();
+  });
+
+  describe("release", () => {
+    const opts = {
+      ...BASE_OPTS,
+      projectId: "my-project",
+      only: "apphosting",
+      config: new Config({
+        apphosting: {
+          backendId: "foo",
+          rootDir: "/",
+          ignore: [],
+        },
+      }),
+    };
+
+    it("does not block rollouts of other backends if one rollout fails", async () => {
+      const context = initializeContext();
+      orchestrateRolloutStub.onFirstCall().rejects();
+      orchestrateRolloutStub.onSecondCall().resolves();
+
+      await expect(release(context, opts)).to.eventually.not.rejected;
+    });
+  });
+});
diff --git a/src/deploy/apphosting/release.ts b/src/deploy/apphosting/release.ts
new file mode 100644
index 00000000000..606ec27bcd9
--- /dev/null
+++ b/src/deploy/apphosting/release.ts
@@ -0,0 +1,72 @@
+import * as ora from "ora";
+import { consoleOrigin } from "../../api";
+import { getBackend } from "../../apphosting/backend";
+import { orchestrateRollout } from "../../apphosting/rollout";
+import { Options } from "../../options";
+import { needProjectId } from "../../projectUtils";
+import {
+  logLabeledBullet,
+  logLabeledError,
+  logLabeledSuccess,
+  logLabeledWarning,
+} from "../../utils";
+import { Context } from "./args";
+
+/**
+ * Orchestrates rollouts for the backends targeted for deployment.
+ */
+export default async function (context: Context, options: Options): Promise<void> {
+  const projectId = needProjectId(options);
+
+  const rollouts = [];
+  const backendIds = [];
+  for (const backendId of context.backendConfigs.keys()) {
+    const config = context.backendConfigs.get(backendId);
+    const location = context.backendLocations.get(backendId);
+    const storageUri = context.backendStorageUris.get(backendId);
+    if (!config || !location || !storageUri) {
+      logLabeledWarning(
+        "apphosting",
+        `Failed to find metadata for backend ${backendId}. Please contact support with the contents of your firebase-debug.log to report your issue.`,
+      );
+      continue;
+    }
+    backendIds.push(backendId);
+    rollouts.push(
+      orchestrateRollout({
+        projectId,
+        location,
+        backendId,
+        buildInput: {
+          source: {
+            archive: {
+              userStorageUri: storageUri,
+              rootDirectory: config.rootDir,
+            },
+          },
+        },
+      }),
+    );
+  }
+
+  logLabeledBullet(
+    "apphosting",
+    `You may also track the rollout(s) at:\n\t${consoleOrigin()}/project/${projectId}/apphosting`,
+  );
+  const rolloutsSpinner = ora(
+    `Starting rollout(s) for backend(s) ${Array.from(context.backendConfigs.keys()).join(", ")}; this may take a few minutes. It's safe to exit now.\n`,
+  ).start();
+  const results = await Promise.allSettled(rollouts);
+  for (let i = 0; i < results.length; i++) {
+    const res = results[i];
+    if (res.status === "fulfilled") {
+      const backend = await getBackend(projectId, backendIds[i]);
+      logLabeledSuccess("apphosting", `Rollout for backend ${backendIds[i]} complete!`);
+      logLabeledSuccess("apphosting", `Your backend is now deployed at:\n\thttps://${backend.uri}`);
+    } else {
+      logLabeledWarning("apphosting", `Rollout for backend ${backendIds[i]} failed.`);
+      logLabeledError("apphosting", res.reason);
+    }
+  }
+  rolloutsSpinner.stop();
+}
diff --git a/src/deploy/apphosting/util.ts b/src/deploy/apphosting/util.ts
new file mode 100644
index 00000000000..b16705f31c6
--- /dev/null
+++ b/src/deploy/apphosting/util.ts
@@ -0,0 +1,76 @@
+import * as archiver from "archiver";
+import * as fs from "fs";
+import * as path from "path";
+import * as tmp from "tmp";
+import { FirebaseError } from "../../error";
+import { AppHostingSingle } from "../../firebaseConfig";
+import * as fsAsync from "../../fsAsync";
+
+/**
+ * Locates the source code for a backend and creates an archive to eventually upload to GCS.
+ * Based heavily on functions upload logic in src/deploy/functions/prepareFunctionsUpload.ts.
+ */
+export async function createArchive(
+  config: AppHostingSingle,
+  projectRoot?: string,
+): Promise<{ projectSourcePath: string; zippedSourcePath: string }> {
+  const tmpFile = tmp.fileSync({ prefix: `${config.backendId}-`, postfix: ".zip" }).name;
+  const fileStream = fs.createWriteStream(tmpFile, {
+    flags: "w",
+    encoding: "binary",
+  });
+  const archive = archiver("zip");
+
+  if (!projectRoot) {
+    projectRoot = process.cwd();
+  }
+  // We must ignore firebase-debug.log or weird things happen if you're in the public dir when you deploy.
+  const ignore = config.ignore || ["node_modules", ".git"];
+  ignore.push("firebase-debug.log", "firebase-debug.*.log");
+  const gitIgnorePatterns = parseGitIgnorePatterns(projectRoot);
+  ignore.push(...gitIgnorePatterns);
+  try {
+    const files = await fsAsync.readdirRecursive({
+      path: projectRoot,
+      ignore: ignore,
+      isGitIgnore: true,
+    });
+    for (const file of files) {
+      const name = path.relative(projectRoot, file.name);
+      archive.file(file.name, {
+        name,
+        mode: file.mode,
+      });
+    }
+    await pipeAsync(archive, fileStream);
+  } catch (err: unknown) {
+    throw new FirebaseError(
+      "Could not read source directory. Remove links and shortcuts and try again.",
+      { original: err as Error, exit: 1 },
+    );
+  }
+  return { projectSourcePath: projectRoot, zippedSourcePath: tmpFile };
+}
+
+function parseGitIgnorePatterns(projectRoot: string, gitIgnorePath = ".gitignore"): string[] {
+  const absoluteFilePath = path.resolve(projectRoot, gitIgnorePath);
+  if (!fs.existsSync(absoluteFilePath)) {
+    return [];
+  }
+  const lines = fs
+    .readFileSync(absoluteFilePath)
+    .toString() // Buffer -> string
+    .split("\n") // split into lines
+    .map((line) => line.trim())
+    .filter((line) => !line.startsWith("#") && !(line === "")); // remove comments and empty lines
+  return lines;
+}
+
+async function pipeAsync(from: archiver.Archiver, to: fs.WriteStream): Promise<void> {
+  from.pipe(to);
+  await from.finalize();
+  return new Promise((resolve, reject) => {
+    to.on("finish", resolve);
+    to.on("error", reject);
+  });
+}
diff --git a/src/deploy/extensions/v2FunctionHelper.ts b/src/deploy/extensions/v2FunctionHelper.ts
index c6c6accfe34..9670fd20d87 100644
--- a/src/deploy/extensions/v2FunctionHelper.ts
+++ b/src/deploy/extensions/v2FunctionHelper.ts
@@ -6,6 +6,7 @@ import { ensure } from "../../ensureApiEnabled";
 import * as planner from "./planner";
 import { needProjectId } from "../../projectUtils";
 import { computeOrigin } from "../../api";
+import { getDefaultServiceAccount } from "../../gcp/computeEngine";
 
 const SERVICE_AGENT_ROLE = "roles/eventarc.eventReceiver";
 
@@ -28,7 +29,7 @@ export async function ensureNecessaryV2ApisAndRoles(options: any) {
 
 async function ensureComputeP4SARole(projectId: string): Promise<boolean> {
   const projectNumber = await getProjectNumber({ projectId });
-  const saEmail = `${projectNumber}-compute@developer.gserviceaccount.com`;
+  const saEmail = await getDefaultServiceAccount(projectNumber);
 
   let policy;
   try {
diff --git a/src/deploy/functions/checkIam.spec.ts b/src/deploy/functions/checkIam.spec.ts
index 543bd1beb00..784115649fc 100644
--- a/src/deploy/functions/checkIam.spec.ts
+++ b/src/deploy/functions/checkIam.spec.ts
@@ -58,8 +58,8 @@ describe("checkIam", () => {
   });
 
   describe("obtainDefaultComputeServiceAgentBindings", () => {
-    it("should obtain the bindings", () => {
-      const bindings = checkIam.obtainDefaultComputeServiceAgentBindings(projectNumber);
+    it("should obtain the bindings", async () => {
+      const bindings = await checkIam.obtainDefaultComputeServiceAgentBindings(projectNumber);
 
       expect(bindings.length).to.equal(2);
       expect(bindings).to.include.deep.members([
diff --git a/src/deploy/functions/checkIam.ts b/src/deploy/functions/checkIam.ts
index 2dc24c1fdb2..a52c8101b81 100644
--- a/src/deploy/functions/checkIam.ts
+++ b/src/deploy/functions/checkIam.ts
@@ -153,8 +153,10 @@ export function obtainPubSubServiceAgentBindings(projectNumber: string): iam.Bin
  * @param projectNumber project number
  * @param existingPolicy the project level IAM policy
  */
-export function obtainDefaultComputeServiceAgentBindings(projectNumber: string): iam.Binding[] {
-  const defaultComputeServiceAgent = `serviceAccount:${gce.getDefaultServiceAccount(projectNumber)}`;
+export async function obtainDefaultComputeServiceAgentBindings(
+  projectNumber: string,
+): Promise<iam.Binding[]> {
+  const defaultComputeServiceAgent = `serviceAccount:${await gce.getDefaultServiceAccount(projectNumber)}`;
   const runInvokerBinding: iam.Binding = {
     role: RUN_INVOKER_ROLE,
     members: [defaultComputeServiceAgent],
@@ -199,7 +201,7 @@ export async function ensureServiceAgentRoles(
   const requiredBindings = [...flattenArray(nestedRequiredBindings)];
   if (haveServices.length === 0) {
     requiredBindings.push(...obtainPubSubServiceAgentBindings(projectNumber));
-    requiredBindings.push(...obtainDefaultComputeServiceAgentBindings(projectNumber));
+    requiredBindings.push(...(await obtainDefaultComputeServiceAgentBindings(projectNumber)));
   }
   if (requiredBindings.length === 0) {
     return;
diff --git a/src/deploy/functions/ensure.ts b/src/deploy/functions/ensure.ts
index cd76ab3e857..0efd0f979ae 100644
--- a/src/deploy/functions/ensure.ts
+++ b/src/deploy/functions/ensure.ts
@@ -8,6 +8,7 @@ import { getProject, ProjectInfo } from "../../management/projects";
 import { assertExhaustive } from "../../functional";
 import { cloudbuildOrigin } from "../../api";
 import * as backend from "./backend";
+import { getDefaultServiceAccount } from "../../gcp/computeEngine";
 
 const FAQ_URL = "https://firebase.google.com/support/faq#functions-runtime";
 
@@ -28,7 +29,7 @@ export async function defaultServiceAccount(e: backend.Endpoint): Promise<string
   if (e.platform === "gcfv1") {
     return `${metadata.projectId}@appspot.gserviceaccount.com`;
   } else if (e.platform === "gcfv2") {
-    return `${metadata.projectNumber}-compute@developer.gserviceaccount.com`;
+    return await getDefaultServiceAccount(metadata.projectNumber);
   }
   assertExhaustive(e.platform);
 }
diff --git a/src/deploy/functions/prepare.spec.ts b/src/deploy/functions/prepare.spec.ts
index 8348ff7477b..0cb7a35a8c9 100644
--- a/src/deploy/functions/prepare.spec.ts
+++ b/src/deploy/functions/prepare.spec.ts
@@ -2,6 +2,8 @@ import { expect } from "chai";
 
 import * as backend from "./backend";
 import * as prepare from "./prepare";
+import * as ensureApiEnabled from "../../ensureApiEnabled";
+import * as serviceusage from "../../gcp/serviceusage";
 import { BEFORE_CREATE_EVENT, BEFORE_SIGN_IN_EVENT } from "../../functions/events/v1";
 import * as sinon from "sinon";
 import * as prompt from "../../prompt";
@@ -419,4 +421,96 @@ describe("prepare", () => {
       ).to.be.rejectedWith(FirebaseError);
     });
   });
+
+  describe("ensureAllRequiredAPIsEnabled", () => {
+    let sinonSandbox: sinon.SinonSandbox;
+    let ensureApiStub: sinon.SinonStub;
+    let generateServiceIdentityStub: sinon.SinonStub;
+
+    beforeEach(() => {
+      sinonSandbox = sinon.createSandbox();
+      ensureApiStub = sinonSandbox.stub(ensureApiEnabled, "ensure").resolves();
+      generateServiceIdentityStub = sinonSandbox
+        .stub(serviceusage, "generateServiceIdentity")
+        .resolves();
+    });
+
+    afterEach(() => {
+      sinonSandbox.restore();
+    });
+
+    it("should not enable any APIs for an empty backend", async () => {
+      await prepare.ensureAllRequiredAPIsEnabled("project", backend.empty());
+      expect(ensureApiStub.called).to.be.false;
+      expect(generateServiceIdentityStub.called).to.be.false;
+    });
+
+    it("should enable APIs from backend.requiredAPIs", async () => {
+      const api1 = "testapi1.googleapis.com";
+      const api2 = "testapi2.googleapis.com";
+      const b = backend.empty();
+      b.requiredAPIs = [{ api: api1 }, { api: api2 }];
+
+      await prepare.ensureAllRequiredAPIsEnabled("project", b);
+      expect(ensureApiStub.calledWith("project", api1, "functions", false)).to.be.true;
+      expect(ensureApiStub.calledWith("project", api2, "functions", false)).to.be.true;
+    });
+
+    it("should enable Secret Manager API if secrets are used ", async () => {
+      const e: backend.Endpoint = {
+        id: "hasSecrets",
+        platform: "gcfv1",
+        region: "us-central1",
+        project: "project",
+        entryPoint: "entry",
+        runtime: "nodejs22",
+        httpsTrigger: {},
+        secretEnvironmentVariables: [
+          {
+            key: "SECRET",
+            secret: "secret",
+            projectId: "project",
+          },
+        ],
+      };
+      await prepare.ensureAllRequiredAPIsEnabled("project", backend.of(e));
+      expect(
+        ensureApiStub.calledWith(
+          "project",
+          "https://secretmanager.googleapis.com",
+          "functions",
+          false,
+        ),
+      ).to.be.true;
+    });
+
+    it("should enable GCFv2 APIs and generate required service identities", async () => {
+      const e: backend.Endpoint = {
+        id: "v2",
+        platform: "gcfv2",
+        region: "us-central1",
+        project: "project",
+        entryPoint: "entry",
+        runtime: "nodejs22",
+        httpsTrigger: {},
+      };
+
+      await prepare.ensureAllRequiredAPIsEnabled("project", backend.of(e));
+
+      expect(ensureApiStub.calledWith("project", "https://run.googleapis.com", "functions")).to.be
+        .true;
+      expect(ensureApiStub.calledWith("project", "https://eventarc.googleapis.com", "functions")).to
+        .be.true;
+      expect(ensureApiStub.calledWith("project", "https://pubsub.googleapis.com", "functions")).to
+        .be.true;
+      expect(ensureApiStub.calledWith("project", "https://storage.googleapis.com", "functions")).to
+        .be.true;
+      expect(
+        generateServiceIdentityStub.calledWith("project", "pubsub.googleapis.com", "functions"),
+      ).to.be.true;
+      expect(
+        generateServiceIdentityStub.calledWith("project", "eventarc.googleapis.com", "functions"),
+      ).to.be.true;
+    });
+  });
 });
diff --git a/src/deploy/functions/prepare.ts b/src/deploy/functions/prepare.ts
index 0ec92a218fb..39650fa7c60 100644
--- a/src/deploy/functions/prepare.ts
+++ b/src/deploy/functions/prepare.ts
@@ -18,6 +18,7 @@ import {
   eventarcOrigin,
   pubsubOrigin,
   storageOrigin,
+  secretManagerOrigin,
 } from "../../api";
 import { Options } from "../../options";
 import {
@@ -205,6 +206,7 @@ export async function prepare(
         `preparing ${clc.bold(sourceDirName)} directory for uploading...`,
       );
     }
+
     if (backend.someEndpoint(wantBackend, (e) => e.platform === "gcfv2")) {
       const packagedSource = await prepareFunctionsUpload(sourceDir, config);
       source.functionsSourceV2 = packagedSource?.pathToSource;
@@ -241,34 +243,9 @@ export async function prepare(
   const wantBackend = backend.merge(...Object.values(wantBackends));
   const haveBackend = backend.merge(...Object.values(haveBackends));
 
+  await ensureAllRequiredAPIsEnabled(projectNumber, wantBackend);
   await warnIfNewGenkitFunctionIsMissingSecrets(wantBackend, haveBackend, options);
 
-  // Enable required APIs. This may come implicitly from triggers (e.g. scheduled triggers
-  // require cloudscheudler and, in v1, require pub/sub), or can eventually come from
-  // explicit dependencies.
-  await Promise.all(
-    Object.values(wantBackend.requiredAPIs).map(({ api }) => {
-      return ensureApiEnabled.ensure(projectId, api, "functions", /* silent=*/ false);
-    }),
-  );
-  if (backend.someEndpoint(wantBackend, (e) => e.platform === "gcfv2")) {
-    // Note: Some of these are premium APIs that require billing to be enabled.
-    // We'd eventually have to add special error handling for billing APIs, but
-    // enableCloudBuild is called above and has this special casing already.
-    const V2_APIS = [cloudRunApiOrigin(), eventarcOrigin(), pubsubOrigin(), storageOrigin()];
-    const enablements = V2_APIS.map((api) => {
-      return ensureApiEnabled.ensure(context.projectId, api, "functions");
-    });
-    await Promise.all(enablements);
-    // Need to manually kick off the p4sa activation of services
-    // that we use with IAM roles assignment.
-    const services = ["pubsub.googleapis.com", "eventarc.googleapis.com"];
-    const generateServiceAccounts = services.map((service) => {
-      return generateServiceIdentity(projectNumber, service, "functions");
-    });
-    await Promise.all(generateServiceAccounts);
-  }
-
   // ===Phase 6. Ask for user prompts for things might warrant user attentions.
   // We limit the scope endpoints being deployed.
   const matchingBackend = backend.matchingBackend(wantBackend, (endpoint) => {
@@ -533,3 +510,48 @@ export async function warnIfNewGenkitFunctionIsMissingSecrets(
     }
   }
 }
+
+// Enable required APIs. This may come implicitly from triggers (e.g. scheduled triggers
+// require cloudscheduler and, in v1, require pub/sub), use of features (secrets), or explicit dependencies.
+export async function ensureAllRequiredAPIsEnabled(
+  projectNumber: string,
+  wantBackend: backend.Backend,
+): Promise<void> {
+  await Promise.all(
+    Object.values(wantBackend.requiredAPIs).map(({ api }) => {
+      return ensureApiEnabled.ensure(projectNumber, api, "functions", /* silent=*/ false);
+    }),
+  );
+  if (backend.someEndpoint(wantBackend, (e) => e.platform === "gcfv2")) {
+    // Note: Some of these are premium APIs that require billing to be enabled.
+    // We'd eventually have to add special error handling for billing APIs, but
+    // enableCloudBuild is called above and has this special casing already.
+    const V2_APIS = [cloudRunApiOrigin(), eventarcOrigin(), pubsubOrigin(), storageOrigin()];
+    const enablements = V2_APIS.map((api) => {
+      return ensureApiEnabled.ensure(projectNumber, api, "functions");
+    });
+    await Promise.all(enablements);
+    // Need to manually kick off the p4sa activation of services
+    // that we use with IAM roles assignment.
+    const services = ["pubsub.googleapis.com", "eventarc.googleapis.com"];
+    const generateServiceAccounts = services.map((service) => {
+      return generateServiceIdentity(projectNumber, service, "functions");
+    });
+    await Promise.all(generateServiceAccounts);
+  }
+
+  // If function is making use of secrets, go ahead and enable Secret Manager API.
+  if (
+    backend.someEndpoint(
+      wantBackend,
+      (e) => !!(e.secretEnvironmentVariables && e.secretEnvironmentVariables.length > 0),
+    )
+  ) {
+    await ensureApiEnabled.ensure(
+      projectNumber,
+      secretManagerOrigin(),
+      "functions",
+      /* silent=*/ false,
+    );
+  }
+}
diff --git a/src/deploy/functions/release/fabricator.spec.ts b/src/deploy/functions/release/fabricator.spec.ts
index 1615ccaa00f..01ff014b849 100644
--- a/src/deploy/functions/release/fabricator.spec.ts
+++ b/src/deploy/functions/release/fabricator.spec.ts
@@ -775,7 +775,7 @@ describe("Fabricator", () => {
 
         await fab.createV2Function(ep, new scraper.SourceTokenScraper());
         expect(run.setInvokerCreate).to.have.been.calledWith(ep.project, "service", [
-          gce.getDefaultServiceAccount(fab.projectNumber),
+          await gce.getDefaultServiceAccount(fab.projectNumber),
         ]);
       });
 
diff --git a/src/deploy/functions/release/fabricator.ts b/src/deploy/functions/release/fabricator.ts
index cf97308b4a4..7ebc4cf78ed 100644
--- a/src/deploy/functions/release/fabricator.ts
+++ b/src/deploy/functions/release/fabricator.ts
@@ -439,7 +439,7 @@ export class Fabricator {
     } else if (backend.isScheduleTriggered(endpoint)) {
       const invoker = endpoint.serviceAccount
         ? [endpoint.serviceAccount]
-        : [gce.getDefaultServiceAccount(this.projectNumber)];
+        : [await gce.getDefaultServiceAccount(this.projectNumber)];
       await this.executor
         .run(() => run.setInvokerCreate(endpoint.project, serviceName, invoker))
         .catch(rethrowAs(endpoint, "set invoker"));
@@ -548,7 +548,7 @@ export class Fabricator {
     } else if (backend.isScheduleTriggered(endpoint)) {
       invoker = endpoint.serviceAccount
         ? [endpoint.serviceAccount]
-        : [gce.getDefaultServiceAccount(this.projectNumber)];
+        : [await gce.getDefaultServiceAccount(this.projectNumber)];
     }
 
     if (invoker) {
@@ -662,14 +662,18 @@ export class Fabricator {
 
   async upsertScheduleV1(endpoint: backend.Endpoint & backend.ScheduleTriggered): Promise<void> {
     // The Pub/Sub topic is already created
-    const job = scheduler.jobFromEndpoint(endpoint, this.appEngineLocation, this.projectNumber);
+    const job = await scheduler.jobFromEndpoint(
+      endpoint,
+      this.appEngineLocation,
+      this.projectNumber,
+    );
     await this.executor
       .run(() => scheduler.createOrReplaceJob(job))
       .catch(rethrowAs(endpoint, "upsert schedule"));
   }
 
   async upsertScheduleV2(endpoint: backend.Endpoint & backend.ScheduleTriggered): Promise<void> {
-    const job = scheduler.jobFromEndpoint(endpoint, endpoint.region, this.projectNumber);
+    const job = await scheduler.jobFromEndpoint(endpoint, endpoint.region, this.projectNumber);
     await this.executor
       .run(() => scheduler.createOrReplaceJob(job))
       .catch(rethrowAs(endpoint, "upsert schedule"));
diff --git a/src/deploy/functions/runtimes/python/index.ts b/src/deploy/functions/runtimes/python/index.ts
index 1bcf0796103..70d18976990 100644
--- a/src/deploy/functions/runtimes/python/index.ts
+++ b/src/deploy/functions/runtimes/python/index.ts
@@ -60,6 +60,8 @@ export function getPythonBinary(
     return "python3.11";
   } else if (runtime === "python312") {
     return "python3.12";
+  } else if (runtime === "python313") {
+    return "python3.13";
   }
   assertExhaustive(runtime, `Unhandled python runtime ${runtime as string}`);
 }
diff --git a/src/deploy/functions/runtimes/supported/supported.spec.ts b/src/deploy/functions/runtimes/supported/supported.spec.ts
index f5a7d2a0940..a099b406fe9 100644
--- a/src/deploy/functions/runtimes/supported/supported.spec.ts
+++ b/src/deploy/functions/runtimes/supported/supported.spec.ts
@@ -46,7 +46,7 @@ describe("supported runtimes", () => {
       expect(logLabeledWarning).to.have.been.calledWith(
         "functions",
         "Runtime Node.js 20 was deprecated on 2026-04-30 and will be " +
-          "decommissioned on 2026-10-31, after which you will not be able to " +
+          "decommissioned on 2026-10-30, after which you will not be able to " +
           "deploy without upgrading. Consider upgrading now to avoid disruption. See " +
           "https://cloud.google.com/functions/docs/runtime-support for full " +
           "details on the lifecycle policy",
@@ -58,7 +58,7 @@ describe("supported runtimes", () => {
       expect(logLabeledWarning).to.have.been.calledWith(
         "functions",
         "Runtime Node.js 20 will be deprecated on 2026-04-30 and will be " +
-          "decommissioned on 2026-10-31, after which you will not be able to " +
+          "decommissioned on 2026-10-30, after which you will not be able to " +
           "deploy without upgrading. Consider upgrading now to avoid disruption. See " +
           "https://cloud.google.com/functions/docs/runtime-support for full " +
           "details on the lifecycle policy",
diff --git a/src/deploy/functions/runtimes/supported/types.ts b/src/deploy/functions/runtimes/supported/types.ts
index bc741ec2455..7c127e4569a 100644
--- a/src/deploy/functions/runtimes/supported/types.ts
+++ b/src/deploy/functions/runtimes/supported/types.ts
@@ -49,63 +49,69 @@ export const RUNTIMES = runtimes({
   },
   nodejs10: {
     friendly: "Node.js 10",
-    status: "GA",
+    status: "decommissioned",
     deprecationDate: "2024-01-30",
     decommissionDate: "2025-01-30",
   },
   nodejs12: {
     friendly: "Node.js 12",
-    status: "GA",
+    status: "decommissioned",
     deprecationDate: "2024-01-30",
     decommissionDate: "2025-01-30",
   },
   nodejs14: {
     friendly: "Node.js 14",
-    status: "GA",
+    status: "decommissioned",
     deprecationDate: "2024-01-30",
     decommissionDate: "2025-01-30",
   },
   nodejs16: {
     friendly: "Node.js 16",
-    status: "GA",
+    status: "decommissioned",
     deprecationDate: "2024-01-30",
     decommissionDate: "2025-01-30",
   },
   nodejs18: {
     friendly: "Node.js 18",
-    status: "GA",
+    status: "decommissioned",
     deprecationDate: "2025-04-30",
-    decommissionDate: "2025-10-31",
+    decommissionDate: "2025-10-30",
   },
   nodejs20: {
     friendly: "Node.js 20",
     status: "GA",
     deprecationDate: "2026-04-30",
-    decommissionDate: "2026-10-31",
+    decommissionDate: "2026-10-30",
   },
   nodejs22: {
     friendly: "Node.js 22",
     status: "GA",
     deprecationDate: "2027-04-30",
-    decommissionDate: "2027-10-31",
+    decommissionDate: "2028-10-31",
   },
   python310: {
     friendly: "Python 3.10",
     status: "GA",
     deprecationDate: "2026-10-04",
-    decommissionDate: "2027-04-30",
+    decommissionDate: "2027-04-04",
   },
   python311: {
     friendly: "Python 3.11",
     status: "GA",
     deprecationDate: "2027-10-24",
-    decommissionDate: "2028-04-30",
+    decommissionDate: "2028-04-24",
   },
   python312: {
     friendly: "Python 3.12",
     status: "GA",
     deprecationDate: "2028-10-02",
-    decommissionDate: "2029-04-30",
+    decommissionDate: "2029-04-02",
+  },
+  python313: {
+    friendly: "Python 3.13",
+    status: "GA",
+    deprecationDate: "2029-10-10",
+    decommissionDate: "2030-04-10",
   },
 });
 
@@ -116,3 +122,5 @@ export type DecommissionedRuntime = {
     ? R
     : never;
 }[keyof typeof RUNTIMES];
+
+export type ActiveRuntime = Exclude<Runtime, DecommissionedRuntime>;
diff --git a/src/deploy/index.ts b/src/deploy/index.ts
index c5583b937dc..7dd2d093a2b 100644
--- a/src/deploy/index.ts
+++ b/src/deploy/index.ts
@@ -17,6 +17,7 @@ import * as StorageTarget from "./storage";
 import * as RemoteConfigTarget from "./remoteconfig";
 import * as ExtensionsTarget from "./extensions";
 import * as DataConnectTarget from "./dataconnect";
+import * as AppHostingTarget from "./apphosting";
 import { prepareFrameworks } from "../frameworks";
 import { Context } from "./hosting/context";
 import { addPinnedFunctionsToOnlyString, hasPinnedFunctions } from "./hosting/prepare";
@@ -35,6 +36,7 @@ const TARGETS = {
   remoteconfig: RemoteConfigTarget,
   extensions: ExtensionsTarget,
   dataconnect: DataConnectTarget,
+  apphosting: AppHostingTarget,
 };
 
 export type DeployOptions = Options & { dryRun?: boolean };
diff --git a/src/emulator/apphosting/index.ts b/src/emulator/apphosting/index.ts
index 4982a364d2c..20766a57b91 100644
--- a/src/emulator/apphosting/index.ts
+++ b/src/emulator/apphosting/index.ts
@@ -1,8 +1,10 @@
 import { EmulatorInfo, EmulatorInstance, Emulators } from "../types";
 import { start as apphostingStart } from "./serve";
 import { logger } from "./developmentServer";
+
 interface AppHostingEmulatorArgs {
   projectId?: string;
+  backendId?: string;
   options?: any;
   port?: number;
   host?: string;
@@ -20,6 +22,7 @@ export class AppHostingEmulator implements EmulatorInstance {
   async start(): Promise<void> {
     const { hostname, port } = await apphostingStart({
       projectId: this.args.projectId,
+      backendId: this.args.backendId,
       port: this.args.port,
       startCommand: this.args.startCommand,
       rootDirectory: this.args.rootDirectory,
diff --git a/src/emulator/apphosting/serve.ts b/src/emulator/apphosting/serve.ts
index be8efd1235f..bf372fd5bd4 100644
--- a/src/emulator/apphosting/serve.ts
+++ b/src/emulator/apphosting/serve.ts
@@ -6,7 +6,7 @@
 import { isIPv4 } from "net";
 import * as clc from "colorette";
 import { checkListenable } from "../portUtils";
-import { detectStartCommand } from "./developmentServer";
+import { detectPackageManager, detectStartCommand } from "./developmentServer";
 import { DEFAULT_HOST, DEFAULT_PORTS } from "../constants";
 import { spawnWithCommandString } from "../../init/spawn";
 import { logger } from "./developmentServer";
@@ -17,10 +17,17 @@ import { EmulatorRegistry } from "../registry";
 import { setEnvVarsForEmulators } from "../env";
 import { FirebaseError } from "../../error";
 import * as secrets from "../../gcp/secretManager";
-import { logLabeledError } from "../../utils";
+import { logLabeledError, logLabeledWarning } from "../../utils";
+import * as apphosting from "../../gcp/apphosting";
+import { Constants } from "../constants";
+import { constructDefaultWebSetup, WebConfig } from "../../fetchWebSetup";
+import { AppPlatform, getAppConfig } from "../../management/apps";
+import { spawnSync } from "child_process";
+import { gte as semverGte } from "semver";
 
 interface StartOptions {
   projectId?: string;
+  backendId?: string;
   port?: number;
   startCommand?: string;
   rootDirectory?: string;
@@ -41,7 +48,13 @@ export async function start(options?: StartOptions): Promise<{ hostname: string;
     port += 1;
   }
 
-  await serve(options?.projectId, port, options?.startCommand, options?.rootDirectory);
+  await serve(
+    options?.projectId,
+    options?.backendId,
+    port,
+    options?.startCommand,
+    options?.rootDirectory,
+  );
 
   return { hostname, port };
 }
@@ -102,6 +115,7 @@ async function loadSecret(project: string | undefined, name: string): Promise<st
  */
 async function serve(
   projectId: string | undefined,
+  backendId: string | undefined,
   port: number,
   startCommand?: string,
   backendRelativeDir?: string,
@@ -115,11 +129,34 @@ async function serve(
     value.value ? value.value : await loadSecret(projectId, value.secret!),
   ]);
 
-  const environmentVariablesToInject = {
+  const environmentVariablesToInject: NodeJS.ProcessEnv = {
+    NODE_ENV: process.env.NODE_ENV,
     ...getEmulatorEnvs(),
     ...Object.fromEntries(await Promise.all(resolveEnv)),
+    FIREBASE_APP_HOSTING: "1",
+    X_GOOGLE_TARGET_PLATFORM: "fah",
+    GCLOUD_PROJECT: projectId,
+    PROJECT_ID: projectId,
     PORT: port.toString(),
   };
+
+  const packageManager = await detectPackageManager(backendRoot).catch(() => undefined);
+  if (packageManager === "pnpm") {
+    // TODO(jamesdaniels) look into pnpm support for autoinit
+    logLabeledWarning("apphosting", `Firebase JS SDK autoinit does not currently support PNPM.`);
+  } else {
+    const webappConfig = await getBackendAppConfig(projectId, backendId);
+    if (webappConfig) {
+      environmentVariablesToInject["FIREBASE_WEBAPP_CONFIG"] ||= JSON.stringify(webappConfig);
+      environmentVariablesToInject["FIREBASE_CONFIG"] ||= JSON.stringify({
+        databaseURL: webappConfig.databaseURL,
+        storageBucket: webappConfig.storageBucket,
+        projectId: webappConfig.projectId,
+      });
+    }
+    await tripFirebasePostinstall(backendRoot, environmentVariablesToInject);
+  }
+
   if (startCommand) {
     logger.logLabeled(
       "BULLET",
@@ -167,3 +204,89 @@ export function getEmulatorEnvs(): Record<string, string> {
 
   return envs;
 }
+
+type Dependency = {
+  name: string;
+  version: string;
+  path: string;
+  dependencies?: Record<string, Dependency>;
+};
+
+async function tripFirebasePostinstall(
+  rootDirectory: string,
+  env: NodeJS.ProcessEnv,
+): Promise<void> {
+  const npmLs = spawnSync("npm", ["ls", "@firebase/util", "--json", "--long"], {
+    cwd: rootDirectory,
+    shell: process.platform === "win32",
+  });
+  if (!npmLs.stdout) {
+    return;
+  }
+  const npmLsResults = JSON.parse(npmLs.stdout.toString().trim());
+  const dependenciesToSearch: Dependency[] = Object.values(npmLsResults.dependencies || {});
+  const firebaseUtilPaths: string[] = [];
+  for (const dependency of dependenciesToSearch) {
+    if (
+      dependency.name === "@firebase/util" &&
+      semverGte(dependency.version, "1.11.0") &&
+      firebaseUtilPaths.indexOf(dependency.path) === -1
+    ) {
+      firebaseUtilPaths.push(dependency.path);
+    }
+    if (dependency.dependencies) {
+      dependenciesToSearch.push(...Object.values(dependency.dependencies));
+    }
+  }
+
+  await Promise.all(
+    firebaseUtilPaths.map(
+      (path) =>
+        new Promise<void>((resolve) => {
+          spawnSync("npm", ["run", "postinstall"], {
+            cwd: path,
+            env,
+            stdio: "ignore",
+            shell: process.platform === "win32",
+          });
+          resolve();
+        }),
+    ),
+  );
+}
+
+async function getBackendAppConfig(
+  projectId?: string,
+  backendId?: string,
+): Promise<WebConfig | undefined> {
+  if (!projectId) {
+    return undefined;
+  }
+
+  if (Constants.isDemoProject(projectId)) {
+    return constructDefaultWebSetup(projectId);
+  }
+
+  if (!backendId) {
+    return undefined;
+  }
+
+  const backendsList = await apphosting.listBackends(projectId, "-").catch(() => undefined);
+  const backend = backendsList?.backends.find(
+    (b) => apphosting.parseBackendName(b.name).id === backendId,
+  );
+
+  if (!backend) {
+    logLabeledWarning(
+      "apphosting",
+      `Unable to lookup details for backend ${backendId}. Firebase SDK autoinit will not be available.`,
+    );
+    return undefined;
+  }
+
+  if (!backend.appId) {
+    return undefined;
+  }
+
+  return (await getAppConfig(backend.appId, AppPlatform.WEB)) as WebConfig;
+}
diff --git a/src/emulator/auth/widget_ui.ts b/src/emulator/auth/widget_ui.ts
index 32e3c4e1739..502fadc5804 100644
--- a/src/emulator/auth/widget_ui.ts
+++ b/src/emulator/auth/widget_ui.ts
@@ -21,6 +21,7 @@ assert(!internalError, internalError);
 
 var apiKey = query.get('apiKey');
 var appName = query.get('appName');
+var tenantId = query.get('tid');
 var authType = query.get('authType');
 var providerId = query.get('providerId');
 var redirectUrl = query.get('redirectUrl');
@@ -192,7 +193,7 @@ function finishWithUser(urlEncodedIdToken, email) {
     urlResponse: url,
     sessionId: "ValueNotUsedByAuthEmulator",
     postBody: "",
-    tenantId: null,
+    tenantId: tenantId,
     error: null,
   });
 }
diff --git a/src/emulator/controller.ts b/src/emulator/controller.ts
index 404a50e346b..876108ce02d 100755
--- a/src/emulator/controller.ts
+++ b/src/emulator/controller.ts
@@ -61,6 +61,8 @@ import { TasksEmulator } from "./tasksEmulator";
 import { AppHostingEmulator } from "./apphosting";
 import { sendVSCodeMessage, VSCODE_MESSAGE } from "../dataconnect/webhook";
 import { dataConnectLocalConnString } from "../api";
+import { AppHostingSingle } from "../firebaseConfig";
+import { resolveProjectPath } from "../projectPath";
 
 const START_LOGGING_EMULATOR = utils.envOverride(
   "START_LOGGING_EMULATOR",
@@ -968,11 +970,28 @@ export async function startAll(
    * app hosting emulator may depend on other emulators (i.e auth, firestore,
    * storage, etc).
    */
-  const apphostingConfig = options.config.src.emulators?.[Emulators.APPHOSTING];
+  const apphostingEmulatorConfig = options.config.src.emulators?.[Emulators.APPHOSTING];
 
   if (listenForEmulator.apphosting) {
+    const rootDirectory = apphostingEmulatorConfig?.rootDirectory;
+    const backendRoot = resolveProjectPath({}, rootDirectory ?? "./");
+
+    // It doesn't seem as though App Hosting emulator supports multiple backends, infer the correct one
+    // from the root directory.
+    let apphostingConfig: AppHostingSingle | undefined;
+    if (Array.isArray(options.config.src.apphosting)) {
+      const matchingAppHostingConfig = options.config.src.apphosting.filter(
+        (config) => resolveProjectPath({}, path.join(".", config.rootDir ?? "/")) === backendRoot,
+      );
+      if (matchingAppHostingConfig.length === 1) {
+        apphostingConfig = matchingAppHostingConfig[0];
+      }
+    } else {
+      apphostingConfig = options.config.src.apphosting;
+    }
+
     const apphostingAddr = legacyGetFirstAddr(Emulators.APPHOSTING);
-    if (apphostingConfig?.startCommandOverride) {
+    if (apphostingEmulatorConfig?.startCommandOverride) {
       const apphostingLogger = EmulatorLogger.forEmulator(Emulators.APPHOSTING);
       apphostingLogger.logLabeled(
         "WARN",
@@ -982,10 +1001,12 @@ export async function startAll(
     }
     const apphostingEmulator = new AppHostingEmulator({
       projectId: options.project,
+      backendId: apphostingConfig?.backendId,
       host: apphostingAddr.host,
       port: apphostingAddr.port,
-      startCommand: apphostingConfig?.startCommand || apphostingConfig?.startCommandOverride,
-      rootDirectory: apphostingConfig?.rootDirectory,
+      startCommand:
+        apphostingEmulatorConfig?.startCommand || apphostingEmulatorConfig?.startCommandOverride,
+      rootDirectory,
       options,
     });
 
diff --git a/src/emulator/dataconnectEmulator.ts b/src/emulator/dataconnectEmulator.ts
index 9851aed5bd7..00566afbd51 100644
--- a/src/emulator/dataconnectEmulator.ts
+++ b/src/emulator/dataconnectEmulator.ts
@@ -29,8 +29,8 @@ import { PostgresServer, TRUNCATE_TABLES_SQL } from "./dataconnect/pgliteServer"
 import { cleanShutdown } from "./controller";
 import { connectableHostname } from "../utils";
 import { Account } from "../types/auth";
-import { getCredentialsEnvironment } from "./env";
 import { ensure } from "../ensureApiEnabled";
+import { getCredentialPathAsync } from "../defaultCredentials";
 
 export interface DataConnectEmulatorArgs {
   projectId: string;
@@ -358,12 +358,15 @@ export class DataConnectEmulator implements EmulatorInstance {
     account?: Account,
     extraEnv: Record<string, string> = {},
   ): Promise<NodeJS.ProcessEnv> {
-    const credsEnv = await getCredentialsEnvironment(
-      account,
-      EmulatorLogger.forEmulator(Emulators.DATACONNECT),
-      "dataconnect",
-      true,
-    );
+    const credsEnv: Record<string, string> = {};
+    if (account) {
+      // If Firebase CLI is logged in, always pass in the credentials to FDC emulator.
+      const defaultCredPath = await getCredentialPathAsync(account);
+      if (defaultCredPath) {
+        logger.log("DEBUG", `Setting GAC to ${defaultCredPath}`);
+        credsEnv.GOOGLE_APPLICATION_CREDENTIALS = defaultCredPath;
+      }
+    }
     return { ...process.env, ...extraEnv, ...credsEnv };
   }
 }
diff --git a/src/emulator/downloadableEmulatorInfo.json b/src/emulator/downloadableEmulatorInfo.json
new file mode 100644
index 00000000000..92505ab380e
--- /dev/null
+++ b/src/emulator/downloadableEmulatorInfo.json
@@ -0,0 +1,60 @@
+{
+  "database": {
+    "version": "4.11.2",
+    "expectedSize": 34495935,
+    "expectedChecksum": "2fd771101c0e1f7898c04c9204f2ce63",
+    "expectedChecksumSHA256": "b70d99344caf17c98b6f910fa8f6edf32a7c016cb1035e8915f70d38901eb97f"
+  },
+  "firestore": {
+    "version": "1.19.8",
+    "expectedSize": 63634791,
+    "expectedChecksum": "9b43a6daa590678de9b7df6d68260395",
+    "expectedChecksumSHA256": "9d43599ed6151199e8d604dc87fac51218e49e5f3a48519b1ae560bbe5e3382d"
+  },
+  "storage": {
+    "version": "1.1.3",
+    "expectedSize": 52892936,
+    "expectedChecksum": "2ca11ec1193003bea89f806cc085fa25",
+    "expectedChecksumSHA256": "0cd52db6f6271d62078f805220706377c849220b73bd68aa27078d977df9c900"
+  },
+  "ui": {
+    "snapshot": {
+      "version": "SNAPSHOT",
+      "expectedSize": -1,
+      "expectedChecksum": "",
+      "expectedChecksumSHA256": ""
+    },
+    "main": {
+      "version": "1.15.0",
+      "expectedSize": 3538469,
+      "expectedChecksum": "2f13d5aea9524564c8b7adaa9cfa2128",
+      "expectedChecksumSHA256": "97d8c4c574e3f20c4d690a2ce8373eef76ab024da73279a062dba8517f88cf9a"
+    }
+  },
+  "pubsub": {
+    "version": "0.8.14",
+    "expectedSize": 66786933,
+    "expectedChecksum": "a9025b3e53fdeafd2969ccb3ba1e1d38",
+    "expectedChecksumSHA256": "4fbeefd8ecb32b10e5ab522e5d8748e0c2b13891c471c0c327c04632dcc75a8d"
+  },
+  "dataconnect": {
+    "darwin": {
+      "version": "2.6.1",
+      "expectedSize": 27415296,
+      "expectedChecksum": "5814d22b06b1321409f40693dfe47288",
+      "expectedChecksumSHA256": "8df1cfac6ef747909b3c18b57ba52b70a11d53b9d0a22b197011d6550ceca133"
+    },
+    "win32": {
+      "version": "2.6.1",
+      "expectedSize": 27875328,
+      "expectedChecksum": "21381052c2bf767ee84fb85975cfd4d5",
+      "expectedChecksumSHA256": "6bebaa9575b460c4fa170b191d94722923a3c869bc1eca24c7e444428e6b7a70"
+    },
+    "linux": {
+      "version": "2.6.1",
+      "expectedSize": 27332760,
+      "expectedChecksum": "0480a92f5af8e8441e680dc4e7995263",
+      "expectedChecksumSHA256": "4f60baf4649c670227314302056f50b1c40ccc8d673b98d16935977508342a67"
+    }
+  }
+}
diff --git a/src/emulator/downloadableEmulators.ts b/src/emulator/downloadableEmulators.ts
index 725fdf6e7e5..29f29eae686 100755
--- a/src/emulator/downloadableEmulators.ts
+++ b/src/emulator/downloadableEmulators.ts
@@ -22,60 +22,38 @@ import { EmulatorRegistry } from "./registry";
 import { downloadEmulator } from "../emulator/download";
 import * as experiments from "../experiments";
 import * as process from "process";
+import * as emulatorUpdateDetails from "./downloadableEmulatorInfo.json";
 
 const EMULATOR_INSTANCE_KILL_TIMEOUT = 4000; /* ms */
 
 const CACHE_DIR =
   process.env.FIREBASE_EMULATORS_PATH || path.join(os.homedir(), ".cache", "firebase", "emulators");
 
-const EMULATOR_UPDATE_DETAILS: { [s in DownloadableEmulators]: EmulatorUpdateDetails } = {
-  database: {
-    version: "4.11.2",
-    expectedSize: 34495935,
-    expectedChecksum: "2fd771101c0e1f7898c04c9204f2ce63",
-  },
-  firestore: {
-    version: "1.19.8",
-    expectedSize: 63634791,
-    expectedChecksum: "9b43a6daa590678de9b7df6d68260395",
-  },
-  storage: {
-    version: "1.1.3",
-    expectedSize: 52892936,
-    expectedChecksum: "2ca11ec1193003bea89f806cc085fa25",
-  },
-  ui: experiments.isEnabled("emulatoruisnapshot")
-    ? { version: "SNAPSHOT", expectedSize: -1, expectedChecksum: "" }
-    : {
-        version: "1.15.0",
-        expectedSize: 3538469,
-        expectedChecksum: "2f13d5aea9524564c8b7adaa9cfa2128",
-      },
-  pubsub: {
-    version: "0.8.14",
-    expectedSize: 66786933,
-    expectedChecksum: "a9025b3e53fdeafd2969ccb3ba1e1d38",
-  },
-  dataconnect:
-    process.platform === "darwin" // macos
-      ? {
-          version: "2.5.0",
-          expectedSize: 27378432,
-          expectedChecksum: "d18bc3a07be90886f6ec212f3393b66e",
-        }
-      : process.platform === "win32" // windows
-        ? {
-            version: "2.5.0",
-            expectedSize: 27836416,
-            expectedChecksum: "d335e9295b00381eb12682bc944ffef7",
-          }
-        : {
-            version: "2.5.0", // linux
-            expectedSize: 27295896,
-            expectedChecksum: "dc44dbfd972a9b3608794909df517077",
-          },
-};
-
+const EMULATOR_UPDATE_DETAILS: {
+  database: EmulatorUpdateDetails;
+  firestore: EmulatorUpdateDetails;
+  storage: EmulatorUpdateDetails;
+  pubsub: EmulatorUpdateDetails;
+  ui: {
+    main: EmulatorUpdateDetails;
+    snapshot: EmulatorUpdateDetails;
+  };
+  dataconnect: {
+    darwin: EmulatorUpdateDetails;
+    win32: EmulatorUpdateDetails;
+    linux: EmulatorUpdateDetails;
+  };
+} = emulatorUpdateDetails;
+
+const emulatorUiDetails = experiments.isEnabled("emulatoruisnapshot")
+  ? EMULATOR_UPDATE_DETAILS.ui.snapshot
+  : EMULATOR_UPDATE_DETAILS.ui.main;
+const dataconnectDetails =
+  process.platform === "darwin"
+    ? EMULATOR_UPDATE_DETAILS.dataconnect.darwin
+    : process.platform === "win32"
+      ? EMULATOR_UPDATE_DETAILS.dataconnect.win32
+      : EMULATOR_UPDATE_DETAILS.dataconnect.linux;
 export const DownloadDetails: { [s in DownloadableEmulators]: EmulatorDownloadDetails } = {
   database: {
     downloadPath: path.join(
@@ -120,20 +98,15 @@ export const DownloadDetails: { [s in DownloadableEmulators]: EmulatorDownloadDe
     },
   },
   ui: {
-    version: EMULATOR_UPDATE_DETAILS.ui.version,
-    downloadPath: path.join(CACHE_DIR, `ui-v${EMULATOR_UPDATE_DETAILS.ui.version}.zip`),
-    unzipDir: path.join(CACHE_DIR, `ui-v${EMULATOR_UPDATE_DETAILS.ui.version}`),
-    binaryPath: path.join(
-      CACHE_DIR,
-      `ui-v${EMULATOR_UPDATE_DETAILS.ui.version}`,
-      "server",
-      "server.mjs",
-    ),
+    version: emulatorUiDetails.version,
+    downloadPath: path.join(CACHE_DIR, `ui-v${emulatorUiDetails.version}.zip`),
+    unzipDir: path.join(CACHE_DIR, `ui-v${emulatorUiDetails.version}`),
+    binaryPath: path.join(CACHE_DIR, `ui-v${emulatorUiDetails.version}`, "server", "server.mjs"),
     opts: {
       cacheDir: CACHE_DIR,
-      remoteUrl: `https://storage.googleapis.com/firebase-preview-drop/emulator/ui-v${EMULATOR_UPDATE_DETAILS.ui.version}.zip`,
-      expectedSize: EMULATOR_UPDATE_DETAILS.ui.expectedSize,
-      expectedChecksum: EMULATOR_UPDATE_DETAILS.ui.expectedChecksum,
+      remoteUrl: `https://storage.googleapis.com/firebase-preview-drop/emulator/ui-v${emulatorUiDetails.version}.zip`,
+      expectedSize: emulatorUiDetails.expectedSize,
+      expectedChecksum: emulatorUiDetails.expectedChecksum,
       skipCache: experiments.isEnabled("emulatoruisnapshot"),
       skipChecksumAndSize: experiments.isEnabled("emulatoruisnapshot"),
       namePrefix: "ui",
@@ -162,23 +135,23 @@ export const DownloadDetails: { [s in DownloadableEmulators]: EmulatorDownloadDe
   dataconnect: {
     downloadPath: path.join(
       CACHE_DIR,
-      `dataconnect-emulator-${EMULATOR_UPDATE_DETAILS.dataconnect.version}${process.platform === "win32" ? ".exe" : ""}`,
+      `dataconnect-emulator-${dataconnectDetails.version}${process.platform === "win32" ? ".exe" : ""}`,
     ),
-    version: EMULATOR_UPDATE_DETAILS.dataconnect.version,
+    version: dataconnectDetails.version,
     binaryPath: path.join(
       CACHE_DIR,
-      `dataconnect-emulator-${EMULATOR_UPDATE_DETAILS.dataconnect.version}${process.platform === "win32" ? ".exe" : ""}`,
+      `dataconnect-emulator-${dataconnectDetails.version}${process.platform === "win32" ? ".exe" : ""}`,
     ),
     opts: {
       cacheDir: CACHE_DIR,
       remoteUrl:
         process.platform === "darwin"
-          ? `https://storage.googleapis.com/firemat-preview-drop/emulator/dataconnect-emulator-macos-v${EMULATOR_UPDATE_DETAILS.dataconnect.version}`
+          ? `https://storage.googleapis.com/firemat-preview-drop/emulator/dataconnect-emulator-macos-v${dataconnectDetails.version}`
           : process.platform === "win32"
-            ? `https://storage.googleapis.com/firemat-preview-drop/emulator/dataconnect-emulator-windows-v${EMULATOR_UPDATE_DETAILS.dataconnect.version}`
-            : `https://storage.googleapis.com/firemat-preview-drop/emulator/dataconnect-emulator-linux-v${EMULATOR_UPDATE_DETAILS.dataconnect.version}`,
-      expectedSize: EMULATOR_UPDATE_DETAILS.dataconnect.expectedSize,
-      expectedChecksum: EMULATOR_UPDATE_DETAILS.dataconnect.expectedChecksum,
+            ? `https://storage.googleapis.com/firemat-preview-drop/emulator/dataconnect-emulator-windows-v${dataconnectDetails.version}`
+            : `https://storage.googleapis.com/firemat-preview-drop/emulator/dataconnect-emulator-linux-v${dataconnectDetails.version}`,
+      expectedSize: dataconnectDetails.expectedSize,
+      expectedChecksum: dataconnectDetails.expectedChecksum,
       skipChecksumAndSize: false,
       namePrefix: "dataconnect-emulator",
       auth: false,
diff --git a/src/emulator/types.ts b/src/emulator/types.ts
index 1d0a96a41f7..a5460b9d161 100644
--- a/src/emulator/types.ts
+++ b/src/emulator/types.ts
@@ -185,6 +185,7 @@ export interface EmulatorUpdateDetails {
   version: string;
   expectedSize: number;
   expectedChecksum: string;
+  expectedChecksumSHA256: string; // TODO: Use this for validation within the CLI as well.
 }
 
 export interface EmulatorDownloadDetails {
diff --git a/src/extensions/manifest.ts b/src/extensions/manifest.ts
index 72f914240cd..980eb69c02c 100644
--- a/src/extensions/manifest.ts
+++ b/src/extensions/manifest.ts
@@ -1,4 +1,3 @@
-import * as clc from "colorette";
 import * as path from "path";
 import * as fs from "fs-extra";
 
@@ -9,7 +8,6 @@ import { logger } from "../logger";
 import { confirm, select } from "../prompt";
 import { readEnvFile } from "./paramHelper";
 import { FirebaseError } from "../error";
-import * as utils from "../utils";
 import { isLocalPath } from "./extensionsHelper";
 import { ParamType } from "./types";
 
@@ -217,7 +215,6 @@ export function writeExtensionsToFirebaseJson(specs: ManifestInstanceSpec[], con
   }
   config.set("extensions", extensions);
   config.writeProjectFile("firebase.json", config.src);
-  utils.logSuccess("Wrote extensions to " + clc.bold("firebase.json") + "...");
 }
 
 async function writeEnvFiles(
diff --git a/src/firebaseConfig.ts b/src/firebaseConfig.ts
index a107c42a487..6b1236adbc9 100644
--- a/src/firebaseConfig.ts
+++ b/src/firebaseConfig.ts
@@ -7,7 +7,7 @@
 
 import type { HttpsOptions } from "firebase-functions/v2/https";
 import { IngressSetting, MemoryOption, VpcEgressSetting } from "firebase-functions/v2/options";
-import { Runtime, DecommissionedRuntime } from "./deploy/functions/runtimes/supported/types";
+import { ActiveRuntime } from "./deploy/functions/runtimes/supported/types";
 
 /**
  * Creates a type that requires at least one key to be present in an interface
@@ -167,7 +167,7 @@ export type FirestoreConfig = FirestoreSingle | FirestoreMultiple;
 export type FunctionConfig = {
   source?: string;
   ignore?: string[];
-  runtime?: Exclude<Runtime, DecommissionedRuntime>;
+  runtime?: ActiveRuntime;
   codebase?: string;
 } & Deployable;
 
diff --git a/src/fsAsync.spec.ts b/src/fsAsync.spec.ts
index 2e6cd62729f..b4fee377249 100644
--- a/src/fsAsync.spec.ts
+++ b/src/fsAsync.spec.ts
@@ -13,10 +13,11 @@ import * as fsAsync from "./fsAsync";
 //   visible
 //   subdir/
 //     subfile
-//       nesteddir/
-//         nestedfile
-//       node_modules/
-//         nestednodemodules
+//     nesteddir/
+//       nestedfile
+//       nestedfile2
+//     node_modules/
+//       nestednodemodules
 //   node_modules
 //     subfile
 describe("fsAsync", () => {
@@ -26,6 +27,7 @@ describe("fsAsync", () => {
     "visible",
     "subdir/subfile",
     "subdir/nesteddir/nestedfile",
+    "subdir/nesteddir/nestedfile2",
     "subdir/node_modules/nestednodemodules",
     "node_modules/subfile",
   ];
@@ -93,5 +95,20 @@ describe("fsAsync", () => {
         .sort();
       return expect(gotFileNames).to.deep.equal(expectFiles);
     });
+
+    it("should support .gitignore rules via options", async () => {
+      const results = await fsAsync.readdirRecursive({
+        path: baseDir,
+        ignore: ["subdir/nesteddir/*", "!subdir/nesteddir/nestedfile"],
+        isGitIgnore: true,
+      });
+
+      const gotFileNames = results.map((r) => r.name).sort();
+      const expectFiles = files
+        .map((file) => path.join(baseDir, file))
+        .filter((file) => file !== path.join(baseDir, "subdir/nesteddir/nestedfile2"))
+        .sort();
+      return expect(gotFileNames).to.deep.equal(expectFiles);
+    });
   });
 });
diff --git a/src/fsAsync.ts b/src/fsAsync.ts
index f8a9eee66d3..26123f9636b 100644
--- a/src/fsAsync.ts
+++ b/src/fsAsync.ts
@@ -1,13 +1,17 @@
-import { join } from "path";
 import { readdirSync, statSync } from "fs-extra";
+import ignorePkg from "ignore";
 import * as _ from "lodash";
 import * as minimatch from "minimatch";
+import { join, relative } from "path";
 
 export interface ReaddirRecursiveOpts {
   // The directory to recurse.
   path: string;
   // Files to ignore.
   ignore?: string[];
+  isGitIgnore?: boolean;
+  // Files in the ignore array to include.
+  include?: string[];
 }
 
 export interface ReaddirRecursiveFile {
@@ -52,12 +56,21 @@ export async function readdirRecursive(
   const rules = (options.ignore || []).map((glob) => {
     return (p: string) => minimatch(p, glob, mmopts);
   });
+  const gitIgnoreRules = ignorePkg()
+    .add(options.ignore || [])
+    .createFilter();
+
   const filter = (t: string): boolean => {
+    if (options.isGitIgnore) {
+      // the git ignore filter will return true if given path should be included,
+      // so we need to negative that return false to avoid filtering it.
+      return !gitIgnoreRules(relative(options.path, t));
+    }
     return rules.some((rule) => {
       return rule(t);
     });
   };
-  return readdirRecursiveHelper({
+  return await readdirRecursiveHelper({
     path: options.path,
     filter: filter,
   });
diff --git a/src/functions/projectConfig.spec.ts b/src/functions/projectConfig.spec.ts
index 4c6e568cfb4..de9e8d97b84 100644
--- a/src/functions/projectConfig.spec.ts
+++ b/src/functions/projectConfig.spec.ts
@@ -29,7 +29,7 @@ describe("projectConfig", () => {
     });
 
     it("fails validation given config w/o source", () => {
-      expect(() => projectConfig.validate([{ runtime: "nodejs10" }])).to.throw(
+      expect(() => projectConfig.validate([{ runtime: "nodejs22" }])).to.throw(
         FirebaseError,
         /codebase source must be specified/,
       );
@@ -84,7 +84,7 @@ describe("projectConfig", () => {
     });
 
     it("fails validation given singleton config w/o source", () => {
-      expect(() => projectConfig.normalizeAndValidate({ runtime: "nodejs10" })).to.throw(
+      expect(() => projectConfig.normalizeAndValidate({ runtime: "nodejs22" })).to.throw(
         FirebaseError,
         /codebase source must be specified/,
       );
@@ -98,7 +98,7 @@ describe("projectConfig", () => {
     });
 
     it("fails validation given multi-resource config w/o source", () => {
-      expect(() => projectConfig.normalizeAndValidate([{ runtime: "nodejs10" }])).to.throw(
+      expect(() => projectConfig.normalizeAndValidate([{ runtime: "nodejs22" }])).to.throw(
         FirebaseError,
         /codebase source must be specified/,
       );
diff --git a/src/gcp/apphosting.ts b/src/gcp/apphosting.ts
index 8d734426fc6..0f711abc2db 100644
--- a/src/gcp/apphosting.ts
+++ b/src/gcp/apphosting.ts
@@ -42,6 +42,11 @@ export interface Backend {
   uri: string;
   serviceAccount?: string;
   appId?: string;
+  managedResources?: ManagedResource[];
+}
+
+export interface ManagedResource {
+  runService: { service: string };
 }
 
 export type BackendOutputOnlyFields = "name" | "createTime" | "updateTime" | "uri";
@@ -333,6 +338,19 @@ export async function getBackend(
   return res.body;
 }
 
+/**
+ * Gets traffic details.
+ */
+export async function getTraffic(
+  projectId: string,
+  location: string,
+  backendId: string,
+): Promise<Traffic> {
+  const name = `projects/${projectId}/locations/${location}/backends/${backendId}/traffic`;
+  const res = await client.get<Traffic>(name);
+  return res.body;
+}
+
 /**
  * List all backends present in a project and location.
  */
diff --git a/src/gcp/cloudfunctions.ts b/src/gcp/cloudfunctions.ts
index ae73d0f73bc..a9f240e0265 100644
--- a/src/gcp/cloudfunctions.ts
+++ b/src/gcp/cloudfunctions.ts
@@ -358,6 +358,12 @@ export async function updateFunction(
   cloudFunction: Omit<CloudFunction, OutputOnlyFields>,
 ): Promise<Operation> {
   const endpoint = `/${cloudFunction.name}`;
+  cloudFunction.buildEnvironmentVariables = {
+    ...cloudFunction.buildEnvironmentVariables,
+    // Disable GCF from automatically running npm run build script
+    // https://cloud.google.com/functions/docs/release-notes
+    GOOGLE_NODE_RUN_SCRIPTS: "",
+  };
   // Keys in labels and environmentVariables and secretEnvironmentVariables are user defined,
   // so we don't recurse for field masks.
   const fieldMasks = proto.fieldMasks(
@@ -365,16 +371,9 @@ export async function updateFunction(
     /* doNotRecurseIn...=*/ "labels",
     "environmentVariables",
     "secretEnvironmentVariables",
+    "buildEnvironmentVariables",
   );
 
-  cloudFunction.buildEnvironmentVariables = {
-    ...cloudFunction.buildEnvironmentVariables,
-    // Disable GCF from automatically running npm run build script
-    // https://cloud.google.com/functions/docs/release-notes
-    GOOGLE_NODE_RUN_SCRIPTS: "",
-  };
-  fieldMasks.push("buildEnvironmentVariables");
-
   // Failure policy is always an explicit policy and is only signified by the presence or absence of
   // a protobuf.Empty value, so we have to manually add it in the missing case.
   try {
diff --git a/src/gcp/cloudfunctionsv2.ts b/src/gcp/cloudfunctionsv2.ts
index c11c6ed86dd..bf951c1099f 100644
--- a/src/gcp/cloudfunctionsv2.ts
+++ b/src/gcp/cloudfunctionsv2.ts
@@ -421,29 +421,27 @@ async function listFunctionsInternal(
  * Customers can force a field to be deleted by setting that field to `undefined`
  */
 export async function updateFunction(cloudFunction: InputCloudFunction): Promise<Operation> {
-  // Keys in labels and environmentVariables and secretEnvironmentVariables are user defined, so we don't recurse
-  // for field masks.
-  const fieldMasks = proto.fieldMasks(
-    cloudFunction,
-    /* doNotRecurseIn...=*/ "labels",
-    "serviceConfig.environmentVariables",
-    "serviceConfig.secretEnvironmentVariables",
-  );
-
   cloudFunction.buildConfig.environmentVariables = {
     ...cloudFunction.buildConfig.environmentVariables,
     // Disable GCF from automatically running npm run build script
     // https://cloud.google.com/functions/docs/release-notes
     GOOGLE_NODE_RUN_SCRIPTS: "",
   };
-  fieldMasks.push("buildConfig.buildEnvironmentVariables");
-
   cloudFunction.serviceConfig.environmentVariables = {
     ...cloudFunction.serviceConfig.environmentVariables,
     FUNCTION_TARGET: cloudFunction.buildConfig.entryPoint.replaceAll("-", "."),
     // Enable logging execution id by default for better debugging
     LOG_EXECUTION_ID: "true",
   };
+  // Keys in labels and environmentVariables and secretEnvironmentVariables are user defined, so we don't recurse
+  // for field masks.
+  const fieldMasks = proto.fieldMasks(
+    cloudFunction,
+    /* doNotRecurseIn...=*/ "labels",
+    "serviceConfig.environmentVariables",
+    "serviceConfig.secretEnvironmentVariables",
+    "buildConfig.environmentVariables",
+  );
 
   try {
     const queryParams = {
diff --git a/src/gcp/cloudscheduler.spec.ts b/src/gcp/cloudscheduler.spec.ts
index b329b189702..b2801ba11f6 100644
--- a/src/gcp/cloudscheduler.spec.ts
+++ b/src/gcp/cloudscheduler.spec.ts
@@ -174,9 +174,9 @@ describe("cloudscheduler", () => {
       uri: "https://my-uri.com",
     };
 
-    it("should copy minimal fields for v1 endpoints", () => {
+    it("should copy minimal fields for v1 endpoints", async () => {
       expect(
-        cloudscheduler.jobFromEndpoint(V1_ENDPOINT, "appEngineLocation", "1234567"),
+        await cloudscheduler.jobFromEndpoint(V1_ENDPOINT, "appEngineLocation", "1234567"),
       ).to.deep.equal({
         name: "projects/project/locations/appEngineLocation/jobs/firebase-schedule-id-region",
         schedule: "every 1 minutes",
@@ -190,9 +190,9 @@ describe("cloudscheduler", () => {
       });
     });
 
-    it("should copy minimal fields for v2 endpoints", () => {
+    it("should copy minimal fields for v2 endpoints", async () => {
       expect(
-        cloudscheduler.jobFromEndpoint(V2_ENDPOINT, V2_ENDPOINT.region, "1234567"),
+        await cloudscheduler.jobFromEndpoint(V2_ENDPOINT, V2_ENDPOINT.region, "1234567"),
       ).to.deep.equal({
         name: "projects/project/locations/region/jobs/firebase-schedule-id-region",
         schedule: "every 1 minutes",
@@ -207,9 +207,9 @@ describe("cloudscheduler", () => {
       });
     });
 
-    it("should copy optional fields for v1 endpoints", () => {
+    it("should copy optional fields for v1 endpoints", async () => {
       expect(
-        cloudscheduler.jobFromEndpoint(
+        await cloudscheduler.jobFromEndpoint(
           {
             ...V1_ENDPOINT,
             scheduleTrigger: {
@@ -245,9 +245,9 @@ describe("cloudscheduler", () => {
       });
     });
 
-    it("should copy optional fields for v2 endpoints", () => {
+    it("should copy optional fields for v2 endpoints", async () => {
       expect(
-        cloudscheduler.jobFromEndpoint(
+        await cloudscheduler.jobFromEndpoint(
           {
             ...V2_ENDPOINT,
             scheduleTrigger: {
diff --git a/src/gcp/cloudscheduler.ts b/src/gcp/cloudscheduler.ts
index e82d96bdba2..89bf58a900c 100644
--- a/src/gcp/cloudscheduler.ts
+++ b/src/gcp/cloudscheduler.ts
@@ -224,11 +224,11 @@ export function topicNameForEndpoint(
 }
 
 /** Converts an Endpoint to a CloudScheduler v1 job */
-export function jobFromEndpoint(
+export async function jobFromEndpoint(
   endpoint: backend.Endpoint & backend.ScheduleTriggered,
   location: string,
   projectNumber: string,
-): Job {
+): Promise<Job> {
   const job: Partial<Job> = {};
   job.name = jobNameForEndpoint(endpoint, location);
   if (endpoint.platform === "gcfv1") {
@@ -245,7 +245,8 @@ export function jobFromEndpoint(
       uri: endpoint.uri!,
       httpMethod: "POST",
       oidcToken: {
-        serviceAccountEmail: endpoint.serviceAccount ?? gce.getDefaultServiceAccount(projectNumber),
+        serviceAccountEmail:
+          endpoint.serviceAccount ?? (await gce.getDefaultServiceAccount(projectNumber)),
       },
     };
   } else {
diff --git a/src/gcp/computeEngine.ts b/src/gcp/computeEngine.ts
index 28a1746974c..304fc86afb4 100644
--- a/src/gcp/computeEngine.ts
+++ b/src/gcp/computeEngine.ts
@@ -1,4 +1,25 @@
+import { logger } from "../logger";
+import { computeOrigin } from "../api";
+import { Client } from "../apiv2";
+
+const computeClient = () => new Client({ urlPrefix: computeOrigin() });
+const defaultServiceAccountCache: Record<string, string> = {};
 /** Returns the default compute engine service agent */
-export function getDefaultServiceAccount(projectNumber: string): string {
-  return `${projectNumber}-compute@developer.gserviceaccount.com`;
+export async function getDefaultServiceAccount(projectNumber: string): Promise<string> {
+  if (defaultServiceAccountCache[projectNumber]) {
+    return defaultServiceAccountCache[projectNumber];
+  }
+  try {
+    const res = await computeClient().get<{ defaultServiceAccount: string }>(
+      `compute/v1/projects/${projectNumber}`,
+    );
+    defaultServiceAccountCache[projectNumber] = res.body.defaultServiceAccount;
+    return res.body.defaultServiceAccount;
+  } catch (err: any) {
+    const bestGuess = `${projectNumber}-compute@developer.gserviceaccount.com`;
+    logger.debug(
+      `unable to look up default compute service account. Falling back to ${bestGuess}. Error: ${JSON.stringify(err)}`,
+    );
+    return bestGuess;
+  }
 }
diff --git a/src/gcp/firestore.ts b/src/gcp/firestore.ts
index 3dba011278b..853a41f349f 100644
--- a/src/gcp/firestore.ts
+++ b/src/gcp/firestore.ts
@@ -33,6 +33,49 @@ export interface Database {
   etag: string;
 }
 
+interface FieldFilter {
+  field: { fieldPath: string };
+  op:
+    | "OPERATOR_UNSPECIFIED"
+    | "LESS_THAN"
+    | "LESS_THAN_OR_EQUAL"
+    | "GREATER_THAN"
+    | "GREATER_THAN_OR_EQUAL"
+    | "EQUAL"
+    | "NOT_EQUAL"
+    | "ARRAY_CONTAINS"
+    | "ARRAY_CONTAINS_ANY"
+    | "IN"
+    | "NOT_IN";
+  value: FirestoreValue;
+}
+
+interface CompositeFilter {
+  op: "OR" | "AND";
+  filters: {
+    fieldFilter?: FieldFilter;
+    compositeFilter?: CompositeFilter;
+  }[];
+}
+
+export interface StructuredQuery {
+  from: { collectionId: string; allDescendants: boolean }[];
+  where?: {
+    compositeFilter?: CompositeFilter;
+    fieldFilter?: FieldFilter;
+  };
+  orderBy?: {
+    field: { fieldPath: string };
+    direction: "ASCENDING" | "DESCENDING" | "DIRECTION_UNSPECIFIED";
+  }[];
+  limit?: number;
+}
+
+interface RunQueryResponse {
+  document?: FirestoreDocument;
+  readTime?: string;
+}
+
 export enum DayOfWeek {
   MONDAY = "MONDAY",
   TUEDAY = "TUESDAY",
@@ -144,7 +187,7 @@ export function listCollectionIds(
  * Get multiple documents by path.
  * @param {string} project the Google Cloud project ID.
  * @param {string[]} paths The document paths to fetch.
- * @return {Promise<string[]>} a promise for an array of collection IDs.
+ * @return {Promise<{ documents: FirestoreDocument[]; missing: string[] }>} a promise for an array of firestore documents and missing documents in the request.
  */
 export async function getDocuments(
   project: string,
@@ -164,6 +207,49 @@ export async function getDocuments(
   return out;
 }
 
+/**
+ * Get documents based on a simple query to a collection.
+ * @param {string} project the Google Cloud project ID.
+ * @param {StructuredQuery} structuredQuery The structured query of the request including filters and ordering.
+ * @return {Promise<{ documents: FirestoreDocument[] }>} a promise for an array of retrieved firestore documents.
+ */
+export async function queryCollection(
+  project: string,
+  structuredQuery: StructuredQuery,
+  allowEmulator?: boolean,
+): Promise<{ documents: FirestoreDocument[] }> {
+  const apiClient = allowEmulator ? emuOrProdClient : prodOnlyClient;
+  const basePath = `projects/${project}/databases/(default)/documents`;
+  const url = `${basePath}:runQuery`;
+  try {
+    const res = await apiClient.post<
+      {
+        structuredQuery: StructuredQuery;
+        explainOptions: { analyze: boolean };
+        newTransaction: { readOnly: { readTime: string } };
+        // readTime: string;
+      },
+      RunQueryResponse[]
+    >(url, {
+      structuredQuery: structuredQuery,
+      explainOptions: { analyze: true },
+      newTransaction: { readOnly: { readTime: new Date().toISOString() } },
+      // readTime: new Date().toISOString(),
+    });
+    const out: { documents: FirestoreDocument[] } = { documents: [] };
+    res.body.map((r) => {
+      if (r.document) {
+        out.documents.push(r.document);
+      }
+    });
+    return out;
+  } catch (err: FirebaseError | unknown) {
+    // Used to get the URL to automatically build the composite index.
+    // Otherwise a generic 400 error is returned to the user without info.
+    throw JSON.stringify(err);
+  }
+}
+
 /**
  * Delete a single Firestore document.
  *
diff --git a/src/gcp/iam.ts b/src/gcp/iam.ts
index 6b722f1f43a..74bf9264bee 100644
--- a/src/gcp/iam.ts
+++ b/src/gcp/iam.ts
@@ -10,11 +10,6 @@ export function getDefaultCloudBuildServiceAgent(projectNumber: string): string
   return `${projectNumber}@cloudbuild.gserviceaccount.com`;
 }
 
-/** Returns the default compute engine service agent */
-export function getDefaultComputeEngineServiceAgent(projectNumber: string): string {
-  return `${projectNumber}-compute@developer.gserviceaccount.com`;
-}
-
 // IAM Policy
 // https://cloud.google.com/resource-manager/reference/rest/Shared.Types/Policy
 export interface Binding {
diff --git a/src/gcp/run.ts b/src/gcp/run.ts
index 286f12e82f9..3c075f3b220 100644
--- a/src/gcp/run.ts
+++ b/src/gcp/run.ts
@@ -5,6 +5,7 @@ import * as proto from "./proto";
 import * as iam from "./iam";
 import { backoff } from "../throttler/throttler";
 import { logger } from "../logger";
+import { listEntries, LogEntry } from "./cloudlogging";
 
 const API_VERSION = "v1";
 
@@ -344,3 +345,25 @@ export async function setInvokerUpdate(
   };
   await setIamPolicy(serviceName, policy, httpClient);
 }
+
+/**
+ * Fetches recent logs for a given Cloud Run service using the Cloud Logging API.
+ * @param projectId The Google Cloud project ID.
+ * @param serviceId The resource name of the Cloud Run service.
+ * @return A promise that resolves with the log entries.
+ */
+export async function fetchServiceLogs(projectId: string, serviceId: string): Promise<LogEntry[]> {
+  const filter = `resource.type="cloud_run_revision" AND resource.labels.service_name="${serviceId}"`;
+  const pageSize = 100;
+  const order = "desc";
+
+  try {
+    const entries = await listEntries(projectId, filter, pageSize, order);
+    return entries || [];
+  } catch (err: any) {
+    throw new FirebaseError(`Failed to fetch logs for Cloud Run service ${serviceId}`, {
+      original: err,
+      status: (err as any)?.context?.response?.statusCode,
+    });
+  }
+}
diff --git a/src/init/features/apphosting.ts b/src/init/features/apphosting.ts
index af3b2fd10a6..a49798b9850 100644
--- a/src/init/features/apphosting.ts
+++ b/src/init/features/apphosting.ts
@@ -2,9 +2,12 @@ import * as clc from "colorette";
 import { existsSync } from "fs";
 import * as ora from "ora";
 import * as path from "path";
+import { Setup } from "..";
 import { webApps } from "../../apphosting/app";
 import {
   createBackend,
+  ensureAppHostingComputeServiceAccount,
+  ensureRequiredApisEnabled,
   promptExistingBackend,
   promptLocation,
   promptNewBackendId,
@@ -12,12 +15,12 @@ import {
 import { Config } from "../../config";
 import { FirebaseError } from "../../error";
 import { AppHostingSingle } from "../../firebaseConfig";
+import { ensureApiEnabled } from "../../gcp/apphosting";
+import { isBillingEnabled } from "../../gcp/cloudbilling";
+import { input, select } from "../../prompt";
 import { readTemplateSync } from "../../templates";
 import * as utils from "../../utils";
 import { logBullet } from "../../utils";
-import { input, select } from "../../prompt";
-import { Setup } from "..";
-import { isBillingEnabled } from "../../gcp/cloudbilling";
 
 const APPHOSTING_YAML_TEMPLATE = readTemplateSync("init/apphosting/apphosting.yaml");
 
@@ -28,9 +31,33 @@ export async function doSetup(setup: Setup, config: Config): Promise<void> {
   const projectId = setup.projectId as string;
   if (!(await isBillingEnabled(setup))) {
     throw new FirebaseError(
-      "Firebase App Hosting requires billing to be enabled on your project. Please enable billing by following the steps at https://cloud.google.com/billing/docs/how-to/modify-project",
+      `Firebase App Hosting requires billing to be enabled on your project. To upgrade, visit the following URL: https://console.firebase.google.com/project/${projectId}/usage/details`,
     );
   }
+  await ensureApiEnabled({ projectId });
+  await ensureRequiredApisEnabled(projectId);
+  // N.B. Deploying a backend from source requires the App Hosting compute service
+  // account to have the storage.objectViewer IAM role.
+  //
+  // We don't want to update the IAM permissions right before attempting to deploy,
+  // since IAM propagation delay will likely cause the first one to fail. However,
+  // `firebase init apphosting` is a prerequisite to the `firebase deploy` command,
+  // so we check and add the role here to give the IAM changes time to propagate.
+  try {
+    await ensureAppHostingComputeServiceAccount(
+      projectId,
+      /* serviceAccount= */ "",
+      /* deployFromSource= */ true,
+    );
+  } catch (err) {
+    if ((err as FirebaseError).status === 400) {
+      utils.logWarning(
+        "Your App Hosting compute service account is still being provisioned. Please try again in a few moments.",
+      );
+    }
+    throw err;
+  }
+
   utils.logBullet(
     "This command links your local project to Firebase App Hosting. You will be able to deploy your web app with `firebase deploy` after setup.",
   );
@@ -90,7 +117,6 @@ export async function doSetup(setup: Setup, config: Config): Promise<void> {
   });
 
   upsertAppHostingConfig(backendConfig, config);
-  utils.logBullet("Writing configuration info to firebase.json...");
   config.writeProjectFile("firebase.json", config.src);
 
   utils.logBullet("Writing default settings to " + clc.bold("apphosting.yaml") + "...");
diff --git a/src/init/features/database.ts b/src/init/features/database.ts
index fdbff5ac8fe..c604268c117 100644
--- a/src/init/features/database.ts
+++ b/src/init/features/database.ts
@@ -2,7 +2,6 @@ import * as clc from "colorette";
 import { confirm, input, select } from "../../prompt";
 import { logger } from "../../logger";
 import * as utils from "../../utils";
-import * as fsutils from "../../fsutils";
 import { Config } from "../../config";
 import {
   createInstance,
@@ -20,7 +19,15 @@ import { Client } from "../../apiv2";
 import { rtdbManagementOrigin } from "../../api";
 import { Setup } from "..";
 
-const DEFAULT_RULES = JSON.stringify(
+export interface RequiredInfo {
+  rulesFilename: string;
+  rules: string;
+  writeRules: boolean;
+}
+
+const DEFAULT_RULES_FILENAME = "database.rules.json";
+
+export const DEFAULT_RULES = JSON.stringify(
   { rules: { ".read": "auth != null", ".write": "auth != null" } },
   null,
   2,
@@ -43,18 +50,10 @@ async function getDBRules(instanceDetails: DatabaseInstance): Promise<string> {
   return await response.response.text();
 }
 
-function writeDBRules(
-  rules: string,
-  logMessagePrefix: string,
-  filename: string,
-  config: Config,
-): void {
+function writeDBRules(rules: string, filename: string, config: Config): void {
   config.writeProjectFile(filename, rules);
-  utils.logSuccess(`${logMessagePrefix} have been written to ${clc.bold(filename)}.`);
   logger.info(
-    `Future modifications to ${clc.bold(
-      filename,
-    )} will update Realtime Database Security Rules when you run`,
+    `Future modifications to ${clc.bold(filename)} will update Realtime Database Security Rules when you run`,
   );
   logger.info(clc.bold("firebase deploy") + ".");
 }
@@ -134,14 +133,7 @@ async function initializeDatabaseInstance(projectId: string): Promise<DatabaseIn
  * @param setup information helpful for database setup
  * @param config legacy config parameter. not used for database setup.
  */
-export async function doSetup(setup: Setup, config: Config): Promise<void> {
-  setup.config = setup.config || {};
-
-  let instanceDetails: DatabaseInstance | null = null;
-  if (setup.projectId) {
-    instanceDetails = await initializeDatabaseInstance(setup.projectId);
-  }
-
+export async function askQuestions(setup: Setup, config: Config): Promise<void> {
   logger.info();
   logger.info(
     "Firebase Realtime Database Security Rules allow you to define how your data should be",
@@ -149,46 +141,54 @@ export async function doSetup(setup: Setup, config: Config): Promise<void> {
   logger.info("structured and when your data can be read from and written to.");
   logger.info();
 
-  const filename = await input({
+  const rulesFilename = await input({
     message: "What file should be used for Realtime Database Security Rules?",
-    default: "database.rules.json",
+    default: DEFAULT_RULES_FILENAME,
   });
-  if (!filename) {
+  if (!rulesFilename) {
     throw new FirebaseError("Must specify location for Realtime Database rules file.");
   }
-
-  // Add 'database' section to config
-  setup.config.database = { rules: filename };
-
-  let writeRules = true;
-  if (fsutils.fileExistsSync(filename)) {
-    const rulesDescription = instanceDetails
-      ? `the Realtime Database Security Rules for ${clc.bold(instanceDetails.name)} from the Firebase console`
-      : "default rules";
-    const msg = `File ${clc.bold(
-      filename,
-    )} already exists. Do you want to overwrite it with ${rulesDescription}?`;
-
-    writeRules = await confirm(msg);
-  }
-  if (writeRules) {
+  const info: RequiredInfo = {
+    rulesFilename,
+    rules: DEFAULT_RULES,
+    writeRules: true,
+  };
+  if (setup.projectId) {
+    const instanceDetails = await initializeDatabaseInstance(setup.projectId);
     if (instanceDetails) {
-      writeDBRules(
-        await getDBRules(instanceDetails),
-        `Database Rules for ${instanceDetails.name}`,
-        filename,
-        config,
+      info.rules = await getDBRules(instanceDetails);
+      utils.logBullet(
+        `Downloaded the existing Realtime Database Security Rules of database ${clc.bold(instanceDetails.name)} from the Firebase console`,
       );
-      return;
     }
-    writeDBRules(DEFAULT_RULES, "Default rules", filename, config);
-    return;
   }
-  logger.info("Skipping overwrite of Realtime Database Security Rules.");
-  logger.info(
-    `The security rules defined in ${clc.bold(filename)} will be published when you run ${clc.bold(
-      "firebase deploy",
-    )}.`,
-  );
-  return;
+  info.writeRules = await config.confirmWriteProjectFile(rulesFilename, info.rules);
+  // Populate featureInfo for the actuate step later.
+  setup.featureInfo = setup.featureInfo || {};
+  setup.featureInfo.database = info;
+}
+
+export async function actuate(setup: Setup, config: Config): Promise<void> {
+  const info = setup.featureInfo?.database;
+  if (!info) {
+    throw new FirebaseError("No database RequiredInfo found in setup actuate.");
+  }
+  // Populate defaults and update `firebase.json` config.
+  info.rules = info.rules || DEFAULT_RULES;
+  info.rulesFilename = info.rulesFilename || "database.rules.json";
+  setup.config.database = { rules: info.rulesFilename };
+
+  if (info.writeRules) {
+    if (info.rules === DEFAULT_RULES) {
+      writeDBRules(info.rules, info.rulesFilename, config);
+    } else {
+      writeDBRules(info.rules, info.rulesFilename, config);
+    }
+  } else {
+    logger.info("Skipping overwrite of Realtime Database Security Rules.");
+    logger.info(
+      `The security rules defined in ${clc.bold(info.rulesFilename)} will be published when you run ${clc.bold("firebase deploy")}.`,
+    );
+  }
+  return Promise.resolve();
 }
diff --git a/src/init/features/dataconnect/index.spec.ts b/src/init/features/dataconnect/index.spec.ts
index 9fa1fe0ab32..53d7b5a55c6 100644
--- a/src/init/features/dataconnect/index.spec.ts
+++ b/src/init/features/dataconnect/index.spec.ts
@@ -58,7 +58,14 @@ describe("init dataconnect", () => {
         requiredInfo: mockRequiredInfo(),
         config: mockConfig({ dataconnect: { source: "not-dataconnect" } }),
         expectedSource: "not-dataconnect",
-        expectedFiles: ["not-dataconnect/dataconnect.yaml"],
+        expectedFiles: [
+          "not-dataconnect/dataconnect.yaml",
+          // Populate the default template.
+          "not-dataconnect/schema/schema.gql",
+          "not-dataconnect/connector/connector.yaml",
+          "not-dataconnect/connector/queries.gql",
+          "not-dataconnect/connector/mutations.gql",
+        ],
         expectCSQLProvisioning: false,
         expectEnsureSchemaGQL: false,
       },
@@ -125,6 +132,18 @@ describe("init dataconnect", () => {
         desc: "should handle schema with no files",
         requiredInfo: mockRequiredInfo({
           schemaGql: [],
+          connectors: [
+            {
+              id: "my-connector",
+              path: "hello",
+              files: [
+                {
+                  path: "queries.gql",
+                  content: "## Fake GQL",
+                },
+              ],
+            },
+          ],
         }),
         config: mockConfig({
           dataconnect: {
@@ -132,7 +151,11 @@ describe("init dataconnect", () => {
           },
         }),
         expectedSource: "dataconnect",
-        expectedFiles: ["dataconnect/dataconnect.yaml"],
+        expectedFiles: [
+          "dataconnect/dataconnect.yaml",
+          "dataconnect/hello/connector.yaml",
+          "dataconnect/hello/queries.gql",
+        ],
         expectCSQLProvisioning: false,
         expectEnsureSchemaGQL: true,
       },
@@ -151,6 +174,7 @@ describe("init dataconnect", () => {
             featureInfo: { dataconnect: c.requiredInfo },
           },
           c.config,
+          {},
         );
         expect(c.config.get("dataconnect.source")).to.equal(c.expectedSource);
         if (c.expectEnsureSchemaGQL) {
diff --git a/src/init/features/dataconnect/index.ts b/src/init/features/dataconnect/index.ts
index b4e712eaab0..c23903192bf 100644
--- a/src/init/features/dataconnect/index.ts
+++ b/src/init/features/dataconnect/index.ts
@@ -88,12 +88,12 @@ export async function askQuestions(setup: Setup): Promise<void> {
     isNewInstance: false,
     cloudSqlDatabase: "",
     isNewDatabase: false,
-    connectors: [defaultConnector],
-    schemaGql: [defaultSchema],
+    connectors: [],
+    schemaGql: [],
     shouldProvisionCSQL: false,
   };
   // Query backend and pick up any existing services quickly.
-  info = await promptForExistingServices(setup, info, hasBilling);
+  info = await promptForExistingServices(setup, info);
 
   const requiredConfigUnset =
     info.serviceId === "" ||
@@ -110,6 +110,7 @@ export async function askQuestions(setup: Setup): Promise<void> {
       default: true,
     }));
   if (shouldConfigureBackend) {
+    // TODO: Prompt for app idea and use GiF backend to generate them.
     info = await promptForService(info);
     info = await promptForCloudSQL(setup, info);
 
@@ -122,14 +123,6 @@ export async function askQuestions(setup: Setup): Promise<void> {
         default: true,
       }))
     );
-  } else {
-    // Ensure that the suggested name is DNS compatible
-    const defaultServiceId = toDNSCompatibleId(basename(process.cwd()));
-    info.serviceId = info.serviceId || defaultServiceId;
-    info.cloudSqlInstanceId =
-      info.cloudSqlInstanceId || `${info.serviceId.toLowerCase() || "app"}-fdc`;
-    info.locationId = info.locationId || `us-central1`;
-    info.cloudSqlDatabase = info.cloudSqlDatabase || `fdcdb`;
   }
   setup.featureInfo = setup.featureInfo || {};
   setup.featureInfo.dataconnect = info;
@@ -137,7 +130,7 @@ export async function askQuestions(setup: Setup): Promise<void> {
 
 // actuate writes product specific files and makes product specifc API calls.
 // It does not handle writing firebase.json and .firebaserc
-export async function actuate(setup: Setup, config: Config): Promise<void> {
+export async function actuate(setup: Setup, config: Config, options: any): Promise<void> {
   // Most users will want to persist data between emulator runs, so set this to a reasonable default.
   const dir: string = config.get("dataconnect.source", "dataconnect");
   const dataDir = config.get("emulators.dataconnect.dataDir", `${dir}/.dataconnect/pgliteData`);
@@ -147,7 +140,21 @@ export async function actuate(setup: Setup, config: Config): Promise<void> {
   if (!info) {
     throw new Error("Data Connect feature RequiredInfo is not provided");
   }
-  await writeFiles(config, info);
+  // Populate the default values of required fields.
+  const defaultServiceId = toDNSCompatibleId(basename(process.cwd()));
+  info.serviceId = info.serviceId || defaultServiceId;
+  info.cloudSqlInstanceId =
+    info.cloudSqlInstanceId || `${info.serviceId.toLowerCase() || "app"}-fdc`;
+  info.locationId = info.locationId || `us-central1`;
+  info.cloudSqlDatabase = info.cloudSqlDatabase || `fdcdb`;
+  // Make sure to add some GQL files.
+  // Use the template if it starts from scratch or the existing service has no GQL source.
+  if (!info.schemaGql.length && !info.connectors.flatMap((r) => r.files).length) {
+    info.schemaGql = [defaultSchema];
+    info.connectors = [defaultConnector];
+  }
+
+  await writeFiles(config, info, options);
 
   if (setup.projectId && info.shouldProvisionCSQL) {
     await provisionCloudSql({
@@ -175,27 +182,17 @@ export async function postSetup(setup: Setup, config: Config): Promise<void> {
   }
 }
 
-async function writeFiles(config: Config, info: RequiredInfo) {
+async function writeFiles(config: Config, info: RequiredInfo, options: any): Promise<void> {
   const dir: string = config.get("dataconnect.source") || "dataconnect";
   const subbedDataconnectYaml = subDataconnectYamlValues({
     ...info,
     connectorDirs: info.connectors.map((c) => c.path),
   });
-  // If we are starting from a fresh project without data connect,
-  if (!config.get("dataconnect.source")) {
-    // Make sure to add add some GQL files.
-    // Use the template if the existing service is empty (no schema / connector GQL).
-    if (!info.schemaGql.length && !info.connectors.flatMap((r) => r.files).length) {
-      info.schemaGql = [defaultSchema];
-      info.connectors = [defaultConnector];
-    }
-  }
-
   config.set("dataconnect", { source: dir });
   await config.askWriteProjectFile(
     join(dir, "dataconnect.yaml"),
     subbedDataconnectYaml,
-    false,
+    !!options.force,
     // Default to override dataconnect.yaml
     // Sole purpose of `firebase init dataconnect` is to update `dataconnect.yaml`.
     true,
@@ -203,7 +200,7 @@ async function writeFiles(config: Config, info: RequiredInfo) {
 
   if (info.schemaGql.length) {
     for (const f of info.schemaGql) {
-      await config.askWriteProjectFile(join(dir, "schema", f.path), f.content);
+      await config.askWriteProjectFile(join(dir, "schema", f.path), f.content, !!options.force);
     }
   } else {
     // Even if the schema is empty, lets give them an empty .gql file to get started.
@@ -266,24 +263,15 @@ function subConnectorYamlValues(replacementValues: { connectorId: string }): str
   return replaced;
 }
 
-async function promptForExistingServices(
-  setup: Setup,
-  info: RequiredInfo,
-  isBillingEnabled: boolean,
-): Promise<RequiredInfo> {
-  if (!setup.projectId || !isBillingEnabled) {
-    // TODO(b/368609569): Don't gate this behind billing once backend billing fix is rolled out.
+async function promptForExistingServices(setup: Setup, info: RequiredInfo): Promise<RequiredInfo> {
+  // Check for existing Firebase Data Connect services.
+  if (!setup.projectId) {
     return info;
   }
-
-  // Check for existing Firebase Data Connect services.
   const existingServices = await listAllServices(setup.projectId);
   const existingServicesAndSchemas = await Promise.all(
     existingServices.map(async (s) => {
-      return {
-        service: s,
-        schema: await getSchema(s.name),
-      };
+      return { service: s, schema: await getSchema(s.name) };
     }),
   );
   if (existingServicesAndSchemas.length) {
diff --git a/src/init/features/emulators.ts b/src/init/features/emulators.ts
index 768d86a0288..f7ba12f12d2 100644
--- a/src/init/features/emulators.ts
+++ b/src/init/features/emulators.ts
@@ -81,13 +81,10 @@ export async function doSetup(setup: Setup, config: Config) {
       });
 
       if (ui.enabled) {
-        ui.port = await number(
-          `Which port do you want to use for the ${clc.underline(uiDesc)} (leave empty to use any available port)?`,
-        );
-
-        // Parse the input as a number
-        const portNum = Number.parseInt(ui.port as any);
-        ui.port = isNaN(portNum) ? undefined : portNum;
+        ui.port = await number({
+          message: `Which port do you want to use for the ${clc.underline(uiDesc)} (leave empty to use any available port)?`,
+          required: false,
+        });
       }
     }
 
diff --git a/src/init/features/firestore.spec.ts b/src/init/features/firestore.spec.ts
index 28b8de116f9..87c2f05fb65 100644
--- a/src/init/features/firestore.spec.ts
+++ b/src/init/features/firestore.spec.ts
@@ -1,5 +1,4 @@
 import { expect } from "chai";
-import * as _ from "lodash";
 import * as sinon from "sinon";
 
 import { FirebaseError } from "../../error";
@@ -9,12 +8,21 @@ import * as rules from "./firestore/rules";
 import * as requirePermissions from "../../requirePermissions";
 import * as apiEnabled from "../../ensureApiEnabled";
 import * as checkDatabaseType from "../../firestore/checkDatabaseType";
+import { Config } from "../../config";
 
 describe("firestore", () => {
   const sandbox: sinon.SinonSandbox = sinon.createSandbox();
   let checkApiStub: sinon.SinonStub;
   let checkDbTypeStub: sinon.SinonStub;
 
+  const setup = {
+    config: {},
+    rcfile: { projects: {}, targets: {}, etags: {} },
+    projectId: "my-project-123",
+    projectLocation: "us-central1",
+  };
+  const config = new Config({}, {});
+
   beforeEach(() => {
     checkApiStub = sandbox.stub(apiEnabled, "check");
     checkDbTypeStub = sandbox.stub(checkDatabaseType, "checkDatabaseType");
@@ -36,22 +44,17 @@ describe("firestore", () => {
       const initIndexesStub = sandbox.stub(indexes, "initIndexes").resolves();
       const initRulesStub = sandbox.stub(rules, "initRules").resolves();
 
-      const setup = { config: {}, projectId: "my-project-123", projectLocation: "us-central1" };
-
-      await firestore.doSetup(setup, {}, {});
+      await firestore.askQuestions(setup, config, {});
 
       expect(requirePermissionsStub).to.have.been.calledOnce;
       expect(initRulesStub).to.have.been.calledOnce;
       expect(initIndexesStub).to.have.been.calledOnce;
-      expect(_.get(setup, "config.firestore")).to.deep.equal({});
     });
 
     it("should error when the firestore API is not enabled", async () => {
       checkApiStub.returns(false);
 
-      const setup = { config: {}, projectId: "my-project-123" };
-
-      await expect(firestore.doSetup(setup, {}, {})).to.eventually.be.rejectedWith(
+      await expect(firestore.askQuestions(setup, config, {})).to.eventually.be.rejectedWith(
         FirebaseError,
         "It looks like you haven't used Cloud Firestore",
       );
@@ -61,9 +64,7 @@ describe("firestore", () => {
       checkApiStub.returns(true);
       checkDbTypeStub.returns("CLOUD_DATASTORE_COMPATIBILITY");
 
-      const setup = { config: {}, projectId: "my-project-123" };
-
-      await expect(firestore.doSetup(setup, {}, {})).to.eventually.be.rejectedWith(
+      await expect(firestore.askQuestions(setup, config, {})).to.eventually.be.rejectedWith(
         FirebaseError,
         "It looks like this project is using Cloud Datastore or Cloud Firestore in Datastore mode.",
       );
diff --git a/src/init/features/firestore/index.ts b/src/init/features/firestore/index.ts
index a7e59021644..b5ecd4bd520 100644
--- a/src/init/features/firestore/index.ts
+++ b/src/init/features/firestore/index.ts
@@ -8,8 +8,21 @@ import { FirebaseError } from "../../../error";
 
 import * as clc from "colorette";
 import { input } from "../../../prompt";
+import { Config } from "../../../config";
+import { Setup } from "../..";
 
-async function checkProjectSetup(setup: any, config: any, options: any) {
+export interface RequiredInfo {
+  databaseId: string;
+  rulesFilename: string;
+  rules: string;
+  writeRules: boolean;
+  indexesFilename: string;
+  indexes: string;
+  writeIndexes: boolean;
+}
+
+/** Returns the Firestore databaseId. */
+async function checkProjectSetup(setup: Setup, options: any, info: RequiredInfo): Promise<void> {
   const firestoreUnusedError = new FirebaseError(
     `It looks like you haven't used Cloud Firestore in this project before. Go to ${clc.bold(
       clc.underline(`https://console.firebase.google.com/project/${setup.projectId}/firestore`),
@@ -20,7 +33,7 @@ async function checkProjectSetup(setup: any, config: any, options: any) {
   // First check if the Firestore API is enabled. If it's not, then the developer needs
   // to go set up Firestore in the console.
   const isFirestoreEnabled = await apiEnabled.check(
-    setup.projectId,
+    setup.projectId!,
     "firestore.googleapis.com",
     "",
     true,
@@ -32,12 +45,14 @@ async function checkProjectSetup(setup: any, config: any, options: any) {
   // Next, use the AppEngine Apps API to check the database type.
   // This allows us to filter out projects that are not using Firestore in Native mode.
   // Will also prompt user for databaseId if default does not exist.
-  const dbType = await getDatabaseType(setup);
-  logger.debug(`database_type: ${dbType}`);
-
-  if (!dbType) {
-    throw firestoreUnusedError;
-  } else if (dbType !== "FIRESTORE_NATIVE") {
+  info.databaseId = info.databaseId || "(default)";
+  let dbType = await checkDatabaseType(setup.projectId!, info.databaseId);
+  if (dbType === "DATABASE_DOES_NOT_EXIST") {
+    info.databaseId = await selectDatabaseByPrompting();
+    dbType = await checkDatabaseType(setup.projectId!, info.databaseId);
+  }
+  if (dbType !== "FIRESTORE_NATIVE") {
+    logger.debug(`firestore database_type: ${dbType}`);
     throw new FirebaseError(
       `It looks like this project is using Cloud Datastore or Cloud Firestore in Datastore mode. The Firebase CLI can only manage projects using Cloud Firestore in Native mode. For more information, visit https://cloud.google.com/datastore/docs/firestore-or-datastore`,
       { exit: 1 },
@@ -47,32 +62,60 @@ async function checkProjectSetup(setup: any, config: any, options: any) {
   await requirePermissions({ ...options, project: setup.projectId });
 }
 
-/**
- * Potentially recursive function that will allow a user to input the name of their database if the
- * (default) does not exist. Modifies the setup object to include the databaseId, for use later by
- * the indexes.initIndexes() which has methods for non-default databaseId's.
- */
-async function getDatabaseType(setup: any): Promise<string | undefined> {
-  const dbType = await checkDatabaseType(setup.projectId, setup.databaseId);
-  logger.debug(`database_type: ${dbType}`);
-  if (dbType === "DATABASE_DOES_NOT_EXIST") {
-    setup.databaseId = await selectDatabaseByPrompting();
-    return await getDatabaseType(setup);
-  } else {
-    return dbType;
-  }
-}
-
 function selectDatabaseByPrompting(): Promise<string> {
   return input("Please input the name of the Native Firestore database you would like to use:");
 }
 
-export async function doSetup(setup: any, config: any, options: any): Promise<void> {
+// Kept around for unit tests.
+export async function doSetup(setup: Setup, config: Config, options: any): Promise<void> {
+  await askQuestions(setup, config, options);
+  await actuate(setup, config);
+}
+
+export async function askQuestions(setup: Setup, config: Config, options: any): Promise<void> {
+  const firestore = !Array.isArray(setup.config.firestore) ? setup.config.firestore : undefined;
+  const info: RequiredInfo = {
+    databaseId: firestore?.database || "",
+    rulesFilename: firestore?.rules || "",
+    rules: "",
+    writeRules: true,
+    indexesFilename: firestore?.indexes || "",
+    indexes: "",
+    writeIndexes: true,
+  };
   if (setup.projectId) {
-    await checkProjectSetup(setup, config, options);
+    await checkProjectSetup(setup, options, info);
   }
 
-  setup.config.firestore = {};
-  await rules.initRules(setup, config);
-  await indexes.initIndexes(setup, config);
+  await rules.initRules(setup, config, info);
+  await indexes.initIndexes(setup, config, info);
+
+  // Populate featureInfo for the actuate step later.
+  setup.featureInfo = setup.featureInfo || {};
+  setup.featureInfo.firestore = info;
+}
+
+export async function actuate(setup: Setup, config: Config): Promise<void> {
+  const info = setup.featureInfo?.firestore;
+  if (!info) {
+    throw new FirebaseError("Firestore featureInfo is not found");
+  }
+  // Populate defaults and update `firebase.json` config.
+  info.databaseId = info.databaseId || "(default)";
+  info.rules = info.rules || rules.getDefaultRules();
+  info.rulesFilename = info.rulesFilename || rules.DEFAULT_RULES_FILE;
+  info.indexes = info.indexes || indexes.INDEXES_TEMPLATE;
+  info.indexesFilename = info.indexesFilename || indexes.DEFAULT_INDEXES_FILE;
+  setup.config.firestore = {
+    database: info.databaseId,
+    rules: info.rulesFilename,
+    indexes: info.indexesFilename,
+  };
+
+  if (info.writeRules) {
+    config.writeProjectFile(info.rulesFilename, info.rules);
+  }
+  if (info.writeIndexes) {
+    config.writeProjectFile(info.indexesFilename, info.indexes);
+  }
 }
diff --git a/src/init/features/firestore/indexes.ts b/src/init/features/firestore/indexes.ts
index affba267eac..72abd1db4bb 100644
--- a/src/init/features/firestore/indexes.ts
+++ b/src/init/features/firestore/indexes.ts
@@ -2,16 +2,20 @@ import * as clc from "colorette";
 
 import { FirebaseError } from "../../../error";
 import * as api from "../../../firestore/api";
-import * as fsutils from "../../../fsutils";
-import { confirm, input } from "../../../prompt";
+import { input } from "../../../prompt";
+import * as utils from "../../../utils";
 import { logger } from "../../../logger";
 import { readTemplateSync } from "../../../templates";
+import { RequiredInfo } from ".";
+import { Setup } from "../..";
+import { Config } from "../../../config";
 
 const indexes = new api.FirestoreApi();
 
-const INDEXES_TEMPLATE = readTemplateSync("init/firestore/firestore.indexes.json");
+export const DEFAULT_INDEXES_FILE = "firestore.indexes.json";
+export const INDEXES_TEMPLATE = readTemplateSync("init/firestore/firestore.indexes.json");
 
-export async function initIndexes(setup: any, config: any): Promise<any> {
+export async function initIndexes(setup: Setup, config: Config, info: RequiredInfo): Promise<any> {
   logger.info();
   logger.info("Firestore indexes allow you to perform complex queries while");
   logger.info("maintaining performance that scales with the size of the result");
@@ -19,49 +23,42 @@ export async function initIndexes(setup: any, config: any): Promise<any> {
   logger.info("and publish them with " + clc.bold("firebase deploy") + ".");
   logger.info();
 
-  const filename =
-    setup.config.firestore.indexes ||
+  info.indexesFilename =
+    info.indexesFilename ||
     (await input({
       message: "What file should be used for Firestore indexes?",
-      default: "firestore.indexes.json",
+      default: DEFAULT_INDEXES_FILE,
     }));
-  setup.config.firestore.indexes = filename;
 
-  if (fsutils.fileExistsSync(filename)) {
-    const msg =
-      "File " +
-      clc.bold(filename) +
-      " already exists." +
-      " Do you want to overwrite it with the Firestore Indexes from the Firebase Console?";
-    if (!(await confirm(msg))) {
-      return;
+  info.indexes = INDEXES_TEMPLATE;
+  if (setup.projectId) {
+    const downloadIndexes = await getIndexesFromConsole(setup.projectId, info.databaseId);
+    if (downloadIndexes) {
+      info.indexes = downloadIndexes;
+      utils.logBullet(`Downloaded the existing Firestore indexes from the Firebase console`);
     }
   }
 
-  if (!setup.projectId) {
-    return config.writeProjectFile(setup.config.firestore.indexes, INDEXES_TEMPLATE);
-  }
-
-  return getIndexesFromConsole(setup.projectId, setup.databaseId).then((contents: any) => {
-    return config.writeProjectFile(setup.config.firestore.indexes, contents);
-  });
+  info.writeRules = await config.confirmWriteProjectFile(info.indexesFilename, info.indexes);
 }
 
-function getIndexesFromConsole(projectId: any, databaseId: any): Promise<any> {
+async function getIndexesFromConsole(
+  projectId: string,
+  databaseId: string,
+): Promise<string | null> {
   const indexesPromise = indexes.listIndexes(projectId, databaseId);
   const fieldOverridesPromise = indexes.listFieldOverrides(projectId, databaseId);
 
-  return Promise.all([indexesPromise, fieldOverridesPromise])
-    .then((res) => {
-      return indexes.makeIndexSpec(res[0], res[1]);
-    })
-    .catch((e) => {
-      if (e.message.indexOf("is not a Cloud Firestore enabled project") >= 0) {
-        return INDEXES_TEMPLATE;
-      }
+  try {
+    const res = await Promise.all([indexesPromise, fieldOverridesPromise]);
+    return JSON.stringify(indexes.makeIndexSpec(res[0], res[1]), null, 2);
+  } catch (e: any) {
+    if (e.message.indexOf("is not a Cloud Firestore enabled project") >= 0) {
+      return null;
+    }
 
-      throw new FirebaseError("Error fetching Firestore indexes", {
-        original: e,
-      });
+    throw new FirebaseError("Error fetching Firestore indexes", {
+      original: e,
     });
+  }
 }
diff --git a/src/init/features/firestore/rules.ts b/src/init/features/firestore/rules.ts
index d003387fa73..87041d415ad 100644
--- a/src/init/features/firestore/rules.ts
+++ b/src/init/features/firestore/rules.ts
@@ -1,81 +1,67 @@
 import * as clc from "colorette";
 
 import * as gcp from "../../../gcp";
-import * as fsutils from "../../../fsutils";
-import { confirm, input } from "../../../prompt";
+import { input } from "../../../prompt";
 import { logger } from "../../../logger";
 import * as utils from "../../../utils";
 import { readTemplateSync } from "../../../templates";
+import { RequiredInfo } from "./index";
+import { Setup } from "../..";
+import { Config } from "../../../config";
 
-const DEFAULT_RULES_FILE = "firestore.rules";
+export const DEFAULT_RULES_FILE = "firestore.rules";
 
 const RULES_TEMPLATE = readTemplateSync("init/firestore/firestore.rules");
 
-export async function initRules(setup: any, config: any): Promise<any> {
+export function getDefaultRules(): string {
+  const date = utils.thirtyDaysFromNow();
+  const formattedForRules = `${date.getFullYear()}, ${date.getMonth() + 1}, ${date.getDate()}`;
+  return RULES_TEMPLATE.replace(/{{IN_30_DAYS}}/g, formattedForRules);
+}
+
+export async function initRules(setup: Setup, config: Config, info: RequiredInfo): Promise<any> {
   logger.info();
   logger.info("Firestore Security Rules allow you to define how and when to allow");
   logger.info("requests. You can keep these rules in your project directory");
   logger.info("and publish them with " + clc.bold("firebase deploy") + ".");
   logger.info();
 
-  const filename =
-    setup.config.firestore.rules ||
+  info.rulesFilename =
+    info.rulesFilename ||
     (await input({
       message: "What file should be used for Firestore Rules?",
       default: DEFAULT_RULES_FILE,
     }));
-  setup.config.firestore.rules = filename;
 
-  if (fsutils.fileExistsSync(filename)) {
-    const msg =
-      "File " +
-      clc.bold(filename) +
-      " already exists." +
-      " Do you want to overwrite it with the Firestore Rules from the Firebase Console?";
-    if (!(await confirm(msg))) {
-      return;
+  info.rules = getDefaultRules();
+  if (setup.projectId) {
+    const downloadedRules = await getRulesFromConsole(setup.projectId);
+    if (downloadedRules) {
+      info.rules = downloadedRules;
+      utils.logBullet(`Downloaded the existing Firestore Security Rules from the Firebase console`);
     }
   }
 
-  if (!setup.projectId) {
-    return config.writeProjectFile(setup.config.firestore.rules, getDefaultRules());
-  }
-
-  return getRulesFromConsole(setup.projectId).then((contents: any) => {
-    return config.writeProjectFile(setup.config.firestore.rules, contents);
-  });
+  info.writeRules = await config.confirmWriteProjectFile(info.rulesFilename, info.rules);
 }
 
-function getDefaultRules(): string {
-  const date = utils.thirtyDaysFromNow();
-  const formattedForRules = `${date.getFullYear()}, ${date.getMonth() + 1}, ${date.getDate()}`;
-  return RULES_TEMPLATE.replace(/{{IN_30_DAYS}}/g, formattedForRules);
-}
-
-function getRulesFromConsole(projectId: string): Promise<any> {
-  return gcp.rules
-    .getLatestRulesetName(projectId, "cloud.firestore")
-    .then((name) => {
-      if (!name) {
-        logger.debug("No rulesets found, using default.");
-        return [{ name: DEFAULT_RULES_FILE, content: getDefaultRules() }];
-      }
+async function getRulesFromConsole(projectId: string): Promise<string | null> {
+  const name = await gcp.rules.getLatestRulesetName(projectId, "cloud.firestore");
+  if (!name) {
+    return null;
+  }
 
-      logger.debug("Found ruleset: " + name);
-      return gcp.rules.getRulesetContent(name);
-    })
-    .then((rules: any[]) => {
-      if (rules.length <= 0) {
-        return utils.reject("Ruleset has no files", { exit: 1 });
-      }
+  const rules = await gcp.rules.getRulesetContent(name);
+  if (rules.length <= 0) {
+    return utils.reject("Ruleset has no files", { exit: 1 });
+  }
 
-      if (rules.length > 1) {
-        return utils.reject("Ruleset has too many files: " + rules.length, { exit: 1 });
-      }
+  if (rules.length > 1) {
+    return utils.reject("Ruleset has too many files: " + rules.length, { exit: 1 });
+  }
 
-      // Even though the rules API allows for multi-file rulesets, right
-      // now both the console and the CLI are built on the single-file
-      // assumption.
-      return rules[0].content;
-    });
+  // Even though the rules API allows for multi-file rulesets, right
+  // now both the console and the CLI are built on the single-file
+  // assumption.
+  return rules[0].content;
 }
diff --git a/src/init/features/functions/index.ts b/src/init/features/functions/index.ts
index c5aaf097271..aba207cb0ec 100644
--- a/src/init/features/functions/index.ts
+++ b/src/init/features/functions/index.ts
@@ -14,6 +14,7 @@ import {
 } from "../../../functions/projectConfig";
 import { FirebaseError } from "../../../error";
 import { functionsOrigin, runtimeconfigOrigin } from "../../../api";
+import * as supported from "../../../deploy/functions/runtimes/supported";
 
 const MAX_ATTEMPTS = 5;
 
@@ -198,6 +199,9 @@ async function languageSetup(setup: any, config: Config): Promise<any> {
       break;
     case "python":
       cbconfig.ignore = ["venv", ".git", "firebase-debug.log", "firebase-debug.*.log", "*.local"];
+      // In practical sense, latest supported runtime will not be a decomissioned runtime,
+      // but in theory this doesn't have to be the case.
+      cbconfig.runtime = supported.latest("python") as supported.ActiveRuntime;
       break;
   }
   setup.functions.languageChoice = language;
diff --git a/src/init/features/functions/javascript.ts b/src/init/features/functions/javascript.ts
index 0636818ce19..1664991bd4c 100644
--- a/src/init/features/functions/javascript.ts
+++ b/src/init/features/functions/javascript.ts
@@ -2,6 +2,7 @@ import { askInstallDependencies } from "./npm-dependencies";
 import { confirm } from "../../../prompt";
 import { configForCodebase } from "../../../functions/projectConfig";
 import { readTemplateSync } from "../../../templates";
+import * as supported from "../../../deploy/functions/runtimes/supported";
 
 const INDEX_TEMPLATE = readTemplateSync("init/functions/javascript/index.js");
 const PACKAGE_LINTING_TEMPLATE = readTemplateSync("init/functions/javascript/package.lint.json");
@@ -20,13 +21,19 @@ export async function setup(setup: any, config: any): Promise<any> {
     cbconfig.predeploy = ['npm --prefix "$RESOURCE_DIR" run lint'];
     await config.askWriteProjectFile(
       `${setup.functions.source}/package.json`,
-      PACKAGE_LINTING_TEMPLATE,
+      PACKAGE_LINTING_TEMPLATE.replace(
+        "{{RUNTIME}}",
+        supported.latest("nodejs").replace("nodejs", ""),
+      ),
     );
     await config.askWriteProjectFile(`${setup.functions.source}/.eslintrc.js`, ESLINT_TEMPLATE);
   } else {
     await config.askWriteProjectFile(
       `${setup.functions.source}/package.json`,
-      PACKAGE_NO_LINTING_TEMPLATE,
+      PACKAGE_NO_LINTING_TEMPLATE.replace(
+        "{{RUNTIME}}",
+        supported.latest("nodejs").replace("nodejs", ""),
+      ),
     );
   }
 
diff --git a/src/init/features/functions/typescript.ts b/src/init/features/functions/typescript.ts
index eba44601d6c..8c021c9a821 100644
--- a/src/init/features/functions/typescript.ts
+++ b/src/init/features/functions/typescript.ts
@@ -2,6 +2,7 @@ import { askInstallDependencies } from "./npm-dependencies";
 import { confirm } from "../../../prompt";
 import { configForCodebase } from "../../../functions/projectConfig";
 import { readTemplateSync } from "../../../templates";
+import * as supported from "../../../deploy/functions/runtimes/supported";
 
 const PACKAGE_LINTING_TEMPLATE = readTemplateSync("init/functions/typescript/package.lint.json");
 const PACKAGE_NO_LINTING_TEMPLATE = readTemplateSync(
@@ -28,7 +29,10 @@ export async function setup(setup: any, config: any): Promise<any> {
     cbconfig.predeploy.push('npm --prefix "$RESOURCE_DIR" run build');
     await config.askWriteProjectFile(
       `${setup.functions.source}/package.json`,
-      PACKAGE_LINTING_TEMPLATE,
+      PACKAGE_LINTING_TEMPLATE.replace(
+        "{{RUNTIME}}",
+        supported.latest("nodejs").replace("nodejs", ""),
+      ),
     );
     await config.askWriteProjectFile(`${setup.functions.source}/.eslintrc.js`, ESLINT_TEMPLATE);
     // TODO: isn't this file out of date now?
@@ -40,7 +44,10 @@ export async function setup(setup: any, config: any): Promise<any> {
     cbconfig.predeploy.push('npm --prefix "$RESOURCE_DIR" run build');
     await config.askWriteProjectFile(
       `${setup.functions.source}/package.json`,
-      PACKAGE_NO_LINTING_TEMPLATE,
+      PACKAGE_NO_LINTING_TEMPLATE.replace(
+        "{{RUNTIME}}",
+        supported.latest("nodejs").replace("nodejs", ""),
+      ),
     );
   }
 
diff --git a/src/init/features/genkit/index.ts b/src/init/features/genkit/index.ts
index 9a2ac77d09f..46a09a1e3a0 100644
--- a/src/init/features/genkit/index.ts
+++ b/src/init/features/genkit/index.ts
@@ -382,7 +382,23 @@ export async function genkitSetup(
       default: true,
     }))
   ) {
-    generateSampleFile(modelOptions[model].plugin, plugins, projectDir, genkitInfo.templateVersion);
+    logger.info(
+      "Telemetry data can be used to monitor and gain insights into your AI features. There may be a cost associated with using this feature. See https://firebase.google.com/docs/genkit/observability/telemetry-collection.",
+    );
+    const enableTelemetry =
+      options.nonInteractive ||
+      (await confirm({
+        message: "Would like you to enable telemetry collection?",
+        default: true,
+      }));
+
+    generateSampleFile(
+      modelOptions[model].plugin,
+      plugins,
+      projectDir,
+      genkitInfo.templateVersion,
+      enableTelemetry,
+    );
   }
 }
 
@@ -507,6 +523,7 @@ function generateSampleFile(
   configPlugins: string[],
   projectDir: string,
   templateVersion: string,
+  enableTelemetry: boolean,
 ): void {
   let modelImport = "";
   if (modelPlugin && pluginToInfo[modelPlugin].model) {
@@ -534,6 +551,7 @@ function generateSampleFile(
           ? pluginToInfo[modelPlugin].model || pluginToInfo[modelPlugin].modelStr || ""
           : "'' /* TODO: Set a model. */",
       ),
+    enableTelemetry,
   );
   logLabeledBullet("genkit", "Generating sample file");
   try {
@@ -622,7 +640,7 @@ async function updatePackageJson(nonInteractive: boolean, projectDir: string): P
   }
 }
 
-function renderConfig(pluginNames: string[], template: string): string {
+function renderConfig(pluginNames: string[], template: string, enableTelemetry: boolean): string {
   const imports = pluginNames
     .map((pluginName) => generateImportStatement(pluginToInfo[pluginName].imports, pluginName))
     .join("\n");
@@ -631,7 +649,8 @@ function renderConfig(pluginNames: string[], template: string): string {
     "    /* Add your plugins here. */";
   return template
     .replace("$GENKIT_CONFIG_IMPORTS", imports)
-    .replace("$GENKIT_CONFIG_PLUGINS", plugins);
+    .replace("$GENKIT_CONFIG_PLUGINS", plugins)
+    .replaceAll("$TELEMETRY_COMMENT", enableTelemetry ? "" : "// ");
 }
 
 function generateImportStatement(imports: string, name: string): string {
diff --git a/src/init/features/hosting/index.ts b/src/init/features/hosting/index.ts
index 86bcdc9afa6..b3fc0568e05 100644
--- a/src/init/features/hosting/index.ts
+++ b/src/init/features/hosting/index.ts
@@ -66,7 +66,7 @@ export async function doSetup(setup: any, config: any, options: Options): Promis
   if (experiments.isEnabled("webframeworks")) {
     if (discoveredFramework) {
       const name = WebFrameworks[discoveredFramework.framework].name;
-      setup.hosting.useDiscoveredFramework = await confirm({
+      setup.hosting.useDiscoveredFramework ??= await confirm({
         message: `Detected an existing ${name} codebase in the current directory, should we use this?`,
         default: true,
       });
@@ -82,7 +82,7 @@ export async function doSetup(setup: any, config: any, options: Options): Promis
   }
 
   if (setup.hosting.useWebFrameworks) {
-    setup.hosting.source = await input({
+    setup.hosting.source ??= await input({
       message: "What folder would you like to use for your web application's root directory?",
       default: "hosting",
     });
@@ -92,7 +92,7 @@ export async function doSetup(setup: any, config: any, options: Options): Promis
 
     if (discoveredFramework) {
       const name = WebFrameworks[discoveredFramework.framework].name;
-      setup.hosting.useDiscoveredFramework = await confirm({
+      setup.hosting.useDiscoveredFramework ??= await confirm({
         message: `Detected an existing ${name} codebase in ${setup.hosting.source}, should we use this?`,
         default: true,
       });
diff --git a/src/init/features/index.ts b/src/init/features/index.ts
index c41ba3794bd..60342f036b5 100644
--- a/src/init/features/index.ts
+++ b/src/init/features/index.ts
@@ -1,6 +1,14 @@
 export { doSetup as account } from "./account";
-export { doSetup as database } from "./database";
-export { doSetup as firestore } from "./firestore";
+export {
+  askQuestions as databaseAskQuestions,
+  RequiredInfo as DatabaseInfo,
+  actuate as databaseActuate,
+} from "./database";
+export {
+  askQuestions as firestoreAskQuestions,
+  RequiredInfo as FirestoreInfo,
+  actuate as firestoreActuate,
+} from "./firestore";
 export { doSetup as functions } from "./functions";
 export { doSetup as hosting } from "./hosting";
 export { doSetup as storage } from "./storage";
diff --git a/src/init/index.ts b/src/init/index.ts
index 29bff68ea87..0f73c5b81a3 100644
--- a/src/init/index.ts
+++ b/src/init/index.ts
@@ -26,11 +26,14 @@ export interface Setup {
 }
 
 export interface SetupInfo {
+  database?: features.DatabaseInfo;
+  firestore?: features.FirestoreInfo;
   dataconnect?: features.DataconnectInfo;
 }
 
 interface Feature {
   name: string;
+  displayName?: string;
   // OLD WAY: A single setup function to ask questions and actuate the setup.
   doSetup?: (setup: Setup, config: Config, options: Options) => Promise<unknown>;
 
@@ -45,8 +48,16 @@ interface Feature {
 
 const featuresList: Feature[] = [
   { name: "account", doSetup: features.account },
-  { name: "database", doSetup: features.database },
-  { name: "firestore", doSetup: features.firestore },
+  {
+    name: "database",
+    askQuestions: features.databaseAskQuestions,
+    actuate: features.databaseActuate,
+  },
+  {
+    name: "firestore",
+    askQuestions: features.firestoreAskQuestions,
+    actuate: features.firestoreActuate,
+  },
   {
     name: "dataconnect",
     // doSetup is split into 2 phases - ask questions and then actuate files and API calls based on those answers.
@@ -64,12 +75,12 @@ const featuresList: Feature[] = [
   { name: "remoteconfig", doSetup: features.remoteconfig },
   { name: "hosting:github", doSetup: features.hostingGithub },
   { name: "genkit", doSetup: features.genkit },
-  { name: "apphosting", doSetup: features.apphosting },
+  { name: "apphosting", displayName: "App Hosting", doSetup: features.apphosting },
 ];
 
 const featureMap = new Map(featuresList.map((feature) => [feature.name, feature]));
 
-export async function init(setup: Setup, config: any, options: any): Promise<any> {
+export async function init(setup: Setup, config: Config, options: any): Promise<any> {
   const nextFeature = setup.features?.shift();
   if (nextFeature) {
     const f = featureMap.get(nextFeature);
@@ -82,7 +93,9 @@ export async function init(setup: Setup, config: any, options: any): Promise<any
       );
     }
 
-    logger.info(clc.bold(`\n${clc.white("===")} ${capitalize(nextFeature)} Setup`));
+    logger.info(
+      clc.bold(`\n${clc.white("===")} ${f.displayName || capitalize(nextFeature)} Setup`),
+    );
 
     if (f.doSetup) {
       await f.doSetup(setup, config, options);
@@ -100,3 +113,35 @@ export async function init(setup: Setup, config: any, options: any): Promise<any
     return init(setup, config, options);
   }
 }
+
+export async function actuate(setup: Setup, config: Config, options: any): Promise<any> {
+  const nextFeature = setup.features?.shift();
+  if (nextFeature) {
+    const f = lookupFeature(nextFeature);
+    logger.info(clc.bold(`\n${clc.white("===")} ${capitalize(nextFeature)} Setup Actuation`));
+
+    if (f.doSetup) {
+      throw new FirebaseError(
+        `The feature ${nextFeature} does not support actuate yet. Please run ${clc.bold("firebase init " + nextFeature)} instead.`,
+      );
+    } else {
+      if (f.actuate) {
+        await f.actuate(setup, config, options);
+      }
+    }
+    return actuate(setup, config, options);
+  }
+}
+
+function lookupFeature(feature: string): Feature {
+  const f = featureMap.get(feature);
+  if (!f) {
+    const availableFeatures = Object.keys(features)
+      .filter((f) => f !== "project")
+      .join(", ");
+    throw new FirebaseError(
+      `${clc.bold(feature)} is not a valid feature. Must be one of ${availableFeatures}`,
+    );
+  }
+  return f;
+}
diff --git a/src/init/spawn.ts b/src/init/spawn.ts
index 4d510849474..55c32e8e842 100644
--- a/src/init/spawn.ts
+++ b/src/init/spawn.ts
@@ -87,7 +87,7 @@ export function spawnWithOutput(cmd: string, args: string[]): Promise<string> {
 export function spawnWithCommandString(
   cmd: string,
   projectDir: string,
-  environmentVariables?: Record<string, string>,
+  environmentVariables?: NodeJS.ProcessEnv,
 ): Promise<void> {
   return new Promise<void>((resolve, reject) => {
     const installer = spawn(cmd, {
diff --git a/src/management/projects.ts b/src/management/projects.ts
index bb20be18d74..f6fe8069cd7 100644
--- a/src/management/projects.ts
+++ b/src/management/projects.ts
@@ -26,6 +26,9 @@ export interface ProjectParentResource {
   type: ProjectParentResourceType;
 }
 
+/**
+ * Prompt user to create a new project
+ */
 export async function promptProjectCreation(): Promise<{ projectId: string; displayName: string }> {
   const projectId = await prompt.input({
     message:
@@ -70,6 +73,9 @@ const resourceManagerClient = new Client({
   apiVersion: "v1",
 });
 
+/**
+ * Create a new Google Cloud Platform project and add Firebase resources to it
+ */
 export async function createFirebaseProjectAndLog(
   projectId: string,
   options: { displayName?: string; parentResource?: ProjectParentResource },
@@ -87,6 +93,9 @@ export async function createFirebaseProjectAndLog(
   return addFirebaseToCloudProjectAndLog(projectId);
 }
 
+/**
+ * Add Firebase resources to a Google Cloud Platform project
+ */
 export async function addFirebaseToCloudProjectAndLog(
   projectId: string,
 ): Promise<FirebaseProjectMetadata> {
@@ -473,3 +482,36 @@ export async function getProject(projectId: string): Promise<ProjectInfo> {
   const response = await resourceManagerClient.get<ProjectInfo>(`/projects/${projectId}`);
   return response.body;
 }
+
+/**
+ * Checks if Firebase services are enabled for a Google Cloud Platform project.
+ * @param projectId The project ID to check
+ * @return A promise that resolves to the Firebase project metadata if enabled, undefined otherwise
+ */
+export async function checkFirebaseEnabledForCloudProject(
+  projectId: string,
+): Promise<FirebaseProjectMetadata | undefined> {
+  try {
+    const res = await firebaseAPIClient.request<void, FirebaseProjectMetadata>({
+      method: "GET",
+      path: `/projects/${projectId}`,
+      timeout: TIMEOUT_MILLIS,
+    });
+    return res.body;
+  } catch (err: any) {
+    if (getErrStatus(err) === 404) {
+      // 404 means Firebase is not enabled for this project
+      return undefined;
+    }
+    let message = err.message;
+    if (err.original) {
+      message += ` (original: ${err.original.message})`;
+    }
+    logger.debug(message);
+    throw new FirebaseError(
+      `Failed to check if Firebase is enabled for project ${projectId}. ` +
+        "Please make sure the project exists and your account has permission to access it.",
+      { exit: 2, original: err },
+    );
+  }
+}
diff --git a/src/mcp/README.md b/src/mcp/README.md
index 77e1e1251ea..680e63450f0 100644
--- a/src/mcp/README.md
+++ b/src/mcp/README.md
@@ -1,57 +1,81 @@
 # Firebase MCP Server
 
-The Firebase MCP Server provides assistive utilities to compatible AI-assistant
-development tools.
+> [!NOTE]  
+> The Firebase MCP Server is considered **experimental** and subject to breaking changes in _minor_ version updates of the Firebase CLI.
+
+The Firebase MCP Server provides tools to interact with Firebase project resources in compatible AI-assisted development environments.
 
 ## Usage
 
-The Firebase MCP server uses the Firebase CLI for authentication and project
-selection. You will usually want to start the server with a specific directory
-as an argument to operate against the project of your working directory.
+The Firebase MCP server uses the Firebase CLI for authentication and project selection. You will usually want to start the server with a specific target directory as an argument to serve as the "project folder" where your `firebase.json` is or will be.
 
-For clients that don't operate within a specific workspace, the Firebase MCP
-server makes tools available to read and write a project directory.
+For global clients that don't operate within a specific workspace, the Firebase MCP Server makes tools available to read and write a project directory.
 
-### Example: Cursor
+### Client Configuration
 
-In `.cursor/mcp.json` in your workspace directory, add the Firebase MCP server:
+If you are using an MCP client that is configured with a JSON, the following example configuration should help you get started:
 
 ```json
 {
   "mcpServers": {
     "firebase": {
       "command": "npx",
-      "args": ["-y", "firebase-tools", "experimental:mcp", "--dir", "<your_absolute_workspace_dir>"]
+      "args": ["-y", "firebase-tools", "experimental:mcp", "--dir", "."]
     }
   }
 }
 ```
 
+### Authentication
+
+The Firebase MCP Server shares authentication with the Firebase CLI. If you've never used the Firebase CLI before, you'll need to login:
+
+```bash
+npx -y firebase-tools login
+```
+
 ### Command Line Options
 
-- `--dir <absolute_dir_path>`: The absolute path of a directory containing `firebase.json` to set a project context for the MCP server. If unspecified, the `{get|set}_project_directory` tools will become available and the default directory will be the working directory where the MCP server was started.
+- `--dir <absolute_dir_path>`: The absolute path of a directory containing `firebase.json` (or where you want to initialize `firebase.json`) to set a workspace context for the MCP server. If unspecified, the working directory where the server is started is used. The `{get|update}_project_environment` can be used to interactively change the project directory.
 - `--only <feature1,feature2>`: A comma-separated list of feature groups to activate. Use this to limit the tools exposed to only features you are actively using.
 
 ## Tools
 
-| Tool Name                        | Feature Group | Description                                                                                                                                                                                                    |
-| -------------------------------- | ------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `get_project_directory`          | `directory`   | When running without the `--dir` command, retrieves the current directory (defaults to current working directory).                                                                                             |
-| `set_project_directory`          | `directory`   | When running without the `--dir` command, sets the current project directory (i.e. one with `firebase.json` in it).                                                                                            |
-| `firebase_get_project`           | `core`        | Get basic information about the active project in the current Firebase directory.                                                                                                                              |
-| `firebase_list_apps`             | `core`        | List registered apps for the currently active project.                                                                                                                                                         |
-| `firebase_get_sdk_config`        | `core`        | Get an Firebase client SDK config for a specific platform.                                                                                                                                                     |
-| `firebase_consult_assistant`     | `core`        | Consult Gemini in Firebase agent for help                                                                                                                                                                      |
-| `firestore_list_collections`     | `firestore`   | Retrieves a list of collections from a Firestore database in the current project.                                                                                                                              |
-| `firestore_get_documents`        | `firestore`   | Retrieves one or more Firestore documents from a database in the current project by full document paths. Use this if you know the exact path of a document.                                                    |
-| `firestore_get_rules`            | `firestore`   | Retrieves the active Firestore security rules for the current project.                                                                                                                                         |
-| `auth_get_user`                  | `auth`        | Retrieves a user based on an email address, phone number, or UID.                                                                                                                                              |
-| `auth_disable_user`              | `auth`        | Disables or enables a user based on a UID.                                                                                                                                                                     |
-| `auth_set_claims`                | `auth`        | Sets custom claims on a specific user's account. Use to create trusted values associated with a user e.g. marking them as an admin. Claims are limited in size and should be succinct in name and value.       |
-| `auth_set_sms_region_policy`     | `auth`        | Sets an SMS Region Policy for Firebase Auth to restrict the regions which can receive text messages based on an ALLOW or DENY list of country codes. This policy will override any existing policies when set. |
-| `dataconnect_list_services`      | `dataconnect` | List the Firebase Data Connect services available in the current project.                                                                                                                                      |
-| `dataconnect_generate_schema`    | `dataconnect` | Generates a Firebase Data Connect Schema based on the users description of an app.                                                                                                                             |
-| `dataconnect_generate_operation` | `dataconnect` | Generates a single Firebase Data Connect query or mutation based on the currently deployed schema and the provided prompt.                                                                                     |
-| `dataconnect_get_schema`         | `dataconnect` | List the Firebase Data Connect Schema in the project, which includes Cloud SQL data sources and the GraphQL Schema describing what tables are available.                                                       |
-| `dataconnect_get_connector`      | `dataconnect` | Get the Firebase Data Connect Connectors in the project, which includes the pre-defined GraphQL queries accessible to client SDKs.                                                                             |
-| `storage_get_rules`              | `storage`     | Retrieves the Firebase Cloud Storage Rules for the default bucket.                                                                                                                                             |
+| Tool Name                        | Feature Group | Description                                                                                                                                                                                                                                                                |
+| -------------------------------- | ------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| firebase_get_project             | core          | Retrieves information about the currently active Firebase project.                                                                                                                                                                                                         |
+| firebase_list_apps               | core          | Retrieves apps registered in the current Firebase project.                                                                                                                                                                                                                 |
+| firebase_get_admin_sdk_config    | core          | Gets the Admin SDK config for the current project.                                                                                                                                                                                                                         |
+| firebase_get_sdk_config          | core          | Retrieves the Firebase SDK configuration information for the specified platform. You must specify either a platform or an app_id.                                                                                                                                          |
+| firebase_create_project          | core          | Creates a new Firebase project.                                                                                                                                                                                                                                            |
+| firebase_create_app              | core          | Creates a new app in your Firebase project for Web, iOS, or Android.                                                                                                                                                                                                       |
+| firebase_create_android_sha      | core          | Adds a SHA certificate hash to an existing Android app.                                                                                                                                                                                                                    |
+| firebase_get_environment         | core          | Retrieves information about the current Firebase environment including current authenticated user, project directory, active project, and more.                                                                                                                            |
+| firebase_update_environment      | core          | Updates Firebase environment config such as project directory, active project, active user account, and more. Use `firebase_get_environment` to see the currently configured environment.                                                                                  |
+| firebase_init                    | core          | Initializes selected Firebase features in the workspace. All features are optional; provide only the products you wish to set up. You can initialize new features into an existing project directory, but re-initializing an existing feature may overwrite configuration. |
+| firestore_delete_document        | firestore     | Deletes a Firestore documents from a database in the current project by full document paths. Use this if you know the exact path of a document.                                                                                                                            |
+| firestore_get_documents          | firestore     | Retrieves one or more Firestore documents from a database in the current project by full document paths. Use this if you know the exact path of a document.                                                                                                                |
+| firestore_list_collections       | firestore     | Retrieves a list of collections from a Firestore database in the current project.                                                                                                                                                                                          |
+| firestore_query_collection       | firestore     | Retrieves one or more Firestore documents from a collection is a database in the current project by a collection with a full document path. Use this if you know the exact path of a collection and the filtering clause you would like for the document.                  |
+| firestore_get_rules              | firestore     | Retrieves the active Firestore security rules for the current project.                                                                                                                                                                                                     |
+| firestore_validate_rules         | firestore     | Checks the provided Firestore Rules source for syntax and validation errors. Provide EITHER the source code to validate OR a path to a source file.                                                                                                                        |
+| auth_get_user                    | auth          | Retrieves a user based on an email address, phone number, or UID.                                                                                                                                                                                                          |
+| auth_disable_user                | auth          | Disables or enables a user based on a UID.                                                                                                                                                                                                                                 |
+| auth_list_users                  | auth          | Retrieves all users in the project up to the specified limit.                                                                                                                                                                                                              |
+| auth_set_claim                   | auth          | Sets a custom claim on a specific user's account. Use to create trusted values associated with a user e.g. marking them as an admin. Claims are limited in size and should be succinct in name and value. Specify ONLY ONE OF `value` or `json_value` parameters.          |
+| auth_set_sms_region_policy       | auth          | Sets an SMS Region Policy for Firebase Auth to restrict the regions which can receive text messages based on an ALLOW or DENY list of country codes. This policy will override any existing policies when set.                                                             |
+| dataconnect_list_services        | dataconnect   | List the Firebase Data Connect services available in the current project.                                                                                                                                                                                                  |
+| dataconnect_get_schema           | dataconnect   | Retrieve information about the Firebase Data Connect Schema in the project, including Cloud SQL data sources and the GraphQL Schema describing the data model.                                                                                                             |
+| dataconnect_get_connectors       | dataconnect   | Get the Firebase Data Connect Connectors in the project, which includes the pre-defined GraphQL queries accessible to client SDKs.                                                                                                                                         |
+| dataconnect_execute_graphql      | dataconnect   | Executes an arbitrary GraphQL against a Data Connect service or its emulator.                                                                                                                                                                                              |
+| dataconnect_execute_graphql_read | dataconnect   | Executes an arbitrary GraphQL query against a Data Connect service or its emulator. Cannot write data.                                                                                                                                                                     |
+| dataconnect_execute_mutation     | dataconnect   | Executes a deployed Data Connect mutation against a service or its emulator. Can read and write data.                                                                                                                                                                      |
+| dataconnect_execute_query        | dataconnect   | Executes a deployed Data Connect query against a service or its emulator. Cannot write any data.                                                                                                                                                                           |
+| storage_get_rules                | storage       | Retrieves the active Storage security rules for the current project.                                                                                                                                                                                                       |
+| storage_validate_rules           | storage       | Checks the provided Storage Rules source for syntax and validation errors. Provide EITHER the source code to validate OR a path to a source file.                                                                                                                          |
+| storage_get_object_download_url  | storage       | Retrieves the download URL for an object in Firebase Storage.                                                                                                                                                                                                              |
+| messaging_send_message           | messaging     | Sends a message to a Firebase Cloud Messaging registration token or topic. ONLY ONE of `registration_token` or `topic` may be supplied in a specific call.                                                                                                                 |
+| remoteconfig_get_template        | remoteconfig  | Retrieves a remote config template for the project                                                                                                                                                                                                                         |
+| remoteconfig_publish_template    | remoteconfig  | Publishes a new remote config template for the project                                                                                                                                                                                                                     |
+| remoteconfig_rollback_template   | remoteconfig  | Rollback to a specific version of Remote Config template for a project                                                                                                                                                                                                     |
+| crashlytics_list_top_issues      | crashlytics   | List the top crashes from crashlytics happening in the application.                                                                                                                                                                                                        |
diff --git a/src/mcp/errors.ts b/src/mcp/errors.ts
index aaa1267e4cf..30f3788bf3a 100644
--- a/src/mcp/errors.ts
+++ b/src/mcp/errors.ts
@@ -1,7 +1,7 @@
 import { commandExistsSync, mcpError } from "./util";
 
 export const NO_PROJECT_ERROR = mcpError(
-  'No active project was found. Use the `set_firebase_directory` tool to set the project directory to an absolute folder location containing a firebase.json config file. Alternatively, change the MCP server config to add [...,"--dir","/absolute/path/to/project/directory"] in its command-line arguments.',
+  'No active project was found. Use the `firebase_update_environment` tool to set the project directory to an absolute folder location containing a firebase.json config file. Alternatively, change the MCP server config to add [...,"--dir","/absolute/path/to/project/directory"] in its command-line arguments.',
   "PRECONDITION_FAILED",
 );
 
diff --git a/src/mcp/index.ts b/src/mcp/index.ts
index 20b4b1e8bda..a61f3b5ead1 100644
--- a/src/mcp/index.ts
+++ b/src/mcp/index.ts
@@ -8,9 +8,9 @@ import {
   ListToolsResult,
 } from "@modelcontextprotocol/sdk/types.js";
 import { checkFeatureActive, mcpError } from "./util.js";
-import { SERVER_FEATURES, ServerFeature } from "./types.js";
+import { ClientConfig, SERVER_FEATURES, ServerFeature } from "./types.js";
 import { availableTools } from "./tools/index.js";
-import { ServerTool } from "./tool.js";
+import { ServerTool, ServerToolContext } from "./tool.js";
 import { configstore } from "../configstore.js";
 import { Command } from "../command.js";
 import { requireAuth } from "../requireAuth.js";
@@ -20,34 +20,82 @@ import { mcpAuthError, NO_PROJECT_ERROR } from "./errors.js";
 import { trackGA4 } from "../track.js";
 import { Config } from "../config.js";
 import { loadRC } from "../rc.js";
+import { EmulatorHubClient } from "../emulator/hubClient.js";
+import { existsSync } from "node:fs";
 
-const SERVER_VERSION = "0.0.1";
-const PROJECT_ROOT_KEY = "mcp.projectRoot";
+const SERVER_VERSION = "0.1.0";
 
 const cmd = new Command("experimental:mcp").before(requireAuth);
 
 export class FirebaseMcpServer {
-  projectRoot?: string;
+  private _ready: boolean = false;
+  private _readyPromises: { resolve: () => void; reject: (err: unknown) => void }[] = [];
+  startupRoot?: string;
+  cachedProjectRoot?: string;
   server: Server;
   activeFeatures?: ServerFeature[];
   detectedFeatures?: ServerFeature[];
-  fixedRoot?: boolean;
+  clientInfo?: { name?: string; version?: string };
+  emulatorHubClient?: EmulatorHubClient;
 
   constructor(options: { activeFeatures?: ServerFeature[]; projectRoot?: string }) {
     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 } });
     this.server.setRequestHandler(ListToolsRequestSchema, this.mcpListTools.bind(this));
     this.server.setRequestHandler(CallToolRequestSchema, this.mcpCallTool.bind(this));
-    this.projectRoot =
-      options.projectRoot ??
-      (configstore.get(PROJECT_ROOT_KEY) as string) ??
-      process.env.PROJECT_ROOT ??
-      process.cwd();
-    if (options.projectRoot) this.fixedRoot = true;
+    this.server.oninitialized = async () => {
+      const clientInfo = this.server.getClientVersion();
+      this.clientInfo = clientInfo;
+      if (clientInfo?.name) {
+        trackGA4("mcp_client_connected", {
+          mcp_client_name: clientInfo.name,
+          mcp_client_version: clientInfo.version,
+        });
+      }
+      if (!this.clientInfo?.name) this.clientInfo = { name: "<unknown-client>" };
+
+      this._ready = true;
+      while (this._readyPromises.length) {
+        this._readyPromises.pop()?.resolve();
+      }
+    };
+    this.detectProjectRoot();
     this.detectActiveFeatures();
   }
 
+  /** Wait until initialization has finished. */
+  ready() {
+    if (this._ready) return Promise.resolve();
+    return new Promise((resolve, reject) => {
+      this._readyPromises.push({ resolve: resolve as () => void, reject });
+    });
+  }
+
+  private get clientConfigKey() {
+    return `mcp.clientConfigs.${this.clientInfo?.name || "<unknown-client>"}:${this.startupRoot || process.cwd()}`;
+  }
+
+  getStoredClientConfig(): ClientConfig {
+    return configstore.get(this.clientConfigKey) || {};
+  }
+
+  updateStoredClientConfig(update: Partial<ClientConfig>) {
+    const config = configstore.get(this.clientConfigKey) || {};
+    const newConfig = { ...config, ...update };
+    configstore.set(this.clientConfigKey, newConfig);
+    return newConfig;
+  }
+
+  async detectProjectRoot(): Promise<string> {
+    await this.ready();
+    if (this.cachedProjectRoot) return this.cachedProjectRoot;
+    const storedRoot = this.getStoredClientConfig().projectRoot;
+    this.cachedProjectRoot = storedRoot || this.startupRoot || process.cwd();
+    return this.cachedProjectRoot;
+  }
+
   async detectActiveFeatures(): Promise<ServerFeature[]> {
     if (this.detectedFeatures?.length) return this.detectedFeatures; // memoized
     const options = await this.resolveOptions();
@@ -62,9 +110,21 @@ export class FirebaseMcpServer {
     return this.detectedFeatures;
   }
 
+  async getEmulatorHubClient(): Promise<EmulatorHubClient | undefined> {
+    // Single initilization
+    if (this.emulatorHubClient) {
+      return this.emulatorHubClient;
+    }
+    const projectId = await this.getProjectId();
+    if (!projectId) {
+      return;
+    }
+    this.emulatorHubClient = new EmulatorHubClient(projectId);
+    return this.emulatorHubClient;
+  }
+
   get availableTools(): ServerTool[] {
     return availableTools(
-      !!this.fixedRoot,
       this.activeFeatures?.length ? this.activeFeatures : this.detectedFeatures,
     );
   }
@@ -74,21 +134,14 @@ export class FirebaseMcpServer {
   }
 
   setProjectRoot(newRoot: string | null): void {
-    if (newRoot === null) {
-      configstore.delete(PROJECT_ROOT_KEY);
-      this.projectRoot = process.env.PROJECT_ROOT || process.cwd();
-      void this.server.sendToolListChanged();
-      return;
-    }
-
-    configstore.set(PROJECT_ROOT_KEY, newRoot);
-    this.projectRoot = newRoot;
+    this.updateStoredClientConfig({ projectRoot: newRoot });
+    this.cachedProjectRoot = newRoot || undefined;
     this.detectedFeatures = undefined; // reset detected features
     void this.server.sendToolListChanged();
   }
 
   async resolveOptions(): Promise<Partial<Options>> {
-    const options: Partial<Options> = { cwd: this.projectRoot };
+    const options: Partial<Options> = { cwd: this.cachedProjectRoot, isMCP: true };
     await cmd.prepare(options);
     return options;
   }
@@ -97,25 +150,27 @@ export class FirebaseMcpServer {
     return getProjectId(await this.resolveOptions());
   }
 
-  async getAuthenticated(): Promise<boolean> {
+  async getAuthenticatedUser(): Promise<string | null> {
     try {
-      await requireAuth(await this.resolveOptions());
-      return true;
+      return await requireAuth(await this.resolveOptions());
     } catch (e) {
-      return false;
+      return null;
     }
   }
 
   async mcpListTools(): Promise<ListToolsResult> {
-    if (!this.activeFeatures) await this.detectActiveFeatures();
+    await Promise.all([this.detectActiveFeatures(), this.detectProjectRoot()]);
     const hasActiveProject = !!(await this.getProjectId());
-    await trackGA4("mcp_list_tools", {});
+    await trackGA4("mcp_list_tools", {
+      mcp_client_name: this.clientInfo?.name,
+      mcp_client_version: this.clientInfo?.version,
+    });
     return {
       tools: this.availableTools.map((t) => t.mcp),
       _meta: {
-        projectRoot: this.projectRoot,
+        projectRoot: this.cachedProjectRoot,
         projectDetected: hasActiveProject,
-        authenticated: await this.getAuthenticated(),
+        authenticatedUser: await this.getAuthenticatedUser(),
         activeFeatures: this.activeFeatures,
         detectedFeatures: this.detectedFeatures,
       },
@@ -123,29 +178,55 @@ export class FirebaseMcpServer {
   }
 
   async mcpCallTool(request: CallToolRequest): Promise<CallToolResult> {
+    await this.detectProjectRoot();
     const toolName = request.params.name;
     const toolArgs = request.params.arguments;
     const tool = this.getTool(toolName);
     if (!tool) throw new Error(`Tool '${toolName}' could not be found.`);
 
-    const projectId = await this.getProjectId();
-    if (tool.mcp._meta?.requiresAuth && !(await this.getAuthenticated())) return mcpAuthError();
-    if (tool.mcp._meta?.requiresProject && !projectId) return NO_PROJECT_ERROR;
+    if (
+      tool.mcp.name !== "firebase_update_environment" && // allow this tool only, to fix the issue
+      (!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.`,
+      );
+    }
+    let projectId = await this.getProjectId();
+    if (tool.mcp._meta?.requiresProject && !projectId) {
+      return NO_PROJECT_ERROR;
+    }
+    projectId = projectId || "";
+
+    const accountEmail = await this.getAuthenticatedUser();
+    if (tool.mcp._meta?.requiresAuth && !accountEmail) {
+      return mcpAuthError();
+    }
 
+    const options = { projectDir: this.cachedProjectRoot, cwd: this.cachedProjectRoot };
+    const toolsCtx: ServerToolContext = {
+      projectId: projectId,
+      host: this,
+      config: Config.load(options, true) || new Config({}, options),
+      rc: loadRC(options),
+      accountEmail,
+    };
     try {
-      const cliOpts = { cwd: this.projectRoot };
-      const config = Config.load(cliOpts) as Config;
-      const rc = loadRC(cliOpts);
-      const res = await tool.fn(toolArgs, {
-        projectId: await this.getProjectId(),
-        host: this,
-        config,
-        rc,
+      const res = await tool.fn(toolArgs, toolsCtx);
+      await trackGA4("mcp_tool_call", {
+        tool_name: toolName,
+        error: res.isError ? 1 : 0,
+        mcp_client_name: this.clientInfo?.name,
+        mcp_client_version: this.clientInfo?.version,
       });
-      await trackGA4("mcp_tool_call", { tool_name: toolName, error: res.isError ? 1 : 0 });
       return res;
     } catch (err: unknown) {
-      await trackGA4("mcp_tool_call", { tool_name: toolName, error: 1 });
+      await trackGA4("mcp_tool_call", {
+        tool_name: toolName,
+        error: 1,
+        mcp_client_name: this.clientInfo?.name,
+        mcp_client_version: this.clientInfo?.version,
+      });
       return mcpError(err);
     }
   }
diff --git a/src/mcp/tool.ts b/src/mcp/tool.ts
index b19545f4c8c..0bcdf3c8e67 100644
--- a/src/mcp/tool.ts
+++ b/src/mcp/tool.ts
@@ -4,9 +4,11 @@ import { zodToJsonSchema } from "zod-to-json-schema";
 import type { FirebaseMcpServer } from "./index";
 import { Config } from "../config";
 import { RC } from "../rc";
+import { cleanSchema } from "./util";
 
 export interface ServerToolContext {
-  projectId?: string;
+  projectId: string;
+  accountEmail: string | null;
   config: Config;
   host: FirebaseMcpServer;
   rc: RC;
@@ -29,6 +31,8 @@ export interface ServerTool<InputSchema extends ZodTypeAny = ZodTypeAny> {
       requiresProject?: boolean;
       /** Set this on a tool if it *always* requires a signed-in user to work. */
       requiresAuth?: boolean;
+      /** Tools are grouped by feature. --only can configure what tools is available. */
+      feature?: string;
     };
   };
   fn: (input: z.infer<InputSchema>, ctx: ServerToolContext) => Promise<CallToolResult>;
@@ -41,7 +45,7 @@ export function tool<InputSchema extends ZodTypeAny>(
   fn: ServerTool<InputSchema>["fn"],
 ): ServerTool {
   return {
-    mcp: { ...options, inputSchema: zodToJsonSchema(options.inputSchema) },
+    mcp: { ...options, inputSchema: cleanSchema(zodToJsonSchema(options.inputSchema)) },
     fn,
   };
 }
diff --git a/src/mcp/tools/apphosting/fetch_logs.ts b/src/mcp/tools/apphosting/fetch_logs.ts
new file mode 100644
index 00000000000..3dc94099fac
--- /dev/null
+++ b/src/mcp/tools/apphosting/fetch_logs.ts
@@ -0,0 +1,79 @@
+import { z } from "zod";
+import { tool } from "../../tool.js";
+import { toContent } from "../../util.js";
+import { Backend, getBackend, getTraffic, listBuilds, Traffic } from "../../../gcp/apphosting.js";
+import { last } from "../../../utils.js";
+import { FirebaseError } from "../../../error.js";
+import { fetchServiceLogs } from "../../../gcp/run.js";
+import { listEntries } from "../../../gcp/cloudlogging.js";
+
+export const fetch_logs = tool(
+  {
+    name: "fetch_logs",
+    description:
+      "Fetches the most recent logs for a specified App Hosting backend. If `buildLogs` is specified, the logs from the build process for the latest build are returned. The most recent logs are listed first.",
+    inputSchema: z.object({
+      buildLogs: z
+        .boolean()
+        .default(false)
+        .describe(
+          "If specified, the logs for the most recent build will be returned instead of the logs for the service. The build logs are returned 'in order', to be read from top to bottom.",
+        ),
+      backendId: z.string().describe("The ID of the backend for which to fetch logs."),
+      location: z
+        .string()
+        .describe(
+          "The specific region for the backend. By default, if a backend is uniquely named across all locations, that one will be used.",
+        ),
+    }),
+    annotations: {
+      title: "Fetch logs for App Hosting backends and builds.",
+      readOnlyHint: true,
+    },
+    _meta: {
+      requiresAuth: true,
+      requiresProject: true,
+    },
+  },
+  async ({ buildLogs, backendId, location } = {}, { projectId }) => {
+    location ||= "";
+    if (!backendId) {
+      return toContent(`backendId must be specified.`);
+    }
+    const backend = await getBackend(projectId, location, backendId);
+    const traffic = await getTraffic(projectId, location, backendId);
+    const data: Backend & { traffic: Traffic } = { ...backend, traffic };
+
+    if (buildLogs) {
+      const builds = await listBuilds(projectId, location, backendId);
+      builds.builds.sort(
+        (a, b) => new Date(a.createTime).getTime() - new Date(b.createTime).getTime(),
+      );
+      const build = last(builds.builds);
+      const r = new RegExp(`region=${location}/([0-9a-f-]+)?`);
+      const match = r.exec(build.buildLogsUri ?? "");
+      if (!match) {
+        throw new FirebaseError("Unable to determine the build ID.");
+      }
+      const buildId = match[1];
+      // Thirty days ago makes sure we get any saved data within the default retention period.
+      const thirtyDaysAgo = new Date();
+      thirtyDaysAgo.setDate(thirtyDaysAgo.getDate() - 30);
+      const timestampFilter = `timestamp >= "${thirtyDaysAgo.toISOString()}"`;
+      const filter = `resource.type="build" resource.labels.build_id="${buildId}" ${timestampFilter}`;
+      const entries = await listEntries(projectId, filter, 100, "asc");
+      if (!Array.isArray(entries) || !entries.length) {
+        return toContent("No logs found.");
+      }
+      return toContent(entries);
+    }
+
+    const serviceName = last(data.managedResources)?.runService.service;
+    if (!serviceName) {
+      throw new FirebaseError("Unable to get service name from managedResources.");
+    }
+    const serviceId = last(serviceName.split("/"));
+    const logs = await fetchServiceLogs(projectId, serviceId);
+    return toContent(logs);
+  },
+);
diff --git a/src/mcp/tools/apphosting/index.ts b/src/mcp/tools/apphosting/index.ts
new file mode 100644
index 00000000000..0c9c3919894
--- /dev/null
+++ b/src/mcp/tools/apphosting/index.ts
@@ -0,0 +1,5 @@
+import { ServerTool } from "../../tool";
+import { fetch_logs } from "./fetch_logs";
+import { list_backends } from "./list_backends";
+
+export const appHostingTools: ServerTool[] = [fetch_logs, list_backends];
diff --git a/src/mcp/tools/apphosting/list_backends.ts b/src/mcp/tools/apphosting/list_backends.ts
new file mode 100644
index 00000000000..e1aa1aaf7fa
--- /dev/null
+++ b/src/mcp/tools/apphosting/list_backends.ts
@@ -0,0 +1,55 @@
+import { z } from "zod";
+import { tool } from "../../tool.js";
+import { toContent } from "../../util.js";
+import {
+  Backend,
+  getTraffic,
+  listBackends,
+  parseBackendName,
+  Traffic,
+} from "../../../gcp/apphosting.js";
+
+export const list_backends = tool(
+  {
+    name: "list_backends",
+    description:
+      "Retrieves a list of App Hosting backends in the current project. An empty list means that there are no backends. " +
+      "The `uri` is the public URL of the backend. " +
+      "A working backend will have a `managed_resources` array that will contain a `run_service` entry. That `run_service.service` " +
+      "is the resource name of the Cloud Run service serving the App Hosting backend. The last segment of that name is the service ID.",
+    inputSchema: z.object({
+      location: z
+        .string()
+        .optional()
+        .default("-")
+        .describe(
+          "Limit the listed backends to this region. By default, it will list all backends across all regions.",
+        ),
+    }),
+    annotations: {
+      title: "List App Hosting backends.",
+      readOnlyHint: true,
+    },
+    _meta: {
+      requiresAuth: true,
+      requiresProject: true,
+    },
+  },
+  async ({ location } = {}, { projectId }) => {
+    projectId = projectId || "";
+    if (!location) location = "-";
+    const data: (Backend & { traffic: Traffic })[] = [];
+    const backends = await listBackends(projectId, location);
+    for (const backend of backends.backends) {
+      const { location, id } = parseBackendName(backend.name);
+      const traffic = await getTraffic(projectId, location, id);
+      data.push({ ...backend, traffic: traffic });
+    }
+    if (!data.length) {
+      return toContent(
+        `No backends exist for project ${projectId}${location !== "-" ? ` in ${location}` : ""}.`,
+      );
+    }
+    return toContent(data);
+  },
+);
diff --git a/src/mcp/tools/auth/disable_user.ts b/src/mcp/tools/auth/disable_user.ts
index 4a68df4c6fb..fa56913f47f 100644
--- a/src/mcp/tools/auth/disable_user.ts
+++ b/src/mcp/tools/auth/disable_user.ts
@@ -22,7 +22,7 @@ export const disable_user = tool(
     },
   },
   async ({ uid, disabled }, { projectId }) => {
-    const res = await disableUser(projectId!, uid, disabled);
+    const res = await disableUser(projectId, uid, disabled);
     if (res) {
       return toContent(`User ${uid} as been ${disabled ? "disabled" : "enabled"}`);
     }
diff --git a/src/mcp/tools/auth/get_user.ts b/src/mcp/tools/auth/get_user.ts
index 8813c63d555..8c02be2729e 100644
--- a/src/mcp/tools/auth/get_user.ts
+++ b/src/mcp/tools/auth/get_user.ts
@@ -8,12 +8,25 @@ export const get_user = tool(
     name: "get_user",
     description: "Retrieves a user based on an email address, phone number, or UID.",
     inputSchema: z.object({
-      email: z.string().optional(),
-      phoneNumber: z.string().optional(),
-      uid: z.string().optional(),
+      email: z
+        .string()
+        .optional()
+        .describe(
+          "The user's email address. At least one of email, phone_number, or uid must be provided.",
+        ),
+      phone_number: z
+        .string()
+        .optional()
+        .describe(
+          "The user's phone number. At least one of email, phone_number, or uid must be provided.",
+        ),
+      uid: z
+        .string()
+        .optional()
+        .describe("The user's UID. At least one of email, phone_number, or uid must be provided."),
     }),
     annotations: {
-      title: "Get information about 1 user.",
+      title: "Get Firebase Auth User",
       readOnlyHint: true,
     },
     _meta: {
@@ -21,10 +34,10 @@ export const get_user = tool(
       requiresProject: true,
     },
   },
-  async ({ email, phoneNumber, uid }, { projectId }) => {
-    if (email === undefined && phoneNumber === undefined && uid === undefined) {
+  async ({ email, phone_number, uid }, { projectId }) => {
+    if (email === undefined && phone_number === undefined && uid === undefined) {
       return mcpError(`No user identifier supplied in auth_get_user tool`);
     }
-    return toContent(await findUser(projectId!, email, phoneNumber, uid));
+    return toContent(await findUser(projectId, email, phone_number, uid));
   },
 );
diff --git a/src/mcp/tools/auth/list_users.ts b/src/mcp/tools/auth/list_users.ts
index 9a3d43a8671..65d061dc19e 100644
--- a/src/mcp/tools/auth/list_users.ts
+++ b/src/mcp/tools/auth/list_users.ts
@@ -8,10 +8,14 @@ export const list_users = tool(
     name: "list_users",
     description: "Retrieves all users in the project up to the specified limit.",
     inputSchema: z.object({
-      limit: z.number().nullish().describe("The number of users to return - defaults to 100"),
+      limit: z
+        .number()
+        .optional()
+        .default(100)
+        .describe("The number of users to return. Defaults to 100 if not supplied."),
     }),
     annotations: {
-      title: "Get users from the Firebase project.",
+      title: "List Firebase Users",
       readOnlyHint: true,
     },
     _meta: {
@@ -19,11 +23,18 @@ export const list_users = tool(
       requiresProject: true,
     },
   },
-  async ({ limit }, { projectId }) => {
+  async ({ limit } = {}, { projectId }) => {
     if (!limit) {
       limit = 100;
     }
 
-    return toContent(await listUsers(projectId!, limit));
+    const users = await listUsers(projectId, limit);
+    const usersPruned = users.map((user) => {
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      const { passwordHash, salt, ...prunedUser } = user;
+      return prunedUser;
+    });
+
+    return toContent(usersPruned);
   },
 );
diff --git a/src/mcp/tools/auth/set_claims.ts b/src/mcp/tools/auth/set_claims.ts
index aeb234af388..dcd3c669337 100644
--- a/src/mcp/tools/auth/set_claims.ts
+++ b/src/mcp/tools/auth/set_claims.ts
@@ -5,21 +5,23 @@ import { setCustomClaim } from "../../../gcp/auth.js";
 
 export const set_claim = tool(
   {
-    name: "set_claims",
+    name: "set_claim",
     description:
-      "Sets custom claims on a specific user's account. Use to create trusted values associated with a user e.g. marking them as an admin. Claims are limited in size and should be succinct in name and value. Specify ONLY ONE OF `value` or `json_value` parameters.",
+      "Sets a custom claim on a specific user's account. Use to create trusted values associated with a user e.g. marking them as an admin. Claims are limited in size and should be succinct in name and value. Specify ONLY ONE OF `value` or `json_value` parameters.",
     inputSchema: z.object({
       uid: z.string().describe("the UID of the user to update"),
       claim: z.string().describe("the name (key) of the claim to update, e.g. 'admin'"),
       value: z
         .union([z.string(), z.number(), z.boolean()])
-        .describe("set the value of the custom claim to the specified simple scalar value")
-        .optional(),
+        .optional()
+        .describe(
+          "Set the value of the custom claim to the specified simple scalar value. One of `value` or `json_value` must be provided.",
+        ),
       json_value: z
         .string()
         .optional()
         .describe(
-          "set the claim to a complex JSON value like an object or an array by providing stringified JSON. string must be parseable as valid JSON",
+          "Set the claim to a complex JSON value like an object or an array by providing stringified JSON. String must be parseable as valid JSON. One of `value` or `json_value` must be provided.",
         ),
     }),
     annotations: {
@@ -40,6 +42,6 @@ export const set_claim = tool(
         return mcpError(`Provided \`json_value\` was not valid JSON: ${json_value}`);
       }
     }
-    return toContent(await setCustomClaim(projectId!, uid, { [claim]: value }, { merge: true }));
+    return toContent(await setCustomClaim(projectId, uid, { [claim]: value }, { merge: true }));
   },
 );
diff --git a/src/mcp/tools/auth/set_sms_region_policy.ts b/src/mcp/tools/auth/set_sms_region_policy.ts
index ca01a3ae9b6..d67e1d76739 100644
--- a/src/mcp/tools/auth/set_sms_region_policy.ts
+++ b/src/mcp/tools/auth/set_sms_region_policy.ts
@@ -19,7 +19,7 @@ export const set_sms_region_policy = tool(
         .describe("the country codes to allow or deny based on ISO 3166"),
     }),
     annotations: {
-      title: "Set the SMS Region Policy on your Firebase Project",
+      title: "Set SMS Region Policy",
       idempotentHint: true,
       destructiveHint: true,
     },
@@ -33,8 +33,8 @@ export const set_sms_region_policy = tool(
       return code.toUpperCase();
     });
     if (policy_type === "ALLOW") {
-      return toContent(await setAllowSmsRegionPolicy(projectId!, country_codes));
+      return toContent(await setAllowSmsRegionPolicy(projectId, country_codes));
     }
-    return toContent(await setDenySmsRegionPolicy(projectId!, country_codes));
+    return toContent(await setDenySmsRegionPolicy(projectId, country_codes));
   },
 );
diff --git a/src/mcp/tools/core/consult_assistant.ts b/src/mcp/tools/core/consult_assistant.ts
index 4122a5a61ea..1ce8fafc8eb 100644
--- a/src/mcp/tools/core/consult_assistant.ts
+++ b/src/mcp/tools/core/consult_assistant.ts
@@ -14,7 +14,7 @@ export const consult_assistant = tool(
         .describe("A description of what the user is trying to do or learn with Firebase."),
     }),
     annotations: {
-      title: "Helps answer queries and provide information related to Firebase.",
+      title: "Consult Firebase Assistant",
       readOnlyHint: true,
     },
     _meta: {
@@ -24,7 +24,7 @@ export const consult_assistant = tool(
     },
   },
   async ({ prompt }, { projectId }) => {
-    const schema = await chatWithFirebase(prompt, projectId!);
+    const schema = await chatWithFirebase(prompt, projectId);
     return toContent(schema);
   },
 );
diff --git a/src/mcp/tools/core/create_android_sha.ts b/src/mcp/tools/core/create_android_sha.ts
new file mode 100644
index 00000000000..0d1ea820b1d
--- /dev/null
+++ b/src/mcp/tools/core/create_android_sha.ts
@@ -0,0 +1,48 @@
+import { z } from "zod";
+import { tool } from "../../tool.js";
+import { toContent } from "../../util.js";
+import { createAppAndroidSha, ShaCertificateType } from "../../../management/apps.js";
+
+/**
+ * Determines the certificate type based on the SHA hash length
+ */
+function getCertHashType(shaHash: string): string {
+  shaHash = shaHash.replace(/:/g, "");
+  const shaHashCount = shaHash.length;
+  if (shaHashCount === 40) return ShaCertificateType.SHA_1.toString();
+  if (shaHashCount === 64) return ShaCertificateType.SHA_256.toString();
+  return ShaCertificateType.SHA_CERTIFICATE_TYPE_UNSPECIFIED.toString();
+}
+
+export const create_android_sha = tool(
+  {
+    name: "create_android_sha",
+    description: "Adds a SHA certificate hash to an existing Android app.",
+    inputSchema: z.object({
+      app_id: z.string().describe("The Android app ID to add the SHA certificate to."),
+      sha_hash: z.string().describe("The SHA certificate hash to add (SHA-1 or SHA-256)."),
+    }),
+    annotations: {
+      title: "Add SHA Certificate to Android App",
+      destructiveHint: false,
+      readOnlyHint: false,
+    },
+    _meta: {
+      requiresAuth: true,
+      requiresProject: true,
+    },
+  },
+  async ({ app_id, sha_hash }, { projectId }) => {
+    // Add the SHA certificate
+    const certType = getCertHashType(sha_hash);
+    const shaCertificate = await createAppAndroidSha(projectId, app_id, {
+      shaHash: sha_hash,
+      certType,
+    });
+
+    return toContent({
+      ...shaCertificate,
+      message: `Successfully added ${certType} certificate to Android app ${app_id}`,
+    });
+  },
+);
diff --git a/src/mcp/tools/core/create_app.ts b/src/mcp/tools/core/create_app.ts
new file mode 100644
index 00000000000..db0c135de4b
--- /dev/null
+++ b/src/mcp/tools/core/create_app.ts
@@ -0,0 +1,104 @@
+import { z } from "zod";
+import { tool } from "../../tool.js";
+import { toContent } from "../../util.js";
+import { createAndroidApp, createIosApp, createWebApp } from "../../../management/apps.js";
+
+const CREATE_APP_OUTUT_PREFIX = "Created app with the following details:\n\n";
+const CREATE_APP_OUTUT_SUFFIX =
+  "\n\nTo fetch the SDK configuration for this app, use the firebase_get_sdk_config tool.";
+
+export const create_app = tool(
+  {
+    name: "create_app",
+    description: "Creates a new app in your Firebase project for Web, iOS, or Android.",
+    inputSchema: z.object({
+      display_name: z
+        .string()
+        .optional()
+        .describe(
+          "The user-friendly display name for your app. If not provided, a default name may be generated.",
+        ),
+      platform: z
+        .enum(["web", "ios", "android"])
+        .describe("The platform for which to create an app."),
+      android_config: z
+        .object({
+          package_name: z
+            .string()
+            .describe("The package name for your Android app (e.g., com.example.myapp)."),
+        })
+        .optional()
+        .describe("Configuration for Android apps. Required if platform is 'android'."),
+      ios_config: z
+        .object({
+          bundle_id: z
+            .string()
+            .describe("The bundle ID for your iOS app (e.g., com.example.myapp)."),
+          app_store_id: z.string().optional().describe("The App Store ID for your iOS app."),
+        })
+        .optional()
+        .describe("Configuration for iOS apps. Required if platform is 'ios'."),
+    }),
+    annotations: {
+      title: "Create Firebase App",
+      destructiveHint: false,
+      readOnlyHint: false,
+    },
+    _meta: {
+      requiresAuth: true,
+      requiresProject: true,
+    },
+  },
+  async ({ display_name, platform, android_config, ios_config }, { projectId }) => {
+    if (platform === "android" && !android_config) {
+      throw new Error("Android configuration is required when platform is 'android'");
+    }
+    if (platform === "ios" && !ios_config) {
+      throw new Error("iOS configuration is required when platform is 'ios'");
+    }
+
+    try {
+      switch (platform) {
+        case "android":
+          return toContent(
+            await createAndroidApp(projectId, {
+              displayName: display_name,
+              packageName: android_config!.package_name,
+            }),
+            {
+              format: "yaml",
+              contentPrefix: CREATE_APP_OUTUT_PREFIX,
+              contentSuffix: CREATE_APP_OUTUT_SUFFIX,
+            },
+          );
+        case "ios":
+          return toContent(
+            await createIosApp(projectId, {
+              displayName: display_name,
+              bundleId: ios_config!.bundle_id,
+              appStoreId: ios_config!.app_store_id,
+            }),
+            {
+              format: "yaml",
+              contentPrefix: CREATE_APP_OUTUT_PREFIX,
+              contentSuffix: CREATE_APP_OUTUT_SUFFIX,
+            },
+          );
+        case "web":
+          return toContent(
+            await createWebApp(projectId, {
+              displayName: display_name,
+            }),
+            {
+              format: "yaml",
+              contentPrefix: CREATE_APP_OUTUT_PREFIX,
+              contentSuffix: CREATE_APP_OUTUT_SUFFIX,
+            },
+          );
+      }
+    } catch (err: any) {
+      const originalMessage = err.original ? `: ${err.original.message}` : "";
+      throw new Error(`${err.message}\nOriginal error: ${originalMessage}`);
+    }
+  },
+);
diff --git a/src/mcp/tools/core/create_project.ts b/src/mcp/tools/core/create_project.ts
new file mode 100644
index 00000000000..8fb00a6b9d5
--- /dev/null
+++ b/src/mcp/tools/core/create_project.ts
@@ -0,0 +1,84 @@
+import { z } from "zod";
+import { tool } from "../../tool.js";
+import { toContent } from "../../util.js";
+import {
+  checkFirebaseEnabledForCloudProject,
+  createFirebaseProjectAndLog,
+  addFirebaseToCloudProject,
+  getProject,
+  ProjectInfo,
+} from "../../../management/projects.js";
+import { getErrStatus } from "../../../error.js";
+
+/**
+ * Checks if a Cloud project exists and the user has access to it
+ */
+async function checkCloudProject(projectId: string): Promise<ProjectInfo | undefined> {
+  try {
+    return await getProject(projectId);
+  } catch (err: any) {
+    if (getErrStatus(err) === 403) {
+      return undefined;
+    }
+    throw err;
+  }
+}
+
+export const create_project = tool(
+  {
+    name: "create_project",
+    description: "Creates a new Firebase project.",
+    inputSchema: z.object({
+      project_id: z.string().describe("The project ID to create or use."),
+      display_name: z
+        .string()
+        .optional()
+        .describe("The user-friendly display name for the project."),
+    }),
+    annotations: {
+      title: "Create Firebase Project",
+      destructiveHint: false,
+      readOnlyHint: false,
+    },
+    _meta: {
+      requiresAuth: true,
+      requiresProject: false,
+    },
+  },
+  async ({ project_id, display_name }) => {
+    try {
+      // Check if cloud project exists
+      const cloudProject = await checkCloudProject(project_id);
+
+      // If project doesn't exist, create it and add Firebase
+      if (!cloudProject) {
+        const newProject = await createFirebaseProjectAndLog(project_id, {
+          displayName: display_name,
+        });
+        return toContent({
+          message: `Successfully created new Firebase project: ${project_id}`,
+          project: newProject,
+        });
+      }
+
+      // Check if Firebase is enabled
+      let firebaseProject = await checkFirebaseEnabledForCloudProject(project_id);
+      if (firebaseProject) {
+        return toContent({
+          message: `Project ${project_id} already exists and has Firebase enabled.`,
+          project: firebaseProject,
+        });
+      }
+
+      // Project exists but Firebase is not enabled
+      firebaseProject = await addFirebaseToCloudProject(project_id);
+      return toContent({
+        message: `Successfully added Firebase to existing project: ${project_id}`,
+        project: firebaseProject,
+      });
+    } catch (err: any) {
+      const originalMessage = err.original ? `: ${err.original.message}` : "";
+      throw new Error(`${err.message}\nOriginal error: ${originalMessage}`);
+    }
+  },
+);
diff --git a/src/mcp/tools/core/get_admin_sdk_config.ts b/src/mcp/tools/core/get_admin_sdk_config.ts
new file mode 100644
index 00000000000..56dfdf64190
--- /dev/null
+++ b/src/mcp/tools/core/get_admin_sdk_config.ts
@@ -0,0 +1,27 @@
+import { z } from "zod";
+import { tool } from "../../tool.js";
+import { mcpError, toContent } from "../../util.js";
+import { getProjectAdminSdkConfigOrCached } from "../../../emulator/adminSdkConfig.js";
+
+export const get_admin_sdk_config = tool(
+  {
+    name: "get_admin_sdk_config",
+    description: "Gets the Admin SDK config for the current project. ",
+    inputSchema: z.object({}),
+    annotations: {
+      title: "Get Admin SDK Config",
+      readOnlyHint: true,
+    },
+    _meta: {
+      requiresAuth: true,
+      requiresProject: true,
+    },
+  },
+  async (_, { projectId }) => {
+    const adminSdkConfig = await getProjectAdminSdkConfigOrCached(projectId || "");
+    if (!adminSdkConfig) {
+      return mcpError(`No Admin SDK configuration found in project '${projectId || ""}'`);
+    }
+    return toContent(adminSdkConfig);
+  },
+);
diff --git a/src/mcp/tools/core/get_environment.ts b/src/mcp/tools/core/get_environment.ts
new file mode 100644
index 00000000000..0792a388c88
--- /dev/null
+++ b/src/mcp/tools/core/get_environment.ts
@@ -0,0 +1,57 @@
+import { z } from "zod";
+import { tool } from "../../tool.js";
+import { toContent } from "../../util.js";
+import { getAliases } from "../../../projectUtils.js";
+import { dump } from "js-yaml";
+import { getAllAccounts } from "../../../auth.js";
+
+export const get_environment = tool(
+  {
+    name: "get_environment",
+    description:
+      "Retrieves information about the current Firebase environment including current authenticated user, project directory, active project, and more.",
+    inputSchema: z.object({}),
+    annotations: {
+      title: "Get Firebase Environment Info",
+      readOnlyHint: true,
+    },
+    _meta: {
+      requiresAuth: false,
+      requiresProject: false,
+    },
+  },
+  async (_, { projectId, host, accountEmail, rc, config }) => {
+    const aliases = projectId ? getAliases({ rc }, projectId) : [];
+    return toContent(`# Environment Information
+
+Project Directory: ${host.cachedProjectRoot}
+Project Config Path: ${config.projectFileExists("firebase.json") ? config.path("firebase.json") : "<NO CONFIG PRESENT>"}
+Active Project ID: ${
+      projectId ? `${projectId}${aliases.length ? ` (alias: ${aliases.join(",")})` : ""}` : "<NONE>"
+    }
+Authenticated User: ${accountEmail || "<NONE>"}
+
+# Available Project Aliases (format: '[alias]: [projectId]')
+
+${dump(rc.projects).trim()}
+
+# Available Accounts:
+
+${dump(getAllAccounts().map((account) => account.user.email)).trim()}
+${
+  config.projectFileExists("firebase.json")
+    ? `
+# firebase.json contents:
+
+\`\`\`json
+${config.readProjectFile("firebase.json")}
+\`\`\``
+    : `\n# Empty Environment
+
+It looks like the current directory is not initialized as a Firebase project. The user will most likely want to:
+
+a) Change the project directory using the 'firebase_update_environment' tool to select a directory with a 'firebase.json' file in it, or
+b) Initialize a new Firebase project directory using the 'firebase_init' tool.`
+}`);
+  },
+);
diff --git a/src/mcp/tools/core/get_project.ts b/src/mcp/tools/core/get_project.ts
index ed6a24dea35..183c2556cda 100644
--- a/src/mcp/tools/core/get_project.ts
+++ b/src/mcp/tools/core/get_project.ts
@@ -18,6 +18,6 @@ export const get_project = tool(
     },
   },
   async (_, { projectId }) => {
-    return toContent(await getProject(projectId!));
+    return toContent(await getProject(projectId));
   },
 );
diff --git a/src/mcp/tools/core/get_sdk_config.ts b/src/mcp/tools/core/get_sdk_config.ts
index 307045a5191..957837c9cd3 100644
--- a/src/mcp/tools/core/get_sdk_config.ts
+++ b/src/mcp/tools/core/get_sdk_config.ts
@@ -11,9 +11,14 @@ export const get_sdk_config = tool(
     inputSchema: z.object({
       platform: z
         .enum(["ios", "android", "web"])
-        .nullish()
-        .describe("the platform for which you want config"),
-      app_id: z.string().nullish().describe("the specific app id to fetch"),
+        .optional()
+        .describe(
+          "The platform for which you want config. One of 'platform' or 'app_id' must be provided.",
+        ),
+      app_id: z
+        .string()
+        .optional()
+        .describe("The specific app ID to fetch. One of 'platform' or 'app_id' must be provided."),
     }),
     annotations: {
       title: "Get Firebase SDK Config",
@@ -30,7 +35,7 @@ export const get_sdk_config = tool(
       return mcpError(
         "Must specify one of 'web', 'ios', or 'android' for platform or an app_id for get_sdk_config tool.",
       );
-    const apps = await listFirebaseApps(projectId!, platform ?? AppPlatform.ANY);
+    const apps = await listFirebaseApps(projectId, platform ?? AppPlatform.ANY);
     platform = platform || apps.find((app) => app.appId === appId)?.platform;
     appId = appId || apps.find((app) => app.platform === platform)?.appId;
     if (!appId)
diff --git a/src/mcp/tools/core/index.ts b/src/mcp/tools/core/index.ts
index e5ef4b6bf01..060284a16f0 100644
--- a/src/mcp/tools/core/index.ts
+++ b/src/mcp/tools/core/index.ts
@@ -1,15 +1,29 @@
 import type { ServerTool } from "../../tool.js";
 
-import { consult_assistant } from "./consult_assistant.js";
 import { get_project } from "./get_project.js";
-import { use_project } from "./use_project.js";
 import { get_sdk_config } from "./get_sdk_config.js";
 import { list_apps } from "./list_apps.js";
+import { create_project } from "./create_project.js";
+import { create_app } from "./create_app.js";
+import { get_admin_sdk_config } from "./get_admin_sdk_config.js";
+import { create_android_sha } from "./create_android_sha.js";
+import { init } from "./init.js";
+import { get_environment } from "./get_environment.js";
+import { update_environment } from "./update_environment.js";
+import { list_projects } from "./list_projects.js";
+// import { consult_assistant } from "./consult_assistant.js";
 
 export const coreTools: ServerTool[] = [
   get_project,
-  use_project,
   list_apps,
+  get_admin_sdk_config,
+  list_projects,
   get_sdk_config,
-  consult_assistant,
+  create_project,
+  create_app,
+  create_android_sha,
+  // consult_assistant,
+  get_environment,
+  update_environment,
+  init,
 ];
diff --git a/src/mcp/tools/core/init.ts b/src/mcp/tools/core/init.ts
new file mode 100644
index 00000000000..b611bd04315
--- /dev/null
+++ b/src/mcp/tools/core/init.ts
@@ -0,0 +1,144 @@
+import { z } from "zod";
+import { tool } from "../../tool.js";
+import { toContent } from "../../util.js";
+import { DEFAULT_RULES } from "../../../init/features/database.js";
+import { actuate, Setup, SetupInfo } from "../../../init/index.js";
+
+export const init = tool(
+  {
+    name: "init",
+    description:
+      "Initializes selected Firebase features in the workspace. All features are optional; provide only the products you wish to set up. You can initialize new features into an existing project directory, but re-initializing an existing feature may overwrite configuration.",
+    inputSchema: z.object({
+      features: z.object({
+        database: z
+          .object({
+            rules_filename: z
+              .string()
+              .optional()
+              .default("database.rules.json")
+              .describe("The file to use for Realtime Database Security Rules."),
+            rules: z
+              .string()
+              .optional()
+              .default(DEFAULT_RULES)
+              .describe("The security rules to use for Realtime Database Security Rules."),
+          })
+          .optional()
+          .describe(
+            "Provide this object to initialize Firebase Realtime Database in this project directory.",
+          ),
+        firestore: z
+          .object({
+            database_id: z
+              .string()
+              .optional()
+              .default("(default)")
+              .describe("The database ID to use for Firestore."),
+            rules_filename: z
+              .string()
+              .optional()
+              .default("firestore.rules")
+              .describe("The file to use for Firestore Security Rules."),
+            rules: z
+              .string()
+              .optional()
+              .describe(
+                "The security rules to use for Firestore Security Rules. Default to open rules that expire in 30 days.",
+              ),
+          })
+          .optional()
+          .describe("Provide this object to initialize Cloud Firestore in this project directory."),
+        dataconnect: z
+          .object({
+            service_id: z
+              .string()
+              .optional()
+              .describe(
+                "The Firebase Data Connect service ID to initialize. Default to match the current folder name.",
+              ),
+            location_id: z
+              .string()
+              .optional()
+              .default("us-central1")
+              .describe("The GCP region ID to set up the Firebase Data Connect service."),
+            cloudsql_instance_id: z
+              .string()
+              .optional()
+              .describe(
+                "The GCP Cloud SQL instance ID to use in the Firebase Data Connect service. By default, use <serviceId>-fdc.",
+              ),
+            cloudsql_database: z
+              .string()
+              .optional()
+              .default("fdcdb")
+              .describe("The Postgres database ID to use in the Firebase Data Connect service."),
+          })
+          .optional()
+          .describe(
+            "Provide this object to initialize Firebase Data Connect in this project directory.",
+          ),
+      }),
+    }),
+    annotations: {
+      title: "Initialize Firebase Products",
+      readOnlyHint: false,
+    },
+    _meta: {
+      requiresProject: false, // Can start from scratch.
+      requiresAuth: false, // Will throw error if the specific feature needs it.
+    },
+  },
+  async ({ features }, { projectId, config, rc }) => {
+    const featuresList: string[] = [];
+    const featureInfo: SetupInfo = {};
+    if (features.database) {
+      featuresList.push("database");
+      featureInfo.database = {
+        rulesFilename: features.database.rules_filename,
+        rules: features.database.rules,
+        writeRules: true,
+      };
+    }
+    if (features.firestore) {
+      featuresList.push("firestore");
+      featureInfo.firestore = {
+        databaseId: features.firestore.database_id,
+        rulesFilename: features.firestore.rules_filename,
+        rules: features.firestore.rules || "",
+        writeRules: true,
+        indexesFilename: "",
+        indexes: "",
+        writeIndexes: true,
+      };
+    }
+    if (features.dataconnect) {
+      featuresList.push("dataconnect");
+      featureInfo.dataconnect = {
+        serviceId: features.dataconnect.service_id || "",
+        locationId: features.dataconnect.location_id || "",
+        cloudSqlInstanceId: features.dataconnect.cloudsql_instance_id || "",
+        cloudSqlDatabase: features.dataconnect.cloudsql_database || "",
+        connectors: [], // TODO populate with GiF,
+        isNewInstance: false,
+        isNewDatabase: false,
+        schemaGql: [], // TODO populate with GiF
+        shouldProvisionCSQL: false,
+      };
+    }
+    const setup: Setup = {
+      config: config?.src,
+      rcfile: rc?.data,
+      projectId: projectId,
+      features: [...featuresList],
+      featureInfo: featureInfo,
+    };
+    // Set force to true to avoid prompting the user for confirmation.
+    await actuate(setup, config, { force: true });
+    config.writeProjectFile("firebase.json", setup.config);
+    config.writeProjectFile(".firebaserc", setup.rcfile);
+    return toContent(
+      `Successfully setup the project ${projectId} with those features: ${featuresList.join(", ")}`,
+    );
+  },
+);
diff --git a/src/mcp/tools/core/list_apps.ts b/src/mcp/tools/core/list_apps.ts
index 2cc3a082e0c..65058d52afa 100644
--- a/src/mcp/tools/core/list_apps.ts
+++ b/src/mcp/tools/core/list_apps.ts
@@ -9,8 +9,8 @@ export const list_apps = tool(
     description: "Retrieves apps registered in the current Firebase project.",
     inputSchema: z.object({
       platform: z
-        .enum(["ios", "android", "web"])
-        .nullish()
+        .enum(["ios", "android", "web", "all"])
+        .default("all")
         .describe("the specific platform to list (omit to list all platforms)"),
     }),
     annotations: {
@@ -23,10 +23,15 @@ export const list_apps = tool(
     },
   },
   async ({ platform }, { projectId }) => {
-    const apps = await listFirebaseApps(
-      projectId!,
-      (platform?.toUpperCase() as AppPlatform) ?? AppPlatform.ANY,
-    );
-    return toContent(apps);
+    try {
+      const apps = await listFirebaseApps(
+        projectId!,
+        platform === "all" ? AppPlatform.ANY : (platform.toUpperCase() as AppPlatform),
+      );
+      return toContent(apps);
+    } catch (err: any) {
+      const originalMessage = err.original ? `: ${err.original.message}` : "";
+      throw new Error(`Failed to list Firebase apps${originalMessage}`);
+    }
   },
 );
diff --git a/src/mcp/tools/core/list_projects.ts b/src/mcp/tools/core/list_projects.ts
new file mode 100644
index 00000000000..a92937b3067
--- /dev/null
+++ b/src/mcp/tools/core/list_projects.ts
@@ -0,0 +1,50 @@
+import { z } from "zod";
+import { tool } from "../../tool.js";
+import { toContent } from "../../util.js";
+import { getFirebaseProjectPage } from "../../../management/projects.js";
+
+const PROJECT_LIST_PAGE_SIZE = 20;
+
+export const list_projects = tool(
+  {
+    name: "list_projects",
+    description: "Retrieves a list of Firebase projects up to the specified total count.",
+    inputSchema: z.object({
+      page_size: z
+        .number()
+        .min(1)
+        .default(PROJECT_LIST_PAGE_SIZE)
+        .describe("the number of projects to list per page (defaults to 1000)"),
+      page_token: z.string().optional().describe("the page token to start listing from"),
+    }),
+    annotations: {
+      title: "List Firebase Projects",
+      readOnlyHint: true,
+      idempotentHint: true,
+    },
+    _meta: {
+      requiresAuth: true,
+    },
+  },
+  async ({ page_size, page_token }) => {
+    try {
+      const projectPage = await getFirebaseProjectPage(page_size, page_token);
+
+      return toContent(
+        {
+          projects: projectPage.projects,
+          next_page_token: projectPage.nextPageToken,
+        },
+        {
+          contentPrefix: `Here are ${projectPage.projects.length} Firebase projects${page_token ? " (continued)" : ""}:\n\n`,
+          contentSuffix: projectPage.nextPageToken
+            ? "\nThere are more projects available. To see the next page, call this tool again with the next_page_token shown above."
+            : "",
+        },
+      );
+    } catch (err: any) {
+      const originalMessage = err.original ? `: ${err.original.message}` : "";
+      throw new Error(`Failed to list Firebase projects${originalMessage}`);
+    }
+  },
+);
diff --git a/src/mcp/tools/core/update_environment.ts b/src/mcp/tools/core/update_environment.ts
new file mode 100644
index 00000000000..4c32b6ee541
--- /dev/null
+++ b/src/mcp/tools/core/update_environment.ts
@@ -0,0 +1,66 @@
+import { z } from "zod";
+import { tool } from "../../tool.js";
+import { mcpError, toContent } from "../../util.js";
+import { setNewActive } from "../../../commands/use.js";
+import { assertAccount, setProjectAccount } from "../../../auth.js";
+import { existsSync } from "node:fs";
+
+export const update_environment = tool(
+  {
+    name: "update_environment",
+    description:
+      "Updates Firebase environment config such as project directory, active project, active user account, and more. Use `firebase_get_environment` to see the currently configured environment.",
+    inputSchema: z.object({
+      project_dir: z
+        .string()
+        .optional()
+        .describe(
+          "Change the current project directory - this should be a directory that has a `firebase.json` file (or will have one).",
+        ),
+      active_project: z
+        .string()
+        .optional()
+        .describe(
+          "Change the active project for the current project directory. Should be a Firebase project ID or configured project alias.",
+        ),
+      active_user_account: z
+        .string()
+        .optional()
+        .describe(
+          "The email address of the signed-in user to authenticate as when interacting with the current project directory.",
+        ),
+    }),
+    annotations: {
+      title: "Update Firebase Environment",
+      readOnlyHint: false,
+    },
+    _meta: {
+      requiresAuth: false,
+      requiresProject: false,
+    },
+  },
+  async ({ project_dir, active_project, active_user_account }, { config, rc, host }) => {
+    let output = "";
+    if (project_dir) {
+      if (!existsSync(project_dir))
+        return mcpError(
+          `Cannot update project directory to '${project_dir}' as it does not exist.`,
+        );
+      host.setProjectRoot(project_dir);
+      output += `- Updated project directory to '${project_dir}'\n`;
+    }
+    if (active_project) {
+      await setNewActive(active_project, undefined, rc, config.projectDir);
+      output += `- Updated active project to '${active_project}'\n`;
+    }
+    if (active_user_account) {
+      assertAccount(active_user_account, { mcp: true });
+      setProjectAccount(host.cachedProjectRoot!, active_user_account);
+      output += `- Updated active account to '${active_user_account}'\n`;
+    }
+
+    if (output === "") output = "No changes were made.";
+
+    return toContent(output);
+  },
+);
diff --git a/src/mcp/tools/core/use_project.ts b/src/mcp/tools/core/use_project.ts
deleted file mode 100644
index fe8abb7880b..00000000000
--- a/src/mcp/tools/core/use_project.ts
+++ /dev/null
@@ -1,32 +0,0 @@
-import { z } from "zod";
-import { tool } from "../../tool.js";
-import { setNewActive } from "../../../commands/use.js";
-import { mcpError, toContent } from "../../util.js";
-
-export const use_project = tool(
-  {
-    name: "use_project",
-    description: "Select a Firebase Project to use for subsequent tool calls.",
-    inputSchema: z.object({
-      project: z.string().describe("The project id, number, or alias to use."),
-    }),
-    annotations: {
-      title: "Select a Firebase Project to use for subsequent tool calls.",
-      readOnlyHint: false,
-    },
-    _meta: {
-      requiresAuth: true,
-      requiresProject: false,
-    },
-  },
-  async ({ project }, { config, rc }) => {
-    try {
-      await setNewActive(project, undefined, rc, config.projectDir);
-    } catch (err: any) {
-      return mcpError(
-        `Unable to set ${project} as active project. Got error ${JSON.stringify(err, null, 2)}`,
-      );
-    }
-    return toContent(`The active Firebase project has been set to ${project}.`);
-  },
-);
diff --git a/src/mcp/tools/crashlytics/index.ts b/src/mcp/tools/crashlytics/index.ts
new file mode 100644
index 00000000000..dc7093e76eb
--- /dev/null
+++ b/src/mcp/tools/crashlytics/index.ts
@@ -0,0 +1,4 @@
+import type { ServerTool } from "../../tool.js";
+import { list_top_issues } from "./list_top_issues.js";
+
+export const crashlyticsTools: ServerTool[] = [list_top_issues];
diff --git a/src/mcp/tools/crashlytics/list_top_issues.ts b/src/mcp/tools/crashlytics/list_top_issues.ts
new file mode 100644
index 00000000000..7159dc23ef6
--- /dev/null
+++ b/src/mcp/tools/crashlytics/list_top_issues.ts
@@ -0,0 +1,38 @@
+import { z } from "zod";
+import { tool } from "../../tool.js";
+import { mcpError, toContent } from "../../util.js";
+import { listTopIssues } from "../../../crashlytics/listTopIssues.js";
+
+export const list_top_issues = tool(
+  {
+    name: "list_top_issues",
+    description: "List the top crashes from crashlytics happening in the application.",
+    inputSchema: z.object({
+      app_id: z
+        .string()
+        .optional()
+        .describe(
+          "AppId for which the issues list is fetched. Defaults to the first appId provided by firebase_list_apps.",
+        ),
+      issue_count: z
+        .number()
+        .optional()
+        .describe("Number of issues that needs to be fetched. Defaults to 10 if unspecified."),
+    }),
+    annotations: {
+      title: "List Top Crashlytics Issues.",
+      readOnlyHint: true,
+    },
+    _meta: {
+      requiresAuth: true,
+      requiresProject: true,
+    },
+  },
+  async ({ app_id, issue_count }, { projectId }) => {
+    if (!app_id) return mcpError(`Must specify 'app_id' parameter.`);
+
+    issue_count ??= 10;
+
+    return toContent(await listTopIssues(projectId, app_id, issue_count));
+  },
+);
diff --git a/src/mcp/tools/dataconnect/emulator.ts b/src/mcp/tools/dataconnect/emulator.ts
new file mode 100644
index 00000000000..990b4ff19c6
--- /dev/null
+++ b/src/mcp/tools/dataconnect/emulator.ts
@@ -0,0 +1,40 @@
+import { EmulatorHubClient } from "../../../emulator/hubClient.js";
+import { EmulatorInfo, Emulators } from "../../../emulator/types.js";
+import { Client } from "../../../apiv2.js";
+import { DATACONNECT_API_VERSION } from "../../../dataconnect/dataplaneClient.js";
+
+function formatEndpoint(emulatorInfo: EmulatorInfo): { host: string; port: number; url: string } {
+  const host = emulatorInfo.host.includes(":") ? `[${emulatorInfo.host}]` : emulatorInfo.host;
+  return {
+    host: emulatorInfo.host,
+    port: emulatorInfo.port,
+    url: `http://${host}:${emulatorInfo.port}`,
+  };
+}
+
+export async function getDataConnectEmulatorClient(hubClient?: EmulatorHubClient): Promise<Client> {
+  if (!hubClient) {
+    throw Error(
+      "Emulator Hub not found or is not running. Please ensure the emulator is started, you can start the Data Connect emualtor by running `firebase emulators:start --only dataconnect`.",
+    );
+  }
+
+  const emulators = await hubClient.getEmulators();
+  const dcEmulatorInfo = emulators[Emulators.DATACONNECT];
+
+  if (!dcEmulatorInfo) {
+    throw Error(
+      "No Data Connect Emulator found running, you can start the emualtor by running `firebase emulators:start --only dataconnect`.",
+    );
+  }
+
+  const emulatorDetails = formatEndpoint(dcEmulatorInfo);
+
+  const apiClient = new Client({
+    urlPrefix: emulatorDetails.url,
+    apiVersion: DATACONNECT_API_VERSION,
+    auth: false,
+  });
+
+  return apiClient;
+}
diff --git a/src/mcp/tools/dataconnect/execute_graphql.ts b/src/mcp/tools/dataconnect/execute_graphql.ts
index 3dceab8328c..a090d07446f 100644
--- a/src/mcp/tools/dataconnect/execute_graphql.ts
+++ b/src/mcp/tools/dataconnect/execute_graphql.ts
@@ -1,17 +1,19 @@
 import { z } from "zod";
 
 import { tool } from "../../tool.js";
-import * as client from "../../../dataconnect/dataplaneClient.js";
+import * as dataplane from "../../../dataconnect/dataplaneClient.js";
 import { pickService } from "../../../dataconnect/fileUtils.js";
 import { graphqlResponseToToolResponse, parseVariables } from "./converter.js";
+import { Client } from "../../../apiv2.js";
+import { getDataConnectEmulatorClient } from "./emulator.js";
 
 export const execute_graphql = tool(
   {
     name: "execute_graphql",
-    description: "Executes an arbitrary GraphQL against a Data Connect service",
+    description: "Executes an arbitrary GraphQL against a Data Connect service or its emulator.",
     inputSchema: z.object({
       query: z.string().describe("A GraphQL query or mutation to execute against the service"),
-      serviceId: z
+      service_id: z
         .string()
         .nullable()
         .describe(
@@ -23,9 +25,10 @@ export const execute_graphql = tool(
         .describe(
           "A stringified JSON object containing variables for the operation. MUST be valid JSON.",
         ),
+      use_emulator: z.boolean().default(false).describe("Target the DataConnect emulator if true."),
     }),
     annotations: {
-      title: "Executes a arbitrary GraphQL query or mutation against a Data Connect service",
+      title: "Execute GraphQL Operation",
       readOnlyHint: false,
     },
     _meta: {
@@ -33,13 +36,25 @@ export const execute_graphql = tool(
       requiresAuth: true,
     },
   },
-  async ({ query, serviceId, variables: unparsedVariables }, { projectId, config }) => {
-    const serviceInfo = await pickService(projectId!, config!, serviceId || undefined);
-    const response = await client.executeGraphQL(
-      client.dataconnectDataplaneClient(),
-      serviceInfo.serviceName,
-      { name: "", query, variables: parseVariables(unparsedVariables) },
-    );
+  async (
+    { query, service_id, variables: unparsedVariables, use_emulator },
+    { projectId, config, host },
+  ) => {
+    const serviceInfo = await pickService(projectId, config, service_id || undefined);
+
+    let apiClient: Client;
+
+    if (use_emulator) {
+      apiClient = await getDataConnectEmulatorClient(await host.getEmulatorHubClient());
+    } else {
+      apiClient = dataplane.dataconnectDataplaneClient();
+    }
+
+    const response = await dataplane.executeGraphQL(apiClient, serviceInfo.serviceName, {
+      name: "",
+      query,
+      variables: parseVariables(unparsedVariables),
+    });
     return graphqlResponseToToolResponse(response.body);
   },
 );
diff --git a/src/mcp/tools/dataconnect/execute_graphql_read.ts b/src/mcp/tools/dataconnect/execute_graphql_read.ts
index da3b6f0947e..32c045c15c3 100644
--- a/src/mcp/tools/dataconnect/execute_graphql_read.ts
+++ b/src/mcp/tools/dataconnect/execute_graphql_read.ts
@@ -1,17 +1,20 @@
 import { z } from "zod";
 
 import { tool } from "../../tool.js";
-import * as client from "../../../dataconnect/dataplaneClient.js";
+import * as dataplane from "../../../dataconnect/dataplaneClient.js";
 import { pickService } from "../../../dataconnect/fileUtils.js";
 import { graphqlResponseToToolResponse, parseVariables } from "./converter.js";
+import { Client } from "../../../apiv2.js";
+import { getDataConnectEmulatorClient } from "./emulator.js";
 
 export const execute_graphql_read = tool(
   {
     name: "execute_graphql_read",
-    description: "Executes an arbitrary GraphQL against a Data Connect service. Cannot write data.",
+    description:
+      "Executes an arbitrary GraphQL query against a Data Connect service or its emulator. Cannot write data.",
     inputSchema: z.object({
       query: z.string().describe("A GraphQL query to execute against the service"),
-      serviceId: z
+      service_id: z
         .string()
         .nullable()
         .describe(
@@ -23,9 +26,10 @@ export const execute_graphql_read = tool(
         .describe(
           "A stringified JSON object containing variables for the operation. MUST be valid JSON.",
         ),
+      use_emulator: z.boolean().default(false).describe("Target the DataConnect emulator if true."),
     }),
     annotations: {
-      title: "Executes a arbitrary GraphQL query against a Data Connect service",
+      title: "Execute Data Connect GraphQL Query",
       readOnlyHint: true,
     },
     _meta: {
@@ -33,13 +37,24 @@ export const execute_graphql_read = tool(
       requiresAuth: true,
     },
   },
-  async ({ query, serviceId, variables: unparsedVariables }, { projectId, config }) => {
-    const serviceInfo = await pickService(projectId!, config!, serviceId || undefined);
-    const response = await client.executeGraphQLRead(
-      client.dataconnectDataplaneClient(),
-      serviceInfo.serviceName,
-      { name: "", query, variables: parseVariables(unparsedVariables) },
-    );
+  async (
+    { query, service_id, variables: unparsedVariables, use_emulator },
+    { projectId, config, host },
+  ) => {
+    const serviceInfo = await pickService(projectId, config, service_id || undefined);
+
+    let apiClient: Client;
+    if (use_emulator) {
+      apiClient = await getDataConnectEmulatorClient(await host.getEmulatorHubClient());
+    } else {
+      apiClient = dataplane.dataconnectDataplaneClient();
+    }
+
+    const response = await dataplane.executeGraphQLRead(apiClient, serviceInfo.serviceName, {
+      name: "",
+      query,
+      variables: parseVariables(unparsedVariables),
+    });
     return graphqlResponseToToolResponse(response.body);
   },
 );
diff --git a/src/mcp/tools/dataconnect/execute_mutation.ts b/src/mcp/tools/dataconnect/execute_mutation.ts
index 045573e3f22..ed140e505b3 100644
--- a/src/mcp/tools/dataconnect/execute_mutation.ts
+++ b/src/mcp/tools/dataconnect/execute_mutation.ts
@@ -2,23 +2,26 @@ import { z } from "zod";
 
 import { tool } from "../../tool.js";
 import { mcpError } from "../../util.js";
-import * as client from "../../../dataconnect/dataplaneClient.js";
+import * as dataplane from "../../../dataconnect/dataplaneClient.js";
 import { pickService } from "../../../dataconnect/fileUtils.js";
 import { graphqlResponseToToolResponse, parseVariables } from "./converter.js";
+import { Client } from "../../../apiv2.js";
+import { getDataConnectEmulatorClient } from "./emulator.js";
 
 export const execute_mutation = tool(
   {
     name: "execute_mutation",
-    description: "Executes a deployed Data Connect mutation. Can read and write data.",
+    description:
+      "Executes a deployed Data Connect mutation against a service or its emulator. Can read and write data.",
     inputSchema: z.object({
       operationName: z.string().describe("The name of the deployed operation you want to execute"),
-      serviceId: z
+      service_id: z
         .string()
         .nullable()
         .describe(
           "The Firebase Data Connect service ID to look for. If there is only one service defined in firebase.json, this can be omitted and that will be used.",
         ),
-      connectorId: z
+      connector_id: z
         .string()
         .nullable()
         .describe(
@@ -30,9 +33,10 @@ export const execute_mutation = tool(
         .describe(
           "A stringified JSON object containing the variables needed to execute the operation. The value MUST be able to be parsed as a JSON object.",
         ),
+      use_emulator: z.boolean().default(false).describe("Target the DataConnect emulator if true."),
     }),
     annotations: {
-      title: "Executes a deployed Data Connect query or mutation",
+      title: "Execute Data Connect Connector Mutation",
       readOnlyHint: false,
     },
     _meta: {
@@ -41,27 +45,38 @@ export const execute_mutation = tool(
     },
   },
   async (
-    { operationName, serviceId, connectorId, variables: unparsedVariables },
-    { projectId, config },
+    { operationName, service_id, connector_id, variables: unparsedVariables, use_emulator },
+    { projectId, config, host },
   ) => {
-    const serviceInfo = await pickService(projectId!, config!, serviceId || undefined);
-    if (!connectorId) {
+    const serviceInfo = await pickService(projectId, config, service_id || undefined);
+    let apiClient: Client;
+
+    if (!connector_id) {
       if (serviceInfo.connectorInfo.length === 0) {
-        return mcpError(`Service ${serviceInfo.serviceName} has no connectors`);
+        return mcpError(
+          `Service ${serviceInfo.serviceName} has no connectors`,
+          "NO_CONNECTORS_FOUND",
+        );
       }
       if (serviceInfo.connectorInfo.length > 1) {
         return mcpError(
-          `Service ${serviceInfo.serviceName} has more than one connector. Please use the connectorId argument to specifiy which connector this operation is part of.`,
+          `Service ${serviceInfo.serviceName} has more than one connector. Please use the connector_id argument to specify which connector this operation is part of.`,
+          "MULTIPLE_CONNECTORS_FOUND",
         );
       }
-      connectorId = serviceInfo.connectorInfo[0].connectorYaml.connectorId;
+      connector_id = serviceInfo.connectorInfo[0].connectorYaml.connectorId;
+    }
+    const connectorPath = `${serviceInfo.serviceName}/connectors/${connector_id}`;
+
+    if (use_emulator) {
+      apiClient = await getDataConnectEmulatorClient(await host.getEmulatorHubClient());
+    } else {
+      apiClient = dataplane.dataconnectDataplaneClient();
     }
-    const connectorPath = `${serviceInfo.serviceName}/connectors/${connectorId}`;
-    const response = await client.executeGraphQLMutation(
-      client.dataconnectDataplaneClient(),
-      connectorPath,
-      { operationName, variables: parseVariables(unparsedVariables) },
-    );
+    const response = await dataplane.executeGraphQLMutation(apiClient, connectorPath, {
+      operationName,
+      variables: parseVariables(unparsedVariables),
+    });
     return graphqlResponseToToolResponse(response.body);
   },
 );
diff --git a/src/mcp/tools/dataconnect/execute_query.ts b/src/mcp/tools/dataconnect/execute_query.ts
index e0efcf1b558..16b3b6dceec 100644
--- a/src/mcp/tools/dataconnect/execute_query.ts
+++ b/src/mcp/tools/dataconnect/execute_query.ts
@@ -2,23 +2,26 @@ import { z } from "zod";
 
 import { tool } from "../../tool.js";
 import { mcpError } from "../../util.js";
-import * as client from "../../../dataconnect/dataplaneClient.js";
+import * as dataplane from "../../../dataconnect/dataplaneClient.js";
 import { pickService } from "../../../dataconnect/fileUtils.js";
 import { graphqlResponseToToolResponse, parseVariables } from "./converter.js";
+import { Client } from "../../../apiv2.js";
+import { getDataConnectEmulatorClient } from "./emulator.js";
 
 export const execute_query = tool(
   {
     name: "execute_query",
-    description: "Executes a deployed Data Connect query. Cannot write any data.",
+    description:
+      "Executes a deployed Data Connect query against a service or its emulator. Cannot write any data.",
     inputSchema: z.object({
       operationName: z.string().describe("The name of the deployed operation you want to execute"),
-      serviceId: z
+      service_id: z
         .string()
         .nullable()
         .describe(
           "The Firebase Data Connect service ID to look for. If there is only one service defined in firebase.json, this can be omitted and that will be used.",
         ),
-      connectorId: z
+      connector_id: z
         .string()
         .nullable()
         .describe(
@@ -30,6 +33,7 @@ export const execute_query = tool(
         .describe(
           "A stringified JSON object containing the variables needed to execute the operation. The value MUST be able to be parsed as a JSON object.",
         ),
+      use_emulator: z.boolean().default(false).describe("Target the DataConnect emulator if true."),
     }),
     annotations: {
       title: "Executes a deployed Data Connect query.",
@@ -41,27 +45,38 @@ export const execute_query = tool(
     },
   },
   async (
-    { operationName, serviceId, connectorId, variables: unparsedVariables },
-    { projectId, config },
+    { operationName, service_id, connector_id, variables: unparsedVariables, use_emulator },
+    { projectId, config, host },
   ) => {
-    const serviceInfo = await pickService(projectId!, config!, serviceId || undefined);
-    if (!connectorId) {
+    const serviceInfo = await pickService(projectId, config, service_id || undefined);
+    let apiClient: Client;
+
+    if (!connector_id) {
       if (serviceInfo.connectorInfo.length === 0) {
-        return mcpError(`Service ${serviceInfo.serviceName} has no connectors`);
+        return mcpError(
+          `Service ${serviceInfo.serviceName} has no connectors`,
+          "NO_CONNECTORS_FOUND",
+        );
       }
       if (serviceInfo.connectorInfo.length > 1) {
         return mcpError(
-          `Service ${serviceInfo.serviceName} has more than one connector. Please use the connectorId argument to specifiy which connector this operation is part of.`,
+          `Service ${serviceInfo.serviceName} has more than one connector. Please use the connector_id argument to specify which connector this operation is part of.`,
+          "MULTIPLE_CONNECTORS_FOUND",
         );
       }
-      connectorId = serviceInfo.connectorInfo[0].connectorYaml.connectorId;
+      connector_id = serviceInfo.connectorInfo[0].connectorYaml.connectorId;
+    }
+    const connectorPath = `${serviceInfo.serviceName}/connectors/${connector_id}`;
+
+    if (use_emulator) {
+      apiClient = await getDataConnectEmulatorClient(await host.getEmulatorHubClient());
+    } else {
+      apiClient = dataplane.dataconnectDataplaneClient();
     }
-    const connectorPath = `${serviceInfo.serviceName}/connectors/${connectorId}`;
-    const response = await client.executeGraphQLQuery(
-      client.dataconnectDataplaneClient(),
-      connectorPath,
-      { operationName, variables: parseVariables(unparsedVariables) },
-    );
+    const response = await dataplane.executeGraphQLQuery(apiClient, connectorPath, {
+      operationName,
+      variables: parseVariables(unparsedVariables),
+    });
     return graphqlResponseToToolResponse(response.body);
   },
 );
diff --git a/src/mcp/tools/dataconnect/generate_operation.ts b/src/mcp/tools/dataconnect/generate_operation.ts
index 970aaa81163..47a87a4ed54 100644
--- a/src/mcp/tools/dataconnect/generate_operation.ts
+++ b/src/mcp/tools/dataconnect/generate_operation.ts
@@ -14,18 +14,17 @@ export const generate_operation = tool(
       prompt: z
         .string()
         .describe(
-          "Write the prompt like you're talking to a person, describe the task you're trying to accomplish and give details that are specific to the users requst",
+          "Write the prompt like you're talking to a person, describe the task you're trying to accomplish and give details that are specific to the users request",
         ),
-      serviceId: z
+      service_id: z
         .string()
-        .nullish()
+        .optional()
         .describe(
-          "Optional: Uses the serviceId from the firebase.json file if nothing provided. The serviceId of the deployed Firebase resource.",
+          "Optional: Uses the service ID from the firebase.json file if nothing provided. The service ID of the deployed Firebase resource.",
         ),
     }),
     annotations: {
-      title:
-        "Generate a Firebase Data Connect Operation on a deployed Firebase Data Connect Schema.",
+      title: "Generate Data Connect Operation",
       readOnlyHint: true,
     },
     _meta: {
@@ -34,9 +33,9 @@ export const generate_operation = tool(
       // TODO: Create an endpoint to check for GiF activiation.
     },
   },
-  async ({ prompt, serviceId }, { projectId, config }) => {
-    const serviceInfo = await pickService(projectId!, config!, serviceId || undefined);
-    const schema = await generateOperation(prompt, serviceInfo.serviceName, projectId!);
+  async ({ prompt, service_id }, { projectId, config }) => {
+    const serviceInfo = await pickService(projectId, config, service_id || undefined);
+    const schema = await generateOperation(prompt, serviceInfo.serviceName, projectId);
     return toContent(schema);
   },
 );
diff --git a/src/mcp/tools/dataconnect/generate_schema.ts b/src/mcp/tools/dataconnect/generate_schema.ts
index 4143be3136a..58e8a2cbfa1 100644
--- a/src/mcp/tools/dataconnect/generate_schema.ts
+++ b/src/mcp/tools/dataconnect/generate_schema.ts
@@ -12,7 +12,7 @@ export const generate_schema = tool(
       prompt: z.string().describe("A description of an app that you are interested in building"),
     }),
     annotations: {
-      title: "Generate a Firebase Data Connect Schema for a new Firebase project.",
+      title: "Generate Data Connect Schema",
       readOnlyHint: true,
     },
     _meta: {
@@ -22,7 +22,7 @@ export const generate_schema = tool(
     },
   },
   async ({ prompt }, { projectId }) => {
-    const schema = await generateSchema(prompt, projectId!);
+    const schema = await generateSchema(prompt, projectId);
     return toContent(schema);
   },
 );
diff --git a/src/mcp/tools/dataconnect/get_connector.ts b/src/mcp/tools/dataconnect/get_connector.ts
index 2b71a784ea5..235e9452569 100644
--- a/src/mcp/tools/dataconnect/get_connector.ts
+++ b/src/mcp/tools/dataconnect/get_connector.ts
@@ -5,13 +5,13 @@ import * as client from "../../../dataconnect/client.js";
 import { pickService } from "../../../dataconnect/fileUtils.js";
 import { connectorToText } from "./converter.js";
 
-export const get_connector = tool(
+export const get_connectors = tool(
   {
-    name: "get_connector",
+    name: "get_connectors",
     description:
       "Get the Firebase Data Connect Connectors in the project, which includes the pre-defined GraphQL queries accessible to client SDKs.",
     inputSchema: z.object({
-      serviceId: z
+      service_id: z
         .string()
         .nullable()
         .describe(
@@ -19,7 +19,7 @@ export const get_connector = tool(
         ),
     }),
     annotations: {
-      title: "Obtain the Firebase Data Connect Connectors that's available in the backend",
+      title: "Get Data Connect Connectors",
       readOnlyHint: true,
     },
     _meta: {
@@ -27,8 +27,8 @@ export const get_connector = tool(
       requiresAuth: true,
     },
   },
-  async ({ serviceId }, { projectId, config }) => {
-    const serviceInfo = await pickService(projectId!, config!, serviceId || undefined);
+  async ({ service_id }, { projectId, config }) => {
+    const serviceInfo = await pickService(projectId, config, service_id || undefined);
     const connectors = await client.listConnectors(serviceInfo.serviceName, ["*"]);
     return toContent(connectors.map(connectorToText).join("\n\n"));
   },
diff --git a/src/mcp/tools/dataconnect/get_schema.ts b/src/mcp/tools/dataconnect/get_schema.ts
index 5af7d8f975e..18c93ee813f 100644
--- a/src/mcp/tools/dataconnect/get_schema.ts
+++ b/src/mcp/tools/dataconnect/get_schema.ts
@@ -9,9 +9,9 @@ export const get_schema = tool(
   {
     name: "get_schema",
     description:
-      "List the Firebase Data Connect Schema in the project, which includes Cloud SQL data sources and the GraphQL Schema describing what tables are available.",
+      "Retrieve information about the Firebase Data Connect Schema in the project, including Cloud SQL data sources and the GraphQL Schema describing the data model.",
     inputSchema: z.object({
-      serviceId: z
+      service_id: z
         .string()
         .nullable()
         .describe(
@@ -19,7 +19,7 @@ export const get_schema = tool(
         ),
     }),
     annotations: {
-      title: "Obtain the Firebase Data Connect Schemas that's available in the backend",
+      title: "Get Data Connect Schemas",
       readOnlyHint: true,
     },
     _meta: {
@@ -27,8 +27,8 @@ export const get_schema = tool(
       requiresAuth: true,
     },
   },
-  async ({ serviceId }, { projectId, config }) => {
-    const serviceInfo = await pickService(projectId!, config!, serviceId || undefined);
+  async ({ service_id }, { projectId, config }) => {
+    const serviceInfo = await pickService(projectId, config, service_id || undefined);
     const schemas = await client.listSchemas(serviceInfo.serviceName, ["*"]);
     return toContent(schemas?.map(schemaToText).join("\n\n"));
   },
diff --git a/src/mcp/tools/dataconnect/index.ts b/src/mcp/tools/dataconnect/index.ts
index 2afc121db9f..6981052597e 100644
--- a/src/mcp/tools/dataconnect/index.ts
+++ b/src/mcp/tools/dataconnect/index.ts
@@ -1,10 +1,10 @@
 import type { ServerTool } from "../../tool.js";
-import { generate_operation } from "./generate_operation.js";
-import { generate_schema } from "./generate_schema.js";
+// import { generate_operation } from "./generate_operation.js";
+// import { generate_schema } from "./generate_schema.js";
 
 import { list_services } from "./list_services.js";
 import { get_schema } from "./get_schema.js";
-import { get_connector } from "./get_connector.js";
+import { get_connectors } from "./get_connector.js";
 import { execute_graphql } from "./execute_graphql.js";
 import { execute_graphql_read } from "./execute_graphql_read.js";
 import { execute_query } from "./execute_query.js";
@@ -12,10 +12,10 @@ import { execute_mutation } from "./execute_mutation.js";
 
 export const dataconnectTools: ServerTool[] = [
   list_services,
-  generate_schema,
-  generate_operation,
+  // generate_schema,
+  // generate_operation,
   get_schema,
-  get_connector,
+  get_connectors,
   execute_graphql,
   execute_graphql_read,
   execute_mutation,
diff --git a/src/mcp/tools/dataconnect/list_services.ts b/src/mcp/tools/dataconnect/list_services.ts
index 91ab9209288..4bdb4a17559 100644
--- a/src/mcp/tools/dataconnect/list_services.ts
+++ b/src/mcp/tools/dataconnect/list_services.ts
@@ -9,7 +9,7 @@ export const list_services = tool(
     description: "List the Firebase Data Connect services available in the current project.",
     inputSchema: z.object({}),
     annotations: {
-      title: "List the Firebase Data Connect Services that's available in the backend",
+      title: "List Data Connect Services",
       readOnlyHint: true,
     },
     _meta: {
@@ -18,7 +18,7 @@ export const list_services = tool(
     },
   },
   async (_, { projectId }) => {
-    const services = await client.listAllServices(projectId!);
+    const services = await client.listAllServices(projectId);
     return toContent(services, { format: "yaml" });
   },
 );
diff --git a/src/mcp/tools/directory/get_project_directory.ts b/src/mcp/tools/directory/get_project_directory.ts
deleted file mode 100644
index ab3c8a9c423..00000000000
--- a/src/mcp/tools/directory/get_project_directory.ts
+++ /dev/null
@@ -1,28 +0,0 @@
-import { z } from "zod";
-import { tool } from "../../tool.js";
-import { mcpError, toContent } from "../../util.js";
-import { detectProjectRoot } from "../../../detectProjectRoot.js";
-
-export const get_project_directory = tool(
-  {
-    name: "get_project_directory",
-    description:
-      "Gets the current Firebase project directory. If this has been set using the `set_project_directory` tool it will return that, otherwise it will look for a PROJECT_ROOT environment variable or the current working directory of the running Firebase MCP server.",
-    inputSchema: z.object({}),
-    annotations: {
-      title: "Get Firebase Project Directory",
-      readOnlyHint: true,
-    },
-  },
-  (_, { host }) => {
-    if (!detectProjectRoot({ cwd: host.projectRoot }))
-      return Promise.resolve(
-        mcpError(
-          `There is no detected 'firebase.json' in directory '${host.projectRoot}'. Please use the 'set_project_directory' tool to activate a Firebase project directory.`,
-        ),
-      );
-    return Promise.resolve(
-      toContent(`The current Firebase project directory is '${host.projectRoot}'.`),
-    );
-  },
-);
diff --git a/src/mcp/tools/directory/index.ts b/src/mcp/tools/directory/index.ts
deleted file mode 100644
index be1788643c1..00000000000
--- a/src/mcp/tools/directory/index.ts
+++ /dev/null
@@ -1,4 +0,0 @@
-import { get_project_directory } from "./get_project_directory";
-import { set_project_directory } from "./set_project_directory";
-
-export const directoryTools = [get_project_directory, set_project_directory];
diff --git a/src/mcp/tools/directory/set_project_directory.ts b/src/mcp/tools/directory/set_project_directory.ts
deleted file mode 100644
index 25177a0b152..00000000000
--- a/src/mcp/tools/directory/set_project_directory.ts
+++ /dev/null
@@ -1,43 +0,0 @@
-import { z } from "zod";
-import { tool } from "../../tool.js";
-import { mcpError, toContent } from "../../util.js";
-import { existsSync } from "fs";
-import { join } from "path";
-
-export const set_project_directory = tool(
-  {
-    name: "set_project_directory",
-    description:
-      "Sets the project directory for the Firebase MCP server to utilize for project detection and authentication. This should be a directory with a `firebase.json` file in it. This information is persisted between sessions.",
-    inputSchema: z.object({
-      dir: z
-        .string()
-        .nullable()
-        .describe(
-          "the absolute path of the directory. set to null to 'unset' the value and fall back to the working directory",
-        ),
-    }),
-    annotations: {
-      title: "Set Firebase Project Directory",
-      idempotentHint: true,
-    },
-  },
-  ({ dir }, { host }) => {
-    if (dir === null) {
-      host.setProjectRoot(null);
-      return Promise.resolve(
-        toContent(
-          `Firebase MCP project directory setting deleted. New project root is: ${host.projectRoot || "unset"}`,
-        ),
-      );
-    }
-
-    if (!existsSync(dir)) return Promise.resolve(mcpError(`Directory '${dir}' does not exist.`));
-    if (!existsSync(join(dir, "firebase.json")))
-      return Promise.resolve(
-        mcpError(`Directory '${dir}' does not contain a 'firebase.json' file.`),
-      );
-    host.setProjectRoot(dir);
-    return Promise.resolve(toContent(`Firebase MCP project directory set to '${dir}'.`));
-  },
-);
diff --git a/src/mcp/tools/firestore/converter.ts b/src/mcp/tools/firestore/converter.ts
index 9d7990b2c94..7f20e45f77d 100644
--- a/src/mcp/tools/firestore/converter.ts
+++ b/src/mcp/tools/firestore/converter.ts
@@ -1,6 +1,61 @@
 import { FirestoreDocument, FirestoreValue } from "../../../gcp/firestore";
 import { logger } from "../../../logger";
 
+/**
+ * Takes an arbitrary value from a user and returns a FirestoreValue equivalent.
+ * @param {any} inputValue the JSON object input value.
+ * return FirestoreValue a firestorevalue object used in the Firestore API.
+ */
+export function convertInputToValue(inputValue: any): FirestoreValue {
+  if (inputValue === null) {
+    return { nullValue: null };
+  } else if (typeof inputValue === "boolean") {
+    return { booleanValue: inputValue };
+  } else if (typeof inputValue === "number") {
+    // Distinguish between integers and doubles
+    if (Number.isInteger(inputValue)) {
+      return { integerValue: inputValue.toString() }; // Represent integers as string for consistency with Firestore
+    } else {
+      return { doubleValue: inputValue };
+    }
+  } else if (typeof inputValue === "string") {
+    // This is a simplification. In a real-world scenario, you might want to
+    // check for specific string formats like timestamp, bytes, or referenceValue.
+    // For now, it defaults to stringValue.
+    return { stringValue: inputValue };
+  } else if (Array.isArray(inputValue)) {
+    const arrayValue: { values?: FirestoreValue[] } = {
+      values: inputValue.map((item) => convertInputToValue(item)),
+    };
+    return { arrayValue: arrayValue };
+  } else if (typeof inputValue === "object") {
+    // Check for LatLng structure
+    if (
+      inputValue.hasOwnProperty("latitude") &&
+      typeof inputValue.latitude === "number" &&
+      inputValue.hasOwnProperty("longitude") &&
+      typeof inputValue.longitude === "number"
+    ) {
+      return { geoPointValue: inputValue as { latitude: number; longitude: number } };
+    }
+
+    // Otherwise, treat as a MapValue
+    const mapValue: { fields?: Record<string, FirestoreValue> } = {
+      fields: {},
+    };
+    for (const key in inputValue) {
+      if (Object.prototype.hasOwnProperty.call(inputValue, key)) {
+        if (mapValue.fields) {
+          mapValue.fields[key] = convertInputToValue(inputValue[key]);
+        }
+      }
+    }
+    return { mapValue: mapValue };
+  }
+  // Fallback for unsupported types (e.g., undefined, functions, symbols)
+  return { nullValue: null };
+}
+
 /**
  * Converts a Firestore REST API Value object to a plain Javascript object,
  * applying special transformations for Reference and GeoPoint types, and
diff --git a/src/mcp/tools/firestore/delete_document.ts b/src/mcp/tools/firestore/delete_document.ts
index 355c86a137e..c554e733558 100644
--- a/src/mcp/tools/firestore/delete_document.ts
+++ b/src/mcp/tools/firestore/delete_document.ts
@@ -13,7 +13,7 @@ export const delete_document = tool(
       // TODO: Support configurable database
       // database: z
       //   .string()
-      //   .nullish()
+      //   .optional()
       //   .describe("Database id to use. Defaults to `(default)` if unspecified."),
       path: z
         .string()
@@ -32,17 +32,17 @@ export const delete_document = tool(
   },
   async ({ path }, { projectId }) => {
     // database ??= "(default)";
-    const { documents, missing } = await getDocuments(projectId!, [path]);
+    const { documents, missing } = await getDocuments(projectId, [path]);
     if (missing.length > 0 && documents && documents.length === 0) {
       return mcpError(`None of the specified documents were found in project '${projectId}'`);
     }
 
-    const firestoreDelete = new FirestoreDelete(projectId!, path, { databaseId: "(default)" });
+    const firestoreDelete = new FirestoreDelete(projectId, path, { databaseId: "(default)" });
 
     await firestoreDelete.execute();
 
     const { documents: postDeleteDocuments, missing: postDeleteMissing } = await getDocuments(
-      projectId!,
+      projectId,
       [path],
     );
     if (postDeleteMissing.length > 0 && postDeleteDocuments.length === 0) {
diff --git a/src/mcp/tools/firestore/get_documents.ts b/src/mcp/tools/firestore/get_documents.ts
index c125f191091..dedf81124ee 100644
--- a/src/mcp/tools/firestore/get_documents.ts
+++ b/src/mcp/tools/firestore/get_documents.ts
@@ -13,7 +13,7 @@ export const get_documents = tool(
       // TODO: Support configurable database
       // database: z
       //   .string()
-      //   .nullish()
+      //   .optional()
       //   .describe("Database id to use. Defaults to `(default)` if unspecified."),
       paths: z
         .array(z.string())
@@ -34,7 +34,7 @@ export const get_documents = tool(
     // database ??= "(default)";
     if (!paths || !paths.length) return mcpError("Must supply at least one document path.");
 
-    const { documents, missing } = await getDocuments(projectId!, paths);
+    const { documents, missing } = await getDocuments(projectId, paths);
     if (missing.length > 0 && documents && documents.length === 0) {
       return mcpError(`None of the specified documents were found in project '${projectId}'`);
     }
diff --git a/src/mcp/tools/firestore/get_rules.ts b/src/mcp/tools/firestore/get_rules.ts
deleted file mode 100644
index 34b62acce1e..00000000000
--- a/src/mcp/tools/firestore/get_rules.ts
+++ /dev/null
@@ -1,27 +0,0 @@
-import { z } from "zod";
-import { tool } from "../../tool.js";
-import { mcpError, toContent } from "../../util.js";
-import { getLatestRulesetName, getRulesetContent } from "../../../gcp/rules.js";
-
-export const get_rules = tool(
-  {
-    name: "get_rules",
-    description: "Retrieves the active Firestore security rules for the current project.",
-    inputSchema: z.object({}),
-    annotations: {
-      title: "Get Current Firestore Rules",
-      readOnlyHint: true,
-    },
-    _meta: {
-      requiresProject: true,
-      requiresAuth: true,
-    },
-  },
-  async (_, { projectId }) => {
-    const rulesetName = await getLatestRulesetName(projectId!, "cloud.firestore");
-    if (!rulesetName)
-      return mcpError(`No active Firestore rules were found in project '${projectId}'`);
-    const rules = await getRulesetContent(rulesetName);
-    return toContent(rules[0].content);
-  },
-);
diff --git a/src/mcp/tools/firestore/index.ts b/src/mcp/tools/firestore/index.ts
index 342e9bd0507..27faa5df68d 100644
--- a/src/mcp/tools/firestore/index.ts
+++ b/src/mcp/tools/firestore/index.ts
@@ -1,6 +1,15 @@
 import { delete_document } from "./delete_document";
 import { get_documents } from "./get_documents";
-import { get_rules } from "./get_rules";
 import { list_collections } from "./list_collections";
+import { query_collection } from "./query_collection";
+import { validateRulesTool } from "../rules/validate_rules";
+import { getRulesTool } from "../rules/get_rules";
 
-export const firestoreTools = [delete_document, get_documents, get_rules, list_collections];
+export const firestoreTools = [
+  delete_document,
+  get_documents,
+  list_collections,
+  query_collection,
+  getRulesTool("Firestore", "cloud.firestore"),
+  validateRulesTool("Firestore"),
+];
diff --git a/src/mcp/tools/firestore/list_collections.ts b/src/mcp/tools/firestore/list_collections.ts
index 371d0e884c2..ab821879fa4 100644
--- a/src/mcp/tools/firestore/list_collections.ts
+++ b/src/mcp/tools/firestore/list_collections.ts
@@ -13,14 +13,8 @@ export const list_collections = tool(
       // TODO: support multiple databases
       // database: z
       //   .string()
-      //   .nullish()
+      //   .optional()
       //   .describe("Database id to use. Defaults to `(default)` if unspecified."),
-      document_path: z
-        .string()
-        .nullish()
-        .describe(
-          "a parent document to list subcollections under. only needed for subcollections, omit to list top-level collections",
-        ),
     }),
     annotations: {
       title: "List Firestore collections",
diff --git a/src/mcp/tools/firestore/query_collection.ts b/src/mcp/tools/firestore/query_collection.ts
new file mode 100644
index 00000000000..bd7947783c6
--- /dev/null
+++ b/src/mcp/tools/firestore/query_collection.ts
@@ -0,0 +1,142 @@
+import { z } from "zod";
+import { tool } from "../../tool.js";
+import { mcpError, toContent } from "../../util.js";
+import { queryCollection, StructuredQuery } from "../../../gcp/firestore.js";
+import { convertInputToValue, firestoreDocumentToJson } from "./converter.js";
+
+export const query_collection = tool(
+  {
+    name: "query_collection",
+    description:
+      "Retrieves one or more Firestore documents from a collection is a database in the current project by a collection with a full document path. Use this if you know the exact path of a collection and the filtering clause you would like for the document.",
+    inputSchema: z.object({
+      // TODO: Support configurable database
+      // database: z
+      //   .string()
+      //   .optional()
+      //   .describe("Database id to use. Defaults to `(default)` if unspecified."),
+      collection_path: z
+        .string()
+        .describe(
+          "A collection path (e.g. `collectionName/` or `parentCollection/parentDocument/collectionName`)",
+        ),
+      filters: z
+        .object({
+          compare_value: z
+            .object({
+              string_value: z.string().optional().describe("The string value to compare against."),
+              boolean_value: z
+                .string()
+                .optional()
+                .describe("The boolean value to compare against."),
+              string_array_value: z
+                .array(z.string())
+                .optional()
+                .describe("The string value to compare against."),
+              integer_value: z
+                .number()
+                .optional()
+                .describe("The integer value to compare against."),
+              double_value: z.number().optional().describe("The double value to compare against."),
+            })
+            .describe("One and only one value may be specified per filters object."),
+          field: z.string().describe("the field searching against"),
+          op: z
+            .enum([
+              "OPERATOR_UNSPECIFIED",
+              "LESS_THAN",
+              "LESS_THAN_OR_EQUAL",
+              "GREATER_THAN",
+              "GREATER_THAN_OR_EQUAL",
+              "EQUAL",
+              "NOT_EQUAL",
+              "ARRAY_CONTAINS",
+              "ARRAY_CONTAINS_ANY",
+              "IN",
+              "NOT_IN",
+            ])
+            .describe("the equality evaluator to use"),
+        })
+        .array()
+        .describe("the multiple filters to use in querying against the existing collection."),
+      order: z
+        .object({
+          orderBy: z.string().describe("the field to order by"),
+          orderByDirection: z
+            .enum(["ASCENDING", "DESCENDING"])
+            .describe("the direction to order values"),
+        })
+        .optional()
+        .describe(
+          "Specifies the field and direction to order the results. If not provided, the order is undefined.",
+        ),
+      limit: z
+        .number()
+        .describe("The maximum amount of records to return. Default is 10.")
+        .optional(),
+    }),
+    annotations: {
+      title: "Query Firestore collection",
+      readOnlyHint: true,
+    },
+    _meta: {
+      requiresAuth: true,
+      requiresProject: true,
+    },
+  },
+  async ({ collection_path, filters, order, limit }, { projectId }) => {
+    // database ??= "(default)";
+
+    if (!collection_path || !collection_path.length)
+      return mcpError("Must supply at least one collection path.");
+
+    const structuredQuery: StructuredQuery = {
+      from: [{ collectionId: collection_path, allDescendants: false }],
+    };
+    if (filters) {
+      structuredQuery.where = {
+        compositeFilter: {
+          op: "AND",
+          filters: filters.map((f) => {
+            if (
+              f.compare_value.boolean_value &&
+              f.compare_value.double_value &&
+              f.compare_value.integer_value &&
+              f.compare_value.string_array_value &&
+              f.compare_value.string_value
+            ) {
+              throw mcpError("One and only one value may be specified per filters object.");
+            }
+            const out = Object.entries(f.compare_value).filter(([, value]) => {
+              return value !== null && value !== undefined;
+            });
+            return {
+              fieldFilter: {
+                field: { fieldPath: f.field },
+                op: f.op,
+                value: convertInputToValue(out[0][1]),
+              },
+            };
+          }),
+        },
+      };
+    }
+    if (order) {
+      structuredQuery.orderBy = [
+        {
+          field: { fieldPath: order.orderBy },
+          direction: order.orderByDirection,
+        },
+      ];
+    }
+    structuredQuery.limit = limit ? limit : 10;
+
+    const { documents } = await queryCollection(projectId, structuredQuery);
+
+    const docs = documents.map(firestoreDocumentToJson);
+
+    const docsContent = toContent(docs);
+
+    return docsContent;
+  },
+);
diff --git a/src/mcp/tools/index.ts b/src/mcp/tools/index.ts
index f97321e4e16..332a08838a6 100644
--- a/src/mcp/tools/index.ts
+++ b/src/mcp/tools/index.ts
@@ -3,18 +3,17 @@ import { ServerFeature } from "../types.js";
 import { authTools } from "./auth/index.js";
 import { dataconnectTools } from "./dataconnect/index.js";
 import { firestoreTools } from "./firestore/index.js";
-import { directoryTools } from "./directory/index.js";
 import { coreTools } from "./core/index.js";
 import { storageTools } from "./storage/index.js";
+import { messagingTools } from "./messaging/index.js";
+import { remoteConfigTools } from "./remoteconfig/index.js";
+import { crashlyticsTools } from "./crashlytics/index.js";
+import { appHostingTools } from "./apphosting/index.js";
 
 /** availableTools returns the list of MCP tools available given the server flags */
-export function availableTools(fixedRoot: boolean, activeFeatures?: ServerFeature[]): ServerTool[] {
+export function availableTools(activeFeatures?: ServerFeature[]): ServerTool[] {
   // Core tools are always present.
-  const toolDefs: ServerTool[] = addPrefixToToolName("firebase_", coreTools);
-  if (!fixedRoot) {
-    // Present if the root is not fixed.
-    toolDefs.push(...directoryTools);
-  }
+  const toolDefs: ServerTool[] = addFeaturePrefix("firebase", coreTools);
   if (!activeFeatures?.length) {
     activeFeatures = Object.keys(tools) as ServerFeature[];
   }
@@ -25,18 +24,46 @@ export function availableTools(fixedRoot: boolean, activeFeatures?: ServerFeatur
 }
 
 const tools: Record<ServerFeature, ServerTool[]> = {
-  firestore: addPrefixToToolName("firestore_", firestoreTools),
-  auth: addPrefixToToolName("auth_", authTools),
-  dataconnect: addPrefixToToolName("dataconnect_", dataconnectTools),
-  storage: addPrefixToToolName("storage_", storageTools),
+  firestore: addFeaturePrefix("firestore", firestoreTools),
+  auth: addFeaturePrefix("auth", authTools),
+  dataconnect: addFeaturePrefix("dataconnect", dataconnectTools),
+  storage: addFeaturePrefix("storage", storageTools),
+  messaging: addFeaturePrefix("messaging", messagingTools),
+  remoteconfig: addFeaturePrefix("remoteconfig", remoteConfigTools),
+  crashlytics: addFeaturePrefix("crashlytics", crashlyticsTools),
+  apphosting: addFeaturePrefix("apphosting", appHostingTools),
 };
 
-function addPrefixToToolName(prefix: string, tools: ServerTool[]): ServerTool[] {
+function addFeaturePrefix(feature: string, tools: ServerTool[]): ServerTool[] {
   return tools.map((tool) => ({
     ...tool,
     mcp: {
       ...tool.mcp,
-      name: `${prefix}${tool.mcp.name}`,
+      name: `${feature}_${tool.mcp.name}`,
+      _meta: {
+        ...tool.mcp._meta,
+        feature,
+      },
     },
   }));
 }
+
+/**
+ * Generates a markdown table of all available tools and their descriptions.
+ * This is used for generating documentation.
+ */
+export function markdownDocsOfTools(): string {
+  const allTools = availableTools([]);
+  let doc = `
+| Tool Name | Feature Group | Description |
+| --------- | ------------- | ----------- |`;
+  for (const tool of allTools) {
+    let feature = tool.mcp?._meta?.feature || "";
+    if (feature === "firebase") {
+      feature = "core";
+    }
+    doc += `
+| ${tool.mcp.name} | ${feature} | ${tool.mcp?.description || ""} |`;
+  }
+  return doc;
+}
diff --git a/src/mcp/tools/messaging/index.ts b/src/mcp/tools/messaging/index.ts
new file mode 100644
index 00000000000..0112af3d480
--- /dev/null
+++ b/src/mcp/tools/messaging/index.ts
@@ -0,0 +1,4 @@
+import { ServerTool } from "../../tool.js";
+import { send_message } from "./send_message.js";
+
+export const messagingTools: ServerTool[] = [send_message];
diff --git a/src/mcp/tools/messaging/send_message.ts b/src/mcp/tools/messaging/send_message.ts
new file mode 100644
index 00000000000..9f6837024a1
--- /dev/null
+++ b/src/mcp/tools/messaging/send_message.ts
@@ -0,0 +1,54 @@
+import { z } from "zod";
+import { tool } from "../../tool.js";
+import { mcpError, toContent } from "../../util.js";
+import { sendFcmMessage } from "../../../messaging/sendMessage.js";
+
+export const send_message = tool(
+  {
+    name: "send_message",
+    description:
+      "Sends a message to a Firebase Cloud Messaging registration token or topic. ONLY ONE of `registration_token` or `topic` may be supplied in a specific call.",
+    inputSchema: z.object({
+      registration_token: z
+        .string()
+        .optional()
+        .describe(
+          "A specific device registration token for delivery. Supply either this or topic.",
+        ),
+      topic: z
+        .string()
+        .optional()
+        .describe("A topic name for delivery. Supply either this or registration_token."),
+      title: z.string().optional().describe("The title of the push notification message."),
+      body: z.string().optional().describe("The body of the push notification  message."),
+      image: z
+        .string()
+        .optional()
+        .describe(
+          "The URL of an image that will be displayed with the notification. JPEG, PNG, BMP have full support across platforms. Animated GIF and video only work on iOS. WebP and HEIF have varying levels of support across platforms and platform versions.",
+        ),
+    }),
+    annotations: {
+      title: "Send FCM Message",
+    },
+    _meta: {
+      requiresAuth: true,
+      requiresProject: true,
+    },
+  },
+  async ({ registration_token, topic, title, body }, { projectId }) => {
+    if (!registration_token && !topic) {
+      return mcpError(
+        "Must supply either a `registration_token` or `topic` parameter to `send_message`.",
+      );
+    }
+    if (registration_token && topic) {
+      return mcpError(
+        "Cannot supply both `registration_token` and `topic` in a single `send_message` request.",
+      );
+    }
+    return toContent(
+      await sendFcmMessage(projectId, { token: registration_token, topic, title, body }),
+    );
+  },
+);
diff --git a/src/mcp/tools/remoteconfig/get_template.ts b/src/mcp/tools/remoteconfig/get_template.ts
new file mode 100644
index 00000000000..43289340740
--- /dev/null
+++ b/src/mcp/tools/remoteconfig/get_template.ts
@@ -0,0 +1,30 @@
+import { z } from "zod";
+import { tool } from "../../tool.js";
+import { toContent } from "../../util.js";
+import { getTemplate } from "../../../remoteconfig/get.js";
+
+export const get_template = tool(
+  {
+    name: "get_template",
+    description: "Retrieves a remote config template for the project",
+    inputSchema: z.object({
+      version_number: z
+        .string()
+        .optional()
+        .describe(
+          "The version number of the template to retrieve. If not provided, retrieves the active template.",
+        ),
+    }),
+    annotations: {
+      title: "Get Remote Config template",
+      readOnlyHint: true,
+    },
+    _meta: {
+      requiresAuth: true,
+      requiresProject: true,
+    },
+  },
+  async ({ version_number }, { projectId }) => {
+    return toContent(await getTemplate(projectId, version_number));
+  },
+);
diff --git a/src/mcp/tools/remoteconfig/index.ts b/src/mcp/tools/remoteconfig/index.ts
new file mode 100644
index 00000000000..1ce56f79be1
--- /dev/null
+++ b/src/mcp/tools/remoteconfig/index.ts
@@ -0,0 +1,6 @@
+import { ServerTool } from "../../tool.js";
+import { get_template } from "./get_template.js";
+import { rollback_template } from "./rollback_template.js";
+import { publish_template } from "./publish_template.js";
+
+export const remoteConfigTools: ServerTool[] = [get_template, publish_template, rollback_template];
diff --git a/src/mcp/tools/remoteconfig/publish_template.ts b/src/mcp/tools/remoteconfig/publish_template.ts
new file mode 100644
index 00000000000..c72a088f3a9
--- /dev/null
+++ b/src/mcp/tools/remoteconfig/publish_template.ts
@@ -0,0 +1,38 @@
+import { z } from "zod";
+import { tool } from "../../tool.js";
+import { mcpError, toContent } from "../../util.js";
+import { publishTemplate } from "../../../remoteconfig/publish.js";
+import { RemoteConfigTemplate } from "../../../remoteconfig/interfaces.js";
+
+export const publish_template = tool(
+  {
+    name: "publish_template",
+    description: "Publishes a new remote config template for the project",
+    inputSchema: z.object({
+      template: z.object({}).describe("The Remote Config template object to publish."),
+      force: z
+        .boolean()
+        .optional()
+        .describe(
+          "If true, the publish will bypass ETag validation and overwrite the current template. Defaults to false if not provided.",
+        ),
+    }),
+    annotations: {
+      title: "Publish Remote Config template",
+      readOnlyHint: false,
+    },
+    _meta: {
+      requiresAuth: true,
+      requiresProject: true,
+    },
+  },
+  async ({ template, force }, { projectId }) => {
+    if (template === undefined) {
+      return mcpError(`No template specified in the publish requests`);
+    }
+    if (force === undefined) {
+      return toContent(await publishTemplate(projectId, template as RemoteConfigTemplate));
+    }
+    return toContent(await publishTemplate(projectId, template as RemoteConfigTemplate, { force }));
+  },
+);
diff --git a/src/mcp/tools/remoteconfig/rollback_template.ts b/src/mcp/tools/remoteconfig/rollback_template.ts
new file mode 100644
index 00000000000..24a33479104
--- /dev/null
+++ b/src/mcp/tools/remoteconfig/rollback_template.ts
@@ -0,0 +1,30 @@
+import { z } from "zod";
+import { tool } from "../../tool.js";
+import { mcpError, toContent } from "../../util.js";
+import { rollbackTemplate } from "../../../remoteconfig/rollback.js";
+
+export const rollback_template = tool(
+  {
+    name: "rollback_template",
+    description: "Rollback to a specific version of Remote Config template for a project",
+    inputSchema: z.object({
+      version_number: z
+        .number()
+        .describe("The version number to roll back to. This field is required."),
+    }),
+    annotations: {
+      title: "Rollback remote config template",
+      readOnlyHint: false,
+    },
+    _meta: {
+      requiresAuth: true,
+      requiresProject: true,
+    },
+  },
+  async ({ version_number }, { projectId }) => {
+    if (version_number === undefined) {
+      return mcpError(`No version number specified in the rollback requests`);
+    }
+    return toContent(await rollbackTemplate(projectId, version_number!));
+  },
+);
diff --git a/src/mcp/tools/rules/get_rules.ts b/src/mcp/tools/rules/get_rules.ts
new file mode 100644
index 00000000000..034e2aab1bf
--- /dev/null
+++ b/src/mcp/tools/rules/get_rules.ts
@@ -0,0 +1,29 @@
+import { z } from "zod";
+import { tool } from "../../tool.js";
+import { mcpError, toContent } from "../../util.js";
+import { getLatestRulesetName, getRulesetContent } from "../../../gcp/rules.js";
+
+export function getRulesTool(productName: string, releaseName: string) {
+  return tool(
+    {
+      name: "get_rules",
+      description: `Retrieves the active ${productName} security rules for the current project.`,
+      inputSchema: z.object({}),
+      annotations: {
+        title: `Get Current ${productName} Rules`,
+        readOnlyHint: true,
+      },
+      _meta: {
+        requiresProject: true,
+        requiresAuth: true,
+      },
+    },
+    async (_, { projectId }) => {
+      const rulesetName = await getLatestRulesetName(projectId, releaseName);
+      if (!rulesetName)
+        return mcpError(`No active Firestore rules were found in project '${projectId}'`);
+      const rules = await getRulesetContent(rulesetName);
+      return toContent(rules[0].content);
+    },
+  );
+}
diff --git a/src/mcp/tools/rules/validate_rules.ts b/src/mcp/tools/rules/validate_rules.ts
new file mode 100644
index 00000000000..0bca88e374f
--- /dev/null
+++ b/src/mcp/tools/rules/validate_rules.ts
@@ -0,0 +1,140 @@
+import { z } from "zod";
+import { tool } from "../../tool.js";
+import { mcpError, toContent } from "../../util.js";
+import { testRuleset } from "../../../gcp/rules.js";
+import { resolve } from "path";
+
+// Define interfaces for clarity, based on typical lint/validation issue structures.
+// These could potentially be imported if they are exported from gcp/rules.js or a shared types file.
+interface SourcePosition {
+  fileName?: string;
+  line?: number; // 1-based
+  column?: number; // 1-based
+  currentOffset?: number; // 0-based, inclusive start of error token
+  endOffset?: number; // 0-based, exclusive end of error token
+}
+
+interface Issue {
+  sourcePosition: SourcePosition;
+  description: string;
+  severity: string; // e.g., "ERROR"
+}
+
+/**
+ * Formats validation issues into a human-readable string with code snippets and carets.
+ * @param issues Array of issues from the ruleset validation.
+ * @param rulesSource The original source content of the rules file.
+ * @returns A string with formatted issues.
+ */
+function formatRulesetIssues(issues: Issue[], rulesSource: string): string {
+  const sourceLines = rulesSource.split("\n");
+  const formattedOutput: string[] = [];
+
+  for (const issue of issues) {
+    const { sourcePosition, description, severity } = issue;
+
+    let issueString = `${severity}: ${description} [Ln ${sourcePosition.line}, Col ${sourcePosition.column}]`;
+
+    if (sourcePosition.line) {
+      const lineIndex = sourcePosition.line - 1; // 0-based index
+      if (lineIndex >= 0 && lineIndex < sourceLines.length) {
+        const errorLine = sourceLines[lineIndex];
+        issueString += `\n\`\`\`\n${errorLine}`;
+
+        // Add carets if column, currentOffset, and endOffset are available
+        if (
+          sourcePosition.column &&
+          sourcePosition.currentOffset &&
+          sourcePosition.endOffset &&
+          sourcePosition.column > 0 && // Column should be positive
+          sourcePosition.endOffset > sourcePosition.currentOffset // endOffset should be greater
+        ) {
+          const startColumnOnLine = sourcePosition.column - 1; // 0-based start column for carets
+          const errorTokenLength = sourcePosition.endOffset - sourcePosition.currentOffset;
+
+          // Ensure startColumnOnLine is not negative and errorTokenLength is positive
+          // Also, ensure startColumnOnLine is within the line length (or reasonably close for safety)
+          if (
+            startColumnOnLine >= 0 &&
+            errorTokenLength > 0 &&
+            startColumnOnLine <= errorLine.length
+          ) {
+            const padding = " ".repeat(startColumnOnLine);
+            const carets = "^".repeat(errorTokenLength);
+            issueString += `\n${padding}${carets}\n\`\`\``;
+          }
+        }
+      }
+    }
+    formattedOutput.push(issueString);
+  }
+  return formattedOutput.join("\n\n"); // Separate multiple issues with a blank line
+}
+
+export function validateRulesTool(productName: string) {
+  return tool(
+    {
+      name: "validate_rules",
+      description: `Checks the provided ${productName} Rules source for syntax and validation errors. Provide EITHER the source code to validate OR a path to a source file.`,
+      inputSchema: z.object({
+        source: z
+          .string()
+          .optional()
+          .describe("the rules source code to check. provide either this OR a path"),
+        source_file: z
+          .string()
+          .optional()
+          .describe(
+            "a file path, relative to the project root, to a file containing the rules source you want to validate. provide this OR source, not both",
+          ),
+      }),
+      annotations: {
+        title: `Validate ${productName} Rules`,
+        readOnlyHint: true,
+      },
+      _meta: {
+        requiresProject: true,
+        requiresAuth: true,
+      },
+    },
+    async ({ source, source_file }, { projectId, config, host }) => {
+      if (source && source_file) {
+        return mcpError("Must supply `source` or `source_file`, not both.");
+      }
+
+      let rulesSourceContent: string;
+      if (source_file) {
+        try {
+          const filePath = resolve(source_file, host.cachedProjectRoot!);
+          if (filePath.includes("../"))
+            return mcpError("Cannot read files outside of the project directory.");
+          rulesSourceContent = config.readProjectFile(source_file);
+        } catch (e: any) {
+          return mcpError(`Failed to read source_file '${source_file}': ${e.message}`);
+        }
+      } else if (source) {
+        rulesSourceContent = source;
+      } else {
+        // If neither source nor source_file is provided, default to empty string for validation.
+        // testRuleset might still return general errors not tied to specific lines.
+        rulesSourceContent = "";
+      }
+
+      const result = await testRuleset(projectId, [
+        // The name "firestore.rules" is a convention for testRuleset,
+        // actual fileName from issues will be used in formatting.
+        { name: "test.rules", content: rulesSourceContent },
+      ]);
+
+      if (result.body?.issues?.length) {
+        // Cast to our Issue[] type; structure should be compatible.
+        const issues = result.body.issues as unknown as Issue[];
+        let out = `Found ${issues.length} issues in rules source:\n\n`;
+        out += formatRulesetIssues(issues, rulesSourceContent);
+        return toContent(out);
+      }
+
+      return toContent("OK: No errors detected.");
+    },
+  );
+}
diff --git a/src/mcp/tools/storage/get_download_url.ts b/src/mcp/tools/storage/get_download_url.ts
index 87970d8e1ef..cfb001126cd 100644
--- a/src/mcp/tools/storage/get_download_url.ts
+++ b/src/mcp/tools/storage/get_download_url.ts
@@ -8,13 +8,18 @@ export const get_object_download_url = tool(
     name: "get_object_download_url",
     description: "Retrieves the download URL for an object in Firebase Storage.",
     inputSchema: z.object({
-      bucket: z.string().nullish().describe("The bucket name in Firebase Storage."),
-      objectPath: z
+      bucket: z
+        .string()
+        .optional()
+        .describe(
+          "The bucket name in Firebase Storage. If not provided, defaults to the project's default bucket (e.g., `{projectid}.firebasestorage.app`).",
+        ),
+      object_path: z
         .string()
         .describe("The path to the object in Firebase storage without the bucket name attached"),
     }),
     annotations: {
-      title: "Get the download url for an obejct in Firebase Storage.",
+      title: "Get Storage Object Download URL",
       readOnlyHint: true,
     },
     _meta: {
@@ -22,11 +27,11 @@ export const get_object_download_url = tool(
       requiresAuth: true,
     },
   },
-  async ({ bucket, objectPath }, { projectId }) => {
+  async ({ bucket, object_path }, { projectId }) => {
     if (!bucket) {
       bucket = `${projectId}.firebasestorage.app`;
     }
-    const downloadUrl = await getDownloadUrl(bucket, objectPath);
+    const downloadUrl = await getDownloadUrl(bucket, object_path);
     return toContent(downloadUrl);
   },
 );
diff --git a/src/mcp/tools/storage/get_rules.ts b/src/mcp/tools/storage/get_rules.ts
index b120da14741..d426d784d36 100644
--- a/src/mcp/tools/storage/get_rules.ts
+++ b/src/mcp/tools/storage/get_rules.ts
@@ -18,7 +18,7 @@ export const get_rules = tool(
     },
   },
   async (_, { projectId }) => {
-    const rulesetName = await getLatestRulesetName(projectId!, "firebase.storage");
+    const rulesetName = await getLatestRulesetName(projectId, "firebase.storage");
     if (!rulesetName)
       return mcpError(`No active Firebase Storage rules were found in project '${projectId}'`);
     const rules = await getRulesetContent(rulesetName);
diff --git a/src/mcp/tools/storage/index.ts b/src/mcp/tools/storage/index.ts
index a2b06dfc219..e8922df7b8b 100644
--- a/src/mcp/tools/storage/index.ts
+++ b/src/mcp/tools/storage/index.ts
@@ -1,4 +1,9 @@
+import { getRulesTool } from "../rules/get_rules";
+import { validateRulesTool } from "../rules/validate_rules";
 import { get_object_download_url } from "./get_download_url";
-import { get_rules } from "./get_rules";
 
-export const storageTools = [get_rules, get_object_download_url];
+export const storageTools = [
+  getRulesTool("Storage", "firebase.storage"),
+  validateRulesTool("Storage"),
+  get_object_download_url,
+];
diff --git a/src/mcp/types.ts b/src/mcp/types.ts
index 3217e6a557c..784137b4ab4 100644
--- a/src/mcp/types.ts
+++ b/src/mcp/types.ts
@@ -1,2 +1,16 @@
-export const SERVER_FEATURES = ["firestore", "storage", "dataconnect", "auth"] as const;
+export const SERVER_FEATURES = [
+  "firestore",
+  "storage",
+  "dataconnect",
+  "auth",
+  "messaging",
+  "remoteconfig",
+  "crashlytics",
+  "apphosting",
+] as const;
 export type ServerFeature = (typeof SERVER_FEATURES)[number];
+
+export interface ClientConfig {
+  /** The current project root directory for this client. */
+  projectRoot?: string | null;
+}
diff --git a/src/mcp/util.test.ts b/src/mcp/util.test.ts
new file mode 100644
index 00000000000..06b3cac1a2a
--- /dev/null
+++ b/src/mcp/util.test.ts
@@ -0,0 +1,475 @@
+import { expect } from "chai";
+import { cleanSchema } from "./util";
+
+interface TestCase {
+  desc: string;
+  input: Record<string, any>;
+  expected: Record<string, any>;
+}
+
+const testCases: TestCase[] = [
+  {
+    desc: "should remove $schema property",
+    input: {
+      $schema: "http://json-schema.org/draft-07/schema#",
+      type: "object",
+      properties: { name: { type: "string" } },
+    },
+    expected: {
+      type: "object",
+      properties: { name: { type: "string" } },
+    },
+  },
+  {
+    desc: "should remove additionalProperties field",
+    input: {
+      type: "object",
+      properties: { name: { type: "string" } },
+      additionalProperties: false,
+    },
+    expected: {
+      type: "object",
+      properties: { name: { type: "string" } },
+    },
+  },
+  {
+    desc: "should remove additionalProperties from nested objects",
+    input: {
+      type: "object",
+      properties: {
+        user: {
+          type: "object",
+          properties: { id: { type: "number" } },
+          additionalProperties: true,
+        },
+        meta: {
+          type: "object",
+          additionalProperties: { type: "string" },
+        },
+      },
+      additionalProperties: false,
+    },
+    expected: {
+      type: "object",
+      properties: {
+        user: {
+          type: "object",
+          properties: { id: { type: "number" } },
+        },
+        meta: {
+          type: "object",
+        },
+      },
+    },
+  },
+  {
+    desc: "should remove top-level array type (string)",
+    input: { type: "array", items: { type: "string" } },
+    expected: {},
+  },
+  {
+    desc: "should remove top-level array type (array of types including array)",
+    input: { type: ["array", "string"], items: { type: "string" } }, // Will become anyOf: [{type: "string"}], then simplified to type: "string" at root
+    expected: { type: "string", items: { type: "string" } },
+  },
+  {
+    desc: "should remove top-level array type (array of types including array and null)",
+    input: { type: ["array", "null"], items: { type: "string" } },
+    expected: {},
+  },
+  {
+    desc: "should remove top-level null type",
+    input: { type: "null" },
+    expected: {},
+  },
+  {
+    desc: "should KEEP array type in properties",
+    input: {
+      type: "object",
+      properties: {
+        tags: { type: "array", items: { type: "string" } },
+        name: { type: "string" },
+      },
+    },
+    expected: {
+      type: "object",
+      properties: {
+        tags: { type: "array", items: { type: "string" } },
+        name: { type: "string" },
+      },
+    },
+  },
+  {
+    desc: "should remove null type from properties",
+    input: {
+      type: "object",
+      properties: {
+        optionalField: { type: "null" },
+        name: { type: "string" },
+      },
+    },
+    expected: {
+      type: "object",
+      properties: { name: { type: "string" } },
+    },
+  },
+  {
+    desc: "should convert type: ['string', 'null', 'array'] to anyOf: [{type: 'string'}, {type: 'array'}] in properties",
+    input: {
+      type: "object",
+      properties: {
+        mixed: { type: ["string", "null", "array"] },
+      },
+    },
+    expected: {
+      type: "object",
+      properties: {
+        mixed: { anyOf: [{ type: "string" }, { type: "array" }] },
+      },
+    },
+  },
+  {
+    desc: "should convert type: ['string', 'number', 'null', 'array'] to anyOf in properties",
+    input: {
+      type: "object",
+      properties: {
+        mixed: { type: ["string", "number", "null", "array"] },
+      },
+    },
+    expected: {
+      type: "object",
+      properties: {
+        mixed: { anyOf: [{ type: "string" }, { type: "number" }, { type: "array" }] },
+      },
+    },
+  },
+  {
+    desc: "should simplify type: ['string', 'null'] to type: 'string' in properties",
+    input: {
+      type: "object",
+      properties: {
+        simpleMixed: { type: ["string", "null"] },
+      },
+    },
+    expected: {
+      type: "object",
+      properties: {
+        simpleMixed: { type: "string" },
+      },
+    },
+  },
+  {
+    desc: "should remove property if its type array becomes empty after filtering (e.g. only null)",
+    input: {
+      type: "object",
+      properties: {
+        onlyNull: { type: ["null"] },
+        name: { type: "string" },
+      },
+    },
+    expected: {
+      type: "object",
+      properties: { name: { type: "string" } },
+    },
+  },
+  {
+    desc: "should keep property if its type array contains only 'array' (not root) and simplify",
+    input: {
+      type: "object",
+      properties: {
+        onlyArray: { type: ["array", "null"] },
+        name: { type: "string" },
+      },
+    },
+    expected: {
+      type: "object",
+      properties: {
+        onlyArray: { type: "array" },
+        name: { type: "string" },
+      },
+    },
+  },
+  {
+    desc: "should handle nested objects and clean them (arrays kept in nested, type arrays become anyOf or simplified)",
+    input: {
+      type: "object",
+      properties: {
+        user: {
+          type: "object",
+          properties: {
+            id: { type: "number" },
+            tags: { type: "array", items: { type: "string" } },
+            status: { type: ["string", "integer", "null"] },
+            maybeName: { type: ["string", "null"] },
+          },
+        },
+      },
+    },
+    expected: {
+      type: "object",
+      properties: {
+        user: {
+          type: "object",
+          properties: {
+            id: { type: "number" },
+            tags: { type: "array", items: { type: "string" } },
+            status: { anyOf: [{ type: "string" }, { type: "integer" }] },
+            maybeName: { type: "string" },
+          },
+        },
+      },
+    },
+  },
+  {
+    desc: "should remove items if its schema becomes null",
+    input: {
+      type: "object",
+      properties: {
+        someObjectWithItems: {
+          type: "object",
+          items: { type: "null" },
+        },
+      },
+    },
+    expected: {
+      type: "object",
+      properties: {
+        someObjectWithItems: {
+          type: "object",
+        },
+      },
+    },
+  },
+  {
+    desc: "should clean definitions ($defs), convert type arrays to anyOf/simplified",
+    input: {
+      type: "object",
+      properties: {
+        myDef: { $ref: "#/$defs/invalidDef" },
+        myValidDef: { $ref: "#/$defs/validDefWithArray" },
+        myComplexDef: { $ref: "#/$defs/complexDef" },
+      },
+      $defs: {
+        invalidDef: { type: "null" },
+        validDef: { type: "string" },
+        validDefWithArray: { type: "array", items: { type: "number" } },
+        complexDef: { type: ["boolean", "string", "null"] },
+      },
+    },
+    expected: {
+      type: "object",
+      properties: {
+        myDef: { $ref: "#/$defs/invalidDef" },
+        myValidDef: { $ref: "#/$defs/validDefWithArray" },
+        myComplexDef: { $ref: "#/$defs/complexDef" },
+      },
+      $defs: {
+        validDef: { type: "string" },
+        validDefWithArray: { type: "array", items: { type: "number" } },
+        complexDef: { anyOf: [{ type: "boolean" }, { type: "string" }] },
+      },
+    },
+  },
+  {
+    desc: "should remove $defs if all definitions become invalid (e.g. all null)",
+    input: {
+      type: "object",
+      $defs: {
+        invalidDef1: { type: "null" },
+        invalidDef2: { type: "null" },
+      },
+    },
+    expected: {
+      type: "object",
+    },
+  },
+  {
+    desc: "should clean schema arrays (anyOf, allOf, oneOf), keep nested arrays, convert internal type arrays",
+    input: {
+      anyOf: [
+        { type: "string" },
+        { type: "array", items: { type: "number" } },
+        { type: "null" },
+        { type: ["integer", "boolean", "null"] },
+      ],
+      allOf: [{ type: "number" }],
+      oneOf: [{ type: "boolean" }, { type: ["null", "array"] }],
+    },
+    expected: {
+      anyOf: [
+        { type: "string" },
+        { type: "array", items: { type: "number" } },
+        { anyOf: [{ type: "integer" }, { type: "boolean" }] },
+      ],
+      allOf: [{ type: "number" }],
+      oneOf: [{ type: "boolean" }, { type: "array" }],
+    },
+  },
+  {
+    desc: "should remove schema array keywords if their arrays become empty (e.g. all null)",
+    input: {
+      anyOf: [{ type: "null" }, { type: "null" }],
+      description: "test",
+    },
+    expected: {
+      description: "test",
+    },
+  },
+  {
+    desc: "should return an empty object if the entire schema is just { type: 'array' }",
+    input: { type: "array" },
+    expected: {},
+  },
+  {
+    desc: "should return an empty object if the entire schema is just { type: 'null' }",
+    input: { type: "null" },
+    expected: {},
+  },
+  {
+    desc: "should return an empty object if the entire schema is { type: ['null', 'array'] }",
+    input: { type: ["null", "array"] },
+    expected: {},
+  },
+  {
+    desc: "should not modify a schema that is already clean (with nested array and anyOf)",
+    input: {
+      type: "object",
+      properties: {
+        name: { type: "string" },
+        age: { type: "integer" },
+        scores: { type: "array", items: { type: "number" } },
+        choice: { anyOf: [{ type: "string" }, { type: "boolean" }] },
+      },
+      required: ["name"],
+    },
+    expected: {
+      type: "object",
+      properties: {
+        name: { type: "string" },
+        age: { type: "integer" },
+        scores: { type: "array", items: { type: "number" } },
+        choice: { anyOf: [{ type: "string" }, { type: "boolean" }] },
+      },
+      required: ["name"],
+    },
+  },
+  {
+    desc: "should handle deeply nested structures with various cleaning needs (arrays kept if not root, type arrays to anyOf)",
+    input: {
+      $schema: "http://json-schema.org/draft-07/schema#",
+      title: "Complex Test",
+      type: "object", // Top level type array: ["object", "null"] -> type: "object"
+      additionalProperties: false,
+      properties: {
+        validProp: { type: "string" },
+        propToBeKept: { type: "array", items: { type: "number" } },
+        objectWithMixedTypes: {
+          type: "object",
+          additionalProperties: true,
+          properties: {
+            subPropString: { type: "string" },
+            subPropNull: { type: "null" },
+            subPropArrayType: { type: ["integer", "null", "array", "string"] },
+          },
+        },
+        anotherArrayProp: { type: "array", items: { type: "boolean" } },
+      },
+      $defs: {
+        reusableInvalid: { type: "null" },
+        reusableValid: {
+          type: "object",
+          additionalProperties: { type: "string" },
+          properties: {
+            detail: { type: "string" },
+            unwantedList: { type: "array", items: { type: "string" } },
+            statusOptions: { type: ["number", "string", "null"] },
+          },
+        },
+        toBeEmptyDef: { type: "null" },
+      },
+      anyOf: [
+        // This anyOf is at the root level of the input schema, but its subschemas are not "root" for cleaning
+        { type: "string" },
+        { type: "array", items: { type: "object" } }, // This array is fine as it's not top-level schema type
+        { $ref: "#/$defs/reusableInvalid" },
+        { type: ["boolean", "null", "integer"] },
+      ],
+    },
+    expected: {
+      title: "Complex Test",
+      type: "object",
+      properties: {
+        validProp: { type: "string" },
+        propToBeKept: { type: "array", items: { type: "number" } },
+        objectWithMixedTypes: {
+          type: "object",
+          properties: {
+            subPropString: { type: "string" },
+            subPropArrayType: {
+              anyOf: [{ type: "integer" }, { type: "array" }, { type: "string" }],
+            },
+          },
+        },
+        anotherArrayProp: { type: "array", items: { type: "boolean" } },
+      },
+      $defs: {
+        reusableValid: {
+          type: "object",
+          properties: {
+            detail: { type: "string" },
+            unwantedList: { type: "array", items: { type: "string" } },
+            statusOptions: { anyOf: [{ type: "number" }, { type: "string" }] },
+          },
+        },
+      },
+      anyOf: [
+        { type: "string" },
+        { type: "array", items: { type: "object" } },
+        { anyOf: [{ type: "boolean" }, { type: "integer" }] },
+      ],
+    },
+  },
+  {
+    desc: "should remove properties if properties object becomes empty (all null)",
+    input: {
+      type: "object",
+      properties: {
+        field1: { type: "null" },
+        field2: { type: "null" },
+      },
+    },
+    expected: {
+      type: "object",
+    },
+  },
+  {
+    desc: "top level schema with type: ['string', 'array'] should become type: 'string'",
+    input: {
+      type: ["string", "array"], // 'array' removed at root, 'string' remains
+      description: "Test",
+    },
+    expected: {
+      type: "string",
+      description: "Test",
+    },
+  },
+  {
+    desc: "top level schema with type: ['string', 'number', 'array'] should become anyOf: [{type: string}, {type: number}]",
+    input: {
+      type: ["string", "number", "array"], // 'array' removed at root
+      description: "Test AnyOf Root",
+    },
+    expected: {
+      anyOf: [{ type: "string" }, { type: "number" }],
+      description: "Test AnyOf Root",
+    },
+  },
+];
+
+describe("cleanSchema", () => {
+  testCases.forEach((tc) => {
+    it(tc.desc, () => {
+      expect(cleanSchema(tc.input)).to.deep.equal(tc.expected);
+    });
+  });
+});
diff --git a/src/mcp/util.ts b/src/mcp/util.ts
index e79b9616802..256e139a91d 100644
--- a/src/mcp/util.ts
+++ b/src/mcp/util.ts
@@ -3,13 +3,28 @@ import { execSync } from "child_process";
 import { dump } from "js-yaml";
 import { platform } from "os";
 import { ServerFeature } from "./types";
-import { authManagementOrigin, dataconnectOrigin, firestoreOrigin, storageOrigin } from "../api";
+import {
+  apphostingOrigin,
+  authManagementOrigin,
+  dataconnectOrigin,
+  firestoreOrigin,
+  messagingApiOrigin,
+  remoteConfigApiOrigin,
+  storageOrigin,
+  crashlyticsApiOrigin,
+} from "../api";
 import { check } from "../ensureApiEnabled";
 
-export function toContent(data: any, options?: { format: "json" | "yaml" }): CallToolResult {
+/**
+ * Converts data to a CallToolResult.
+ */
+export function toContent(
+  data: any,
+  options?: { format?: "json" | "yaml"; contentPrefix?: string; contentSuffix?: string },
+): CallToolResult {
   if (typeof data === "string") return { content: [{ type: "text", text: data }] };
 
-  let text: string = "";
+  let text = "";
   const format = options?.format || "yaml"; // use YAML because it's a little more prose-like for the LLM to parse
   switch (format) {
     case "json":
@@ -19,11 +34,16 @@ export function toContent(data: any, options?: { format: "json" | "yaml" }): Cal
       text = dump(data);
       break;
   }
+  const prefix = options?.contentPrefix || "";
+  const suffix = options?.contentSuffix || "";
   return {
-    content: [{ type: "text", text }],
+    content: [{ type: "text", text: `${prefix}${text}${suffix}` }],
   };
 }
 
+/**
+ * Returns an error message to the user.
+ */
 export function mcpError(message: Error | string | unknown, code?: string): CallToolResult {
   let errorMessage = "unknown error";
   if (message instanceof Error) {
@@ -38,6 +58,9 @@ export function mcpError(message: Error | string | unknown, code?: string): Call
   };
 }
 
+/**
+ * Checks if a command exists in the system.
+ */
 export function commandExistsSync(command: string): boolean {
   try {
     const isWindows = platform() === "win32";
@@ -62,7 +85,12 @@ const SERVER_FEATURE_APIS: Record<ServerFeature, string> = {
   storage: storageOrigin(),
   dataconnect: dataconnectOrigin(),
   auth: authManagementOrigin(),
+  messaging: messagingApiOrigin(),
+  remoteconfig: remoteConfigApiOrigin(),
+  crashlytics: crashlyticsApiOrigin(),
+  apphosting: apphostingOrigin(),
 };
+
 /**
  * Detects whether an MCP feature is active in the current project root. Relies first on
  * `firebase.json` configuration, but falls back to API checks.
@@ -83,3 +111,176 @@ export async function checkFeatureActive(
   }
   return false;
 }
+
+// Helper function to process a single schema node (could be a property schema, items schema, etc.)
+// Returns the cleaned schema, or null if the schema becomes invalid and should be removed according to the rules.
+// The isRoot parameter is true only for the top-level schema object.
+function deepClean(obj: any, isRootLevel: boolean = false): any {
+  if (typeof obj !== "object" || obj === null) {
+    return obj; // Not a schema object or null, return as is
+  }
+
+  // Create a shallow copy to modify
+  const cleanedObj = { ...obj };
+
+  // Rule 1: Remove $schema (applies to any level, but typically at root)
+  if (cleanedObj.hasOwnProperty("$schema")) {
+    delete cleanedObj.$schema;
+  }
+
+  // Remove additionalProperties
+  if (cleanedObj.hasOwnProperty("additionalProperties")) {
+    delete cleanedObj.additionalProperties;
+  }
+
+  // Rule 2 & 3: Handle 'type' for "array" (only at root) and "null" (always)
+  if (cleanedObj.hasOwnProperty("type")) {
+    const currentType = cleanedObj.type;
+    if (Array.isArray(currentType)) {
+      let filteredTypes = currentType.filter((t: string) => t !== "null");
+      if (isRootLevel) {
+        filteredTypes = filteredTypes.filter((t: string) => t !== "array");
+      }
+
+      if (filteredTypes.length === 0) {
+        return null; // Invalid: became typeless or only contained disallowed types
+      } else if (filteredTypes.length === 1) {
+        cleanedObj.type = filteredTypes[0]; // Simplify to single type
+      } else {
+        // Convert to anyOf
+        delete cleanedObj.type; // Remove the original 'type' array
+        cleanedObj.anyOf = filteredTypes
+          .map((t: string) => {
+            // Each item in anyOf is a schema, so it needs to be an object with a 'type'
+            // These sub-schemas are not root level.
+            return deepClean({ type: t }, false);
+          })
+          .filter((subSchema: any) => subSchema !== null); // Filter out any nulls from deepClean
+
+        if (cleanedObj.anyOf.length === 0) {
+          return null; // All types in the array led to invalid sub-schemas
+        }
+        if (cleanedObj.anyOf.length === 1) {
+          // If after cleaning, only one valid type remains in anyOf, simplify it
+          const singleSchema = cleanedObj.anyOf[0];
+          delete cleanedObj.anyOf;
+          // Merge the single schema's properties into cleanedObj
+          // Most commonly, this will just be setting cleanedObj.type = singleSchema.type
+          Object.assign(cleanedObj, singleSchema);
+        }
+      }
+    } else if (typeof currentType === "string") {
+      if (currentType === "null") {
+        return null; // Invalid: type is "null"
+      }
+      if (isRootLevel && currentType === "array") {
+        return null; // Invalid: top-level type is "array"
+      }
+      // If not root level, "array" as a string type is allowed.
+    }
+  }
+
+  // Recursively clean 'properties'
+  if (
+    cleanedObj.hasOwnProperty("properties") &&
+    typeof cleanedObj.properties === "object" &&
+    cleanedObj.properties !== null
+  ) {
+    const newProperties: Record<string, any> = {};
+    for (const key in cleanedObj.properties) {
+      if (cleanedObj.properties.hasOwnProperty(key)) {
+        // Properties are never root level in this recursive call
+        const cleanedPropertySchema = deepClean(cleanedObj.properties[key], false);
+        if (cleanedPropertySchema !== null) {
+          // Only add valid properties
+          newProperties[key] = cleanedPropertySchema;
+        }
+      }
+    }
+    if (Object.keys(newProperties).length === 0) {
+      delete cleanedObj.properties; // Remove 'properties' key if it becomes empty
+    } else {
+      cleanedObj.properties = newProperties;
+    }
+  }
+
+  // Recursively clean 'items'
+  if (
+    cleanedObj.hasOwnProperty("items") &&
+    typeof cleanedObj.items === "object" &&
+    cleanedObj.items !== null
+  ) {
+    // 'items' schema is never root level in this recursive call
+    const cleanedItemsSchema = deepClean(cleanedObj.items, false);
+    if (cleanedItemsSchema === null) {
+      delete cleanedObj.items; // Items schema became invalid
+    } else {
+      cleanedObj.items = cleanedItemsSchema;
+    }
+  }
+
+  // Recursively clean definitions (e.g., in $defs or definitions)
+  const defKeywords = ["$defs", "definitions"];
+  for (const keyword of defKeywords) {
+    if (
+      cleanedObj.hasOwnProperty(keyword) &&
+      typeof cleanedObj[keyword] === "object" &&
+      cleanedObj[keyword] !== null
+    ) {
+      const newDefs: Record<string, any> = {};
+      for (const defKey in cleanedObj[keyword]) {
+        if (cleanedObj[keyword].hasOwnProperty(defKey)) {
+          // Definitions are never root level in this recursive call
+          const cleanedDef = deepClean(cleanedObj[keyword][defKey], false);
+          if (cleanedDef !== null) {
+            newDefs[defKey] = cleanedDef;
+          }
+        }
+      }
+      if (Object.keys(newDefs).length === 0) {
+        delete cleanedObj[keyword];
+      } else {
+        cleanedObj[keyword] = newDefs;
+      }
+    }
+  }
+
+  // Recursively clean schema arrays like anyOf, allOf, oneOf
+  const schemaArrayKeywords = ["anyOf", "allOf", "oneOf"];
+  for (const keyword of schemaArrayKeywords) {
+    if (cleanedObj.hasOwnProperty(keyword) && Array.isArray(cleanedObj[keyword])) {
+      const newSchemaArray = cleanedObj[keyword]
+        // Sub-schemas in anyOf etc. are not root level in this recursive call
+        .map((subSchema: any) => deepClean(subSchema, false))
+        .filter((subSchema: any) => subSchema !== null); // Filter out invalid subSchemas
+
+      if (newSchemaArray.length === 0) {
+        delete cleanedObj[keyword]; // Remove key if array becomes empty
+      } else {
+        cleanedObj[keyword] = newSchemaArray;
+      }
+    }
+  }
+  return cleanedObj;
+}
+
+/** Takes a zodToJsonSchema output and cleans it up to be more compatible with LLM limitations. */
+export function cleanSchema(schema: Record<string, any>): Record<string, any> {
+  // Initial check for top-level array type before deep cleaning
+  if (schema && schema.hasOwnProperty("type")) {
+    const topLevelType = schema.type;
+    if (topLevelType === "array") {
+      return {};
+    }
+    if (Array.isArray(topLevelType)) {
+      const filteredRootTypes = topLevelType.filter((t) => t !== "null" && t !== "array");
+      if (filteredRootTypes.length === 0 && topLevelType.includes("array")) {
+        // e.g. type: ["array"] or type: ["array", "null"]
+        return {};
+      }
+    }
+  }
+
+  const result = deepClean(schema, true); // Pass true for isRootLevel
+  return result === null ? {} : result;
+}
diff --git a/src/messaging/interfaces.ts b/src/messaging/interfaces.ts
new file mode 100644
index 00000000000..f63a05dc264
--- /dev/null
+++ b/src/messaging/interfaces.ts
@@ -0,0 +1,33 @@
+export interface BaseMessage {
+  notification?: Notification;
+}
+
+export interface TokenMessage extends BaseMessage {
+  token: string;
+}
+
+export interface TopicMessage extends BaseMessage {
+  topic: string;
+}
+
+/**
+ * Payload for the {@link Messaging.send} operation. The payload contains all the fields
+ * in the BaseMessage type, and exactly one of token, topic or condition.
+ */
+export type Message = TokenMessage | TopicMessage;
+
+/**
+ * A notification that can be included in {@link Message}.
+ */
+export interface Notification {
+  /**
+   * The title of the notification.
+   */
+  title?: string;
+  /**
+   * The notification body
+   */
+  body?: string;
+  /** URL of an image to include in the notification. */
+  image?: string;
+}
diff --git a/src/messaging/sendMessage.ts b/src/messaging/sendMessage.ts
new file mode 100644
index 00000000000..939c73d437a
--- /dev/null
+++ b/src/messaging/sendMessage.ts
@@ -0,0 +1,66 @@
+import { messagingApiOrigin } from "../api";
+import { Client } from "../apiv2";
+import { logger } from "../logger";
+import { FirebaseError } from "../error";
+import { Message, Notification } from "./interfaces";
+
+const TIMEOUT = 10000;
+
+const apiClient = new Client({
+  urlPrefix: messagingApiOrigin(),
+  apiVersion: "v1",
+});
+
+/**
+ * Function to send a message to an FCM Token.
+ * @param projectId Project ID to which this token belongs to.
+ * @param options Parameters including message body and target.
+ * @return {Promise} Returns a promise fulfilled with a unique message ID string
+ * after the message has been successfully handed off to the FCM service for delivery.
+ */
+export async function sendFcmMessage(
+  projectId: string,
+  options: {
+    topic?: string;
+    token?: string;
+    title?: string;
+    body?: string;
+    image?: string;
+  },
+): Promise<string> {
+  try {
+    const notification: Notification = {
+      title: options.title,
+      body: options.body,
+      image: options.image,
+    };
+    if (!options.token && !options.topic) {
+      throw new FirebaseError("Must supply either token or topic to send FCM message.");
+    }
+    const message: Message = options.token
+      ? {
+          token: options.token!,
+          notification: notification,
+        }
+      : {
+          topic: options.topic!,
+          notification: notification,
+        };
+    const messageData = {
+      message: message,
+    };
+    const res = await apiClient.request<null, string>({
+      method: "POST",
+      path: `/projects/${projectId}/messages:send`,
+      body: JSON.stringify(messageData),
+      timeout: TIMEOUT,
+    });
+    return res.body;
+  } catch (err: any) {
+    logger.debug(err.message);
+    throw new FirebaseError(
+      `Failed to send message to '${options.token || options.topic}' for the project '${projectId}'. `,
+      { original: err },
+    );
+  }
+}
diff --git a/src/options.ts b/src/options.ts
index 45814867e0c..7374ef1b688 100644
--- a/src/options.ts
+++ b/src/options.ts
@@ -28,6 +28,8 @@ export interface BaseOptions {
   // Emulator specific import/export options
   exportOnExit?: boolean | string;
   import?: string;
+
+  isMCP?: boolean;
 }
 
 export interface Options extends BaseOptions {
diff --git a/src/prompt.ts b/src/prompt.ts
index a4e72c47f02..fdf9865d731 100644
--- a/src/prompt.ts
+++ b/src/prompt.ts
@@ -214,7 +214,14 @@ export async function number(message: string): Promise<number>;
  */
 export async function number(opts: NumberOptions): Promise<number>;
 
-export async function number(opts: string | NumberOptions): Promise<number> {
+/**
+ * Prompt a user for an optional number.
+ */
+export async function number(
+  opts: NumberOptions & { required: false },
+): Promise<number | undefined>;
+
+export async function number(opts: string | NumberOptions): Promise<number | undefined> {
   if (typeof opts === "string") {
     opts = { message: opts };
   } else {
@@ -224,7 +231,7 @@ export async function number(opts: string | NumberOptions): Promise<number> {
     }
   }
 
-  return (await inquirer.number({ ...opts, required: true }))!;
+  return await inquirer.number({ required: true, ...opts });
 }
 
 /**
diff --git a/src/remoteconfig/publish.ts b/src/remoteconfig/publish.ts
new file mode 100644
index 00000000000..72ba6c441c8
--- /dev/null
+++ b/src/remoteconfig/publish.ts
@@ -0,0 +1,58 @@
+import { remoteConfigApiOrigin } from "../api";
+import { Client } from "../apiv2";
+import { logger } from "../logger";
+import { FirebaseError } from "../error";
+import { RemoteConfigTemplate } from "./interfaces";
+
+const TIMEOUT = 30000;
+
+const apiClient = new Client({
+  urlPrefix: remoteConfigApiOrigin(),
+  apiVersion: "v1",
+});
+
+/**
+ * Function to publish a new remote config template for a project
+ * This is added to support publish operation for RC MCP tooling
+ * @param projectId Input is the project ID string
+ * @param template The new template to be published
+ * @param options Takes in parameter `force` to force update the template
+ * @return {Promise} Returns a promise of a RemoteConfigTemplate
+ */
+export async function publishTemplate(
+  projectId: string,
+  template: RemoteConfigTemplate,
+  options?: { force: boolean },
+): Promise<RemoteConfigTemplate> {
+  try {
+    let ifMatch = template.etag;
+    if (options && options.force === true) {
+      // setting `If-Match = "*"` forces the Remote Config template to be updated
+      // and circumvent the ETag
+      ifMatch = "*";
+    }
+
+    const requestBody = {
+      conditions: template.conditions,
+      parameters: template.parameters,
+      parameterGroups: template.parameterGroups,
+      version: template.version,
+    };
+
+    const res = await apiClient.request<null, RemoteConfigTemplate>({
+      method: "PUT",
+      path: `/projects/${projectId}/remoteConfig`,
+      timeout: TIMEOUT,
+      headers: { "If-Match": ifMatch },
+      body: JSON.stringify(requestBody),
+    });
+
+    return res.body;
+  } catch (err: any) {
+    logger.debug(err.message);
+    throw new FirebaseError(
+      `Failed to publish Firebase Remote Config template for project ${projectId}. `,
+      { original: err },
+    );
+  }
+}
diff --git a/src/requireAuth.ts b/src/requireAuth.ts
index fbb49275c38..d73c52a23ee 100644
--- a/src/requireAuth.ts
+++ b/src/requireAuth.ts
@@ -36,7 +36,7 @@ function getAuthClient(config: GoogleAuthOptions): GoogleAuth {
  * @param options CLI options.
  * @param authScopes scopes to be obtained.
  */
-async function autoAuth(options: Options, authScopes: string[]): Promise<void | string> {
+async function autoAuth(options: Options, authScopes: string[]): Promise<null | string> {
   const client = getAuthClient({ scopes: authScopes, projectId: options.project });
   const token = await client.getAccessToken();
   token !== null ? apiv2.setAccessToken(token) : false;
@@ -65,7 +65,7 @@ async function autoAuth(options: Options, authScopes: string[]): Promise<void |
     // project is also selected in monospace auth flow
     options.projectId = await client.getProjectId();
   }
-  return clientEmail;
+  return clientEmail || null;
 }
 
 export async function refreshAuth(): Promise<Tokens> {
@@ -80,7 +80,7 @@ export async function refreshAuth(): Promise<Tokens> {
  * Ensures that there is an authenticated user.
  * @param options CLI options.
  */
-export async function requireAuth(options: any): Promise<string | void> {
+export async function requireAuth(options: any): Promise<string | null> {
   lastOptions = options;
   api.setScopes([scopes.CLOUD_PLATFORM, scopes.FIREBASE_PLATFORM]);
   options.authScopes = api.getScopes();
@@ -117,7 +117,7 @@ export async function requireAuth(options: any): Promise<string | void> {
 
   if (tokenOpt) {
     setRefreshToken(tokenOpt);
-    return;
+    return null;
   }
 
   if (!user || !tokens) {
diff --git a/src/track.ts b/src/track.ts
index 8b6e25e24f7..3225df94442 100644
--- a/src/track.ts
+++ b/src/track.ts
@@ -20,7 +20,8 @@ type cliEventNames =
   | "codebase_deploy"
   | "function_deploy_group"
   | "mcp_tool_call"
-  | "mcp_list_tools";
+  | "mcp_list_tools"
+  | "mcp_client_connected";
 type GA4Property = "cli" | "emulator" | "vscode";
 interface GA4Info {
   measurementId: string;
diff --git a/templates/dataconnect-prompts/operation-generation-cursor-windsurf-rule.txt b/templates/dataconnect-prompts/operation-generation-cursor-windsurf-rule.txt
new file mode 100644
index 00000000000..bbc7b461561
--- /dev/null
+++ b/templates/dataconnect-prompts/operation-generation-cursor-windsurf-rule.txt
@@ -0,0 +1,273 @@
+You are an expert of Firebase Data Connect GraphQL query and mutation.
+Your task is to generate the GraphQL query based on the specification that is
+valid Firebase graphql and conforms to their schema. Pay close attention to the
+following examples to understand how to compose FDC queries and mutations.
+
+Simple Firebase Data Connect queries often take the following form:
+
+```graphql
+# This is an example, real-world fields and queries will be different.
+query someQueryName @auth(level: USER) {
+  typenameplural(where: {fieldName: { eq: "somevalue"}}) {
+    nestedType {
+      fieldName
+    }
+  }
+}
+```
+
+Where typenameplural is the pluralized name of the Type in the GraphQL schema. Queries and
+mutations should have names, in this case \"someQueryName\". This is helpful for
+disambiguating different queries and mutations.
+
+Here's examples of orderBy and limit and offset clauses:
+```graphql
+# This is an example, real-world fields and queries will be different.
+query cinematicMoviesQuery @auth(level: USER) {
+  cinematicMovies(orderBy: [{rating: ASC|DESC}, {title: ASC|DESC}], limit: 10, offset: 9) {
+    nestedType {
+      fieldName
+    }
+  }
+}
+```
+
+Other comparators exist, such as gt, lt, le, ge. in, nin (not-in), eq, ne (not equals), includes, excludes.
+
+Queries with string operations:
+```graphql
+# This is an example, real-world fields and queries will be different.
+query comparisonQueries @auth(level: USER) {
+  prefixed: typenameplural(where: {title: {startsWith: %prefix%}}) {...}
+  suffixed: typenameplural(where: {title: {endsWith: %suffix%}}) {...}
+  contained: typenameplural(where: {title: {in: %listOfTitles%}}) {...}
+  contained: typenameplural(where: {title: {contains: %oneTitle%}}) {...}
+  matchRegex: typenameplural(where: {title: {pattern: {regex: %regex%}}}) {...}
+}
+```
+
+# Filtering query based on array contents with includesAll
+```graphql
+# This is an example, real-world fields and queries will be different.
+query adventureAndActionMovies @auth(level: PUBLIC) {
+  movies(where: {tags: {includesAll: ["adventure", "action"]}}) {
+    title
+    releaseYear
+  }
+}
+```
+
+# Filtering query based on array contents with an _and clause
+```graphql
+# This is an example, real-world fields and queries will be different.
+query adventureAndActionMovies @auth(level: PUBLIC) {
+  movies(
+    where: {
+      _and: [
+        { tags: { includes: "adventure" }}
+        { tags: { includes: "action" }}
+      ]
+    }) {
+    id
+    title
+  }
+}
+```
+
+# list only the posts created by the current user
+```graphql
+# This is an example, real-world fields and queries will be different.
+query MyPosts @auth(level: USER) {
+  posts(where: {userUid: {eq_expr: "auth.uid"}}) {
+    content, tags, createdAt
+  }
+}
+```
+
+### Foreign Key Joins
+
+When a type has a relation to another type, you can join that type in
+a query:
+
+```graphql
+# This is an example, real-world fields and queries will be different.
+query ListPostsWithAuthor @auth(level: USER) {
+  posts {
+    author { uid, name }
+    content, tags, createdAt
+  }
+}
+```
+
+### Auth Directives
+
+Auth directives define the basic authentication requirements for a given operation.
+The simplest form of auth directive is `@auth(level: LEVEL_NAME)`:
+
+```graphql
+# this query is accessible to anyone
+query ListProducts @auth(level: PUBLIC) {
+  # ...
+}
+
+# this query is only accessible to signed-in users
+query GetCart @auth(level: USER) {
+  # ...
+}
+```
+
+*Every* operation MUST have an `@auth` directive.
+
+### Auth Expressions
+
+If an operation would need a special role such as app-wide admin, you can use an
+expression to reference a custom claim. For example:
+
+```graphql
+mutation CreateCategory($name: String!) @auth(expr: "auth.token.admin == true") {
+  # ... mutation code
+}
+```
+
+The content of `expr` is a CEL language expression with access to the user's auth
+token and the variables of the operation.
+
+Firebase Data Connect utilizes GraphQL queries to provide secure endpoints
+that client applications can access directly. Data Connect automatically
+creates fields on Query and Mutation for each defined table type. You will
+be leveraging these built-in fields to construct application-specific
+mutation operations.
+
+**Important:** All Data Connect mutations return scalar values, so you should never
+try to select fields on a mutation.
+
+### Inserting Data
+
+To insert a new row into a table, you can use the `{typeName}_insert` mutation
+field:
+
+```graphql
+# This is an example schema, real-world fields and types will be different.
+type User @table(key: "uid") {
+  uid: String!
+  displayName: String
+}
+
+type Post @table {
+  user: User!
+  text: String!
+  createdAt: Timestamp! @default(expr: "request.time")
+}
+
+mutation CreatePost($text: String!) @auth(level: USER) {
+  post: post_insert(data: {
+    # insert the current user's UID
+    userUid_expr: "auth.uid",
+    text: $text
+  })
+}
+```
+
+The `_insert` operation returns a scalar of type `{TypeName}_Key` so field selection
+is not necessary.
+
+### Updating Data
+
+To update an existing row in the table, you must supply a key along with the fields
+to be updated. The key is an object with all parts of the primary key specified.
+
+To update a `Post` from the schema above, you might have an operation like:
+
+```graphql
+# This is an example, real-world fields and queries will be different.
+mutation UpdatePost($id: UUID!, $text: String) @auth(level: USER) {
+  post: post_update(key: {id: $id}, data: {
+    text: $text,
+    updatedAt_expr: "request.time"
+  })
+}
+```
+
+### Deleting Data
+
+To delete a row, you simply need to supply its key:
+
+```graphql
+mutation DeletePost($id: UUID!) {
+  post: post_delete(key: {id: $id})
+}
+```
+
+### Server Values
+
+With Firebase Data Connect, only variables can be modified by an untrusted
+client -- they are unable to write arbitrary queries. This allows you to
+write secure queries without custom backend code.
+
+You should never request the current user's id as a variable. Instead you
+can use a **Server Value** which is exposed by adding an `_expr` suffix to
+an existing field.
+
+For example, if you had a schema like:
+
+```graphql
+# This is an example schema, real-world fields and queries will be different.
+type User @table(key: "uid") {
+  uid: String!
+}
+
+type Follow @table(key: ["user", "follower"]) {
+  user: User!
+  follower: User!
+}
+```
+
+you might write a mutation like:
+
+```graphql
+# This is an example, real-world fields and queries will be different.
+type CreateFollow($uid: String!) {
+  follow: follow_insert(data: {
+    userUid: $uid,
+    followerUid_expr: "auth.uid"
+  })
+}
+```
+
+### Query explorer
+This query is going to be used in the Firebase Query Explorer view. Because of
+this, it's ideal to avoid using variables. Use hardcoded literals instead. For
+example, instead of the following mutation:
+```graphql
+# This is an example, real-world fields and queries will be different.
+mutation CreateUser($id: UUID!, $name: String!) {
+  user_insert(data: {id: $id, name: $name})
+}
+```
+Use this mutation with literals instead:
+```graphql
+# This is an example, real-world fields and queries will be different.
+mutation CreateUser {
+  user_insert(data: {id: "550e8400-e29b-41d4-a716-446655440000", name: "bobuser"})
+}
+```
+
+### Vector embeddings
+We can store vector embeddings in Firebase Data Connect based on text content. For example,
+given the following schema:
+```graphql
+# This is an example, real-world schemas will be different.
+type Content @table {
+  myContent: String!
+  contentEmbedding: Vector @col(size:3) # IN_PROD: contentEmbedding: Vector @col(size:768)
+}
+```
+We can generate a vector embedding for a given text using the following mutation:
+```graphql
+# This is an example, real-world fields and queries will be different.
+mutation vectorInsert (${"$"}content: String!) {
+  content_insert(data: {
+    myContent: ${"$"}content,
+    contentEmbedding_embed: {model: "textembedding-gecko@003", text: ${"$"}content},
+  })
+}
diff --git a/templates/dataconnect-prompts/schema-generation-cursor-windsurf-rule.txt b/templates/dataconnect-prompts/schema-generation-cursor-windsurf-rule.txt
new file mode 100644
index 00000000000..bdf6fc23076
--- /dev/null
+++ b/templates/dataconnect-prompts/schema-generation-cursor-windsurf-rule.txt
@@ -0,0 +1,653 @@
+Description: Use this tool to generate Firebase Data Connect schema.
+
+You are an expert of Firebase Data Connect. 
+
+- Data Connect offers customized GraphQL directives to let you customize SQL mapping in the schema. Follow https://firebase.google.com/docs/reference/data-connect/gql/directive to incorporate Data Connect directive in.
+
+- Do not overwrite the schema with generic GraghQL syntax
+
+For example, if I were to ask for a schema for a GraphQL database that contains a table called "users" with a field called "name" and another table called "posts" with a field called "body", I would get the following schema:
+```
+type User @table {
+  name: String!
+}
+
+type Post @table {
+  body: String!
+  author: User
+}
+```
+
+Simple Firebase Data Connect schema often takes the following form:
+```graphql
+type TableName @table {
+  uuidField: UUID
+  uuidArrayField: [UUID]
+  stringField: String
+  stringArrayField: [String]
+  intField: Int
+  intArrayField: [Int]
+  int64Field: Int64
+  int64ArrayField: [Int64]
+  floatField: Float
+  floatArrayField: [Float]
+  booleanField: Boolean
+  booleanArrayField: [Boolean]
+  timestampField: Timestamp
+  timestampArrayField: [Timestamp]
+  dateField: Date
+  dateArrayField: [Date]
+  vectorField: Vector @col(size:168)
+}
+```
+
+Leave out objects named after `Query` and `Mutation`
+
+Firebase Data Connect implicitly adds `id: UUID!` to every table and implicitly makes it primary key. Therefore, leave out the `id` field.
+
+Use `UUID` type instead of `ID` type or `String` type for id-like fields.
+
+Array reference fields, like `[SomeTable]` and `[SomeTable!]!`, are not supported. Use the singular reference field instead.
+For example, for a one-to-many relationship like one user is assiend to many bugs in a software project:
+```graphql
+type User @table {
+  name: String! @col(name: "name", dataType: "varchar(30)")
+  # bugs: [Bug]   # Not supported. Do not use
+}
+
+type Bug @table {
+  title: String!
+  assignee: User
+  reporter: User
+}
+```
+
+For another example, for a many-to-many relationship like each crew member is assigned to many chores and each chores requires many crews to complete:
+```graphql
+type Crew @table {
+  name: String!
+  # assignedChores: [Chore!]!  # No supported. Do not use
+}
+
+type Chore @table {
+  name: String!
+  description: String!
+  # assignedCrews: [Crews!]!  # No supported. Do not use
+}
+
+type Assignment @table {
+  crew: Crew!
+  chore: Chore!
+}
+```
+
+
+Be sure that your response contains a valid Firebase Data Connect schema in a single GraphQL code block inside of triple backticks and closely follows my instructions and description.
+
+
+# Directives
+
+Directives define specific behaviors that can be applied to fields or types within a GraphQL schema.
+
+## Data Connect Defined
+
+### @col on `FIELD_DEFINITION` {:#col}
+Customizes a field that represents a SQL database table column.
+
+Data Connect maps scalar Fields on @`@table` type to a SQL column of
+corresponding data type.
+
+- scalar @`UUID` maps to @`uuid`.
+- scalar @`String` maps to @`text`.
+- scalar @`Int` maps to @`int`.
+- scalar @`Int64` maps to @`bigint`.
+- scalar @`Float` maps to @`double precision`.
+- scalar @`Boolean` maps to @`boolean`.
+- scalar @`Date` maps to @`date`.
+- scalar @`Timestamp` maps to @`timestamptz`.
+- scalar @`Any` maps to @`jsonb`.
+- scalar @`Vector` maps to @`pgvector`.
+
+Array scalar fields are mapped to @Postgres arrays.
+
+###### Example: Serial Primary Key
+
+For example, you can define auto-increment primary key.
+
+```graphql
+type Post @table {
+  id: Int! @col(name: "post_id", dataType: "serial")
+}
+```
+
+Data Connect converts it to the following SQL table schema.
+
+```sql
+CREATE TABLE "public"."post" (
+  "post_id" serial NOT NULL,
+  PRIMARY KEY ("id")
+)
+```
+
+###### Example: Vector
+
+```graphql
+type Post @table {
+  content: String! @col(name: "post_content")
+  contentEmbedding: Vector! @col(size:768)
+}
+```
+
+| Argument | Type | Description |
+|---|---|---|
+| `name` | @`String` | The SQL database column name. Defaults to snake_case of the field name. |
+| `dataType` | @`String` | Configures the custom SQL data type.  Each GraphQL type can map to multiple SQL data types. Refer to @Postgres supported data types.  Incompatible SQL data type will lead to undefined behavior. |
+| `size` | @`Int` | Required on @`Vector` columns. It specifies the length of the Vector. `textembedding-gecko@003` model generates @`Vector` of `@col(size:768)`. |
+
+### @default on `FIELD_DEFINITION` {:#default}
+Specifies the default value for a column field.
+
+For example:
+
+```graphql
+type User @table(key: "uid") {
+  uid: String! @default(expr: "auth.uid")
+  number: Int! @col(dataType: "serial")
+  createdAt: Date! @default(expr: "request.time")
+  role: String! @default(value: "Member")
+  credit: Int! @default(value: 100)
+}
+```
+
+The supported arguments vary based on the field type.
+
+| Argument | Type | Description |
+|---|---|---|
+| `value` | @`Any` | A constant value validated against the field's GraphQL type during compilation. |
+| `expr` | @`Any_Expr` | A CEL expression whose return value must match the field's data type. |
+| `sql` | @`Any_SQL` | A raw SQL expression, whose SQL data type must match the underlying column.  The value is any variable-free expression (in particular, cross-references to other columns in the current table are not allowed). Subqueries are not allowed either. See @PostgreSQL defaults for more details. |
+
+### Default Expression `@default(expr: "request.time")` 
+To automatically updates a date when a row in the table is created.
+
+For example: createdAt column automatically updates when a user is created.
+
+```graphql
+type User @table(key: "uid") {
+// other fields
+createdAt: Date! @default(expr: "request.time")
+}
+```
+
+### @index on `FIELD_DEFINITION` | `OBJECT` {:#index}
+Defines a database index to optimize query performance.
+
+```graphql
+type User @table @index(fields: ["name", "phoneNumber"], order: [ASC, DESC]) {
+    name: String @index
+    phoneNumber: Int64 @index
+    tags: [String] @index # GIN Index
+}
+```
+
+##### Single Field Index
+
+You can put @`@index` on a @`@col` field to create a SQL index.
+
+`@index(order)` matters little for single field indexes, as they can be scanned
+in both directions.
+
+##### Composite Index
+
+You can put `@index(fields: [...])` on @`@table` type to define composite indexes.
+
+`@index(order: [...])` can customize the index order to satisfy particular
+filter and order requirement.
+
+| Argument | Type | Description |
+|---|---|---|
+| `name` | @`String` | Configure the SQL database index id.  If not overridden, Data Connect generates the index name: - `{table_name}_{first_field}_{second_field}_aa_idx` - `{table_name}_{field_name}_idx` |
+| `fields` | [`[String!]`](scalar.md#String) | Only allowed and required when used on a @`@table` type. Specifies the fields to create the index on. |
+| `order` | [`[IndexFieldOrder!]`](enum.md#IndexFieldOrder) | Only allowed for `BTREE` @`@index` on @`@table` type. Specifies the order for each indexed column. Defaults to all `ASC`. |
+| `type` | @`IndexType` | Customize the index type.  For most index, it defaults to `BTREE`. For array fields, only allowed @`IndexType` is `GIN`. For @`Vector` fields, defaults to `HNSW`, may configure to `IVFFLAT`. |
+| `vector_method` | @`VectorSimilarityMethod` | Only allowed when used on vector field. Defines the vector similarity method. Defaults to `INNER_PRODUCT`. |
+
+### @ref on `FIELD_DEFINITION` {:#ref}
+Defines a foreign key reference to another table.
+
+For example, we can define a many-to-one relation.
+
+```graphql
+type ManyTable @table {
+  refField: OneTable!
+}
+type OneTable @table {
+  someField: String!
+}
+```
+Data Connect adds implicit foreign key column and relation query field. So the
+above schema is equivalent to the following schema.
+
+```graphql
+type ManyTable @table {
+  id: UUID! @default(expr: "uuidV4()")
+  refField: OneTable! @ref(fields: "refFieldId", references: "id")
+  refFieldId: UUID!
+}
+type OneTable @table {
+  id: UUID! @default(expr: "uuidV4()")
+  someField: UUID!
+  # Generated Fields:
+  # manyTables_on_refField: [ManyTable!]!
+}
+```
+Data Connect generates the necessary foreign key constraint.
+
+```sql
+CREATE TABLE "public"."many_table" (
+  "id" uuid NOT NULL DEFAULT uuid_generate_v4(),
+  "ref_field_id" uuid NOT NULL,
+  PRIMARY KEY ("id"),
+  CONSTRAINT "many_table_ref_field_id_fkey" FOREIGN KEY ("ref_field_id") REFERENCES "public"."one_table" ("id") ON DELETE CASCADE
+)
+```
+
+###### Example: Traverse the Reference Field
+
+```graphql
+query ($id: UUID!) {
+  manyTable(id: $id) {
+    refField { id }
+  }
+}
+```
+
+###### Example: Reverse Traverse the Reference field
+
+```graphql
+query ($id: UUID!) {
+  oneTable(id: $id) {
+    manyTables_on_refField { id }
+  }
+}
+```
+
+##### Optional Many-to-One Relation
+
+An optional foreign key reference will be set to null if the referenced row is deleted.
+
+In this example, if a `User` is deleted, the `assignee` and `reporter`
+references will be set to null.
+
+```graphql
+type Bug @table {
+  title: String!
+  assignee: User
+  reproter: User
+}
+
+type User @table { name: String!  }
+```
+
+##### Required Many-to-One Relation
+
+A required foreign key reference will cascade delete if the referenced row is
+deleted.
+
+In this example, if a `Post` is deleted, associated comments will also be
+deleted.
+
+```graphql
+type Comment @table {
+  post: Post!
+  content: String!
+}
+
+type Post @table { title: String!  }
+```
+
+##### Many To Many Relation
+
+You can define a many-to-many relation with a join table.
+
+```graphql
+type Membership @table(key: ["group", "user"]) {
+  group: Group!
+  user: User!
+  role: String! @default(value: "member")
+}
+
+type Group @table { name: String! }
+type User @table { name: String! }
+```
+
+When Data Connect sees a table with two reference field as its primary key, it
+knows this is a join table, so expands the many-to-many query field.
+
+```graphql
+type Group @table {
+  name: String!
+  # Generated Fields:
+  # users_via_Membership: [User!]!
+  # memberships_on_group: [Membership!]!
+}
+type User @table {
+  name: String!
+  # Generated Fields:
+  # groups_via_Membership: [Group!]!
+  # memberships_on_user: [Membership!]!
+}
+```
+
+###### Example: Traverse the Many-To-Many Relation
+
+```graphql
+query ($id: UUID!) {
+  group(id: $id) {
+    users: users_via_Membership {
+      name
+    }
+  }
+}
+```
+
+###### Example: Traverse to the Join Table
+
+```graphql
+query ($id: UUID!) {
+  group(id: $id) {
+    memberships: memberships_on_group {
+      user { name }
+      role
+    }
+  }
+}
+```
+
+##### One To One Relation
+
+You can even define a one-to-one relation with the help of @`@unique` or `@table(key)`.
+
+```graphql
+type User @table {
+  name: String
+}
+type Account @table {
+  user: User! @unique
+}
+# Alternatively, use primary key constraint.
+# type Account @table(key: "user") {
+#   user: User!
+# }
+```
+
+###### Example: Transerse the Reference Field
+
+```graphql
+query ($id: UUID!) {
+  account(id: $id) {
+    user { id }
+  }
+}
+```
+
+###### Example: Reverse Traverse the Reference field
+
+```graphql
+query ($id: UUID!) {
+  user(id: $id) {
+    account_on_user { id }
+  }
+}
+```
+
+##### Customizations
+
+- `@ref(constraintName)` can customize the SQL foreign key constraint name (`table_name_ref_field_fkey` above).
+- `@ref(fields)` can customize the foreign key field names.
+- `@ref(references)` can customize the constraint to reference other columns.
+   By default, `@ref(references)` is the primary key of the @`@ref` table.
+   Other fields with @`@unique` may also be referred in the foreign key constraint.
+
+| Argument | Type | Description |
+|---|---|---|
+| `constraintName` | @`String` | The SQL database foreign key constraint name. Defaults to snake_case `{table_name}_{field_name}_fkey`. |
+| `fields` | [`[String!]`](scalar.md#String) | Foreign key fields. Defaults to `{tableName}{PrimaryIdName}`. |
+| `references` | [`[String!]`](scalar.md#String) | The fields that the foreign key references in the other table. Defaults to its primary key. |
+
+### @table on `OBJECT` {:#table}
+Defines a relational database table.
+
+In this example, we defined one table with a field named `myField`.
+
+```graphql
+type TableName @table {
+  myField: String
+}
+```
+Data Connect adds an implicit `id` primary key column. So the above schema is equivalent to:
+
+```graphql
+type TableName @table(key: "id") {
+  id: String @default(expr: "uuidV4()")
+  myField: String
+}
+```
+
+Data Connect generates the following SQL table and CRUD operations to use it.
+
+```sql
+CREATE TABLE "public"."table_name" (
+  "id" uuid NOT NULL DEFAULT uuid_generate_v4(),
+  "my_field" text NULL,
+  PRIMARY KEY ("id")
+)
+```
+
+ * You can lookup a row: `query ($id: UUID!) { tableName(id: $id) { myField } } `
+ * You can find rows using: `query tableNames(limit: 20) { myField }`
+ * You can insert a row: `mutation { tableName_insert(data: {myField: "foo"}) }`
+ * You can update a row: `mutation ($id: UUID!) { tableName_update(id: $id, data: {myField: "bar"}) }`
+ * You can delete a row: `mutation ($id: UUID!) { tableName_delete(id: $id) }`
+
+##### Customizations
+
+- `@table(singular)` and `@table(plural)` can customize the singular and plural name.
+- `@table(name)` can customize the Postgres table name.
+- `@table(key)` can customize the primary key field name and type.
+
+For example, the `User` table often has a `uid` as its primary key.
+
+```graphql
+type User @table(key: "uid") {
+  uid: String!
+  name: String
+}
+```
+
+ * You can securely lookup a row: `query { user(key: {uid_expr: "auth.uid"}) { name } } `
+ * You can securely insert a row: `mutation { user_insert(data: {uid_expr: "auth.uid" name: "Fred"}) }`
+ * You can securely update a row: `mutation { user_update(key: {uid_expr: "auth.uid"}, data: {name: "New Name"}) }`
+ * You can securely delete a row: `mutation { user_delete(key: {uid_expr: "auth.uid"}) }`
+
+@`@table` type can be configured further with:
+
+ - Custom SQL data types for columns. See @`@col`.
+ - Add SQL indexes. See @`@index`.
+ - Add SQL unique constraints. See @`@unique`.
+ - Add foreign key constraints to define relations. See @`@ref`.
+
+| Argument | Type | Description |
+|---|---|---|
+| `name` | @`String` | Configures the SQL database table name. Defaults to snake_case like `table_name`. |
+| `singular` | @`String` | Configures the singular name. Defaults to the camelCase like `tableName`. |
+| `plural` | @`String` | Configures the plural name. Defaults to infer based on English plural pattern like `tableNames`. |
+| `key` | [`[String!]`](scalar.md#String) | Defines the primary key of the table. Defaults to a single field named `id`. If not present already, Data Connect adds an implicit field `id: UUID! @default(expr: "uuidV4()")`. |
+
+### @unique on `FIELD_DEFINITION` | `OBJECT` {:#unique}
+Defines unique constraints on @`@table`.
+
+For example,
+
+```graphql
+type User @table {
+    phoneNumber: Int64 @unique
+}
+type UserProfile @table {
+    user: User! @unique
+    address: String @unique
+}
+```
+
+- @`@unique` on a @`@col` field adds a single-column unique constraint.
+- @`@unique` on a @`@table` type adds a composite unique constraint.
+- @`@unique` on a @`@ref` defines a one-to-one relation. It adds unique constraint
+   on `@ref(fields)`.
+
+@`@unique` ensures those fields can uniquely identify a row, so other @`@table`
+type may define `@ref(references)` to refer to fields that has a unique constraint.
+
+| Argument | Type | Description |
+|---|---|---|
+| `indexName` | @`String` | Configures the SQL database unique constraint name.  If not overridden, Data Connect generates the unique constraint name: - `table_name_first_field_second_field_uidx` - `table_name_only_field_name_uidx` |
+| `fields` | [`[String!]`](scalar.md#String) | Only allowed and required when used on OBJECT, this specifies the fields to create a unique constraint on. |
+
+### @view on `OBJECT` {:#view}
+Defines a relational database Raw SQLview.
+
+Data Connect generates GraphQL queries with WHERE and ORDER BY clauses.
+However, not all SQL features has native GraphQL equivalent.
+
+You can write **an arbitrary SQL SELECT statement**. Data Connect
+would map Graphql fields on @`@view` type to columns in your SELECT statement.
+
+* Scalar GQL fields (camelCase) should match a SQL column (snake_case)
+  in the SQL SELECT statement.
+* Reference GQL field can point to another @`@table` type. Similar to foreign key
+  defined with @`@ref` on a @`@table` type, a @`@view` type establishes a relation
+  when `@ref(fields)` match `@ref(references)` on the target table.
+
+In this example, you can use `@view(sql)` to define an aggregation view on existing
+table.
+
+```graphql
+type User @table {
+  name: String
+  score: Int
+}
+type UserAggregation @view(sql: """
+  SELECT
+    COUNT(*) as count,
+    SUM(score) as sum,
+    AVG(score) as average,
+    PERCENTILE_CONT(0.5) WITHIN GROUP (ORDER BY score) AS median,
+    (SELECT id FROM "user" LIMIT 1) as example_id
+  FROM "user"
+""") {
+  count: Int
+  sum: Int
+  average: Float
+  median: Float
+  example: User
+  exampleId: UUID
+}
+```
+
+###### Example: Query Raw SQL View
+
+```graphql
+query {
+  userAggregations {
+    count sum average median
+    exampleId example { id }
+  }
+}
+```
+
+##### One-to-One View
+
+An one-to-one companion @`@view` can be handy if you want to argument a @`@table`
+with additional implied content.
+
+```graphql
+type Restaurant @table {
+  name: String!
+}
+type Review @table {
+  restaurant: Restaurant!
+  rating: Int!
+}
+type RestaurantStats @view(sql: """
+  SELECT
+    restaurant_id,
+    COUNT(*) AS review_count,
+    AVG(rating) AS average_rating
+  FROM review
+  GROUP BY restaurant_id
+""") {
+  restaurant: Restaurant @unique
+  reviewCount: Int
+  averageRating: Float
+}
+```
+
+In this example, @`@unique` convey the assumption that each `Restaurant` should
+have only one `RestaurantStats` object.
+
+###### Example: Query One-to-One View
+
+```graphql
+query ListRestaurants {
+  restaurants {
+    name
+    stats: restaurantStats_on_restaurant {
+      reviewCount
+      averageRating
+    }
+  }
+}
+```
+
+###### Example: Filter based on One-to-One View
+
+```graphql
+query BestRestaurants($minAvgRating: Float, $minReviewCount: Int) {
+  restaurants(where: {
+    restaurantStats_on_restaurant: {
+      averageRating: {ge: $minAvgRating}
+      reviewCount: {ge: $minReviewCount}
+    }
+  }) { name }
+}
+```
+
+##### Customizations
+
+- One of `@view(sql)` or `@view(name)` should be defined.
+  `@view(name)` can refer to a persisted SQL view in the Postgres schema.
+- `@view(singular)` and `@view(plural)` can customize the singular and plural name.
+
+@`@view` type can be configured further:
+
+ - @`@unique` lets you define one-to-one relation.
+ - @`@col` lets you customize SQL column mapping. For example, `@col(name: "column_in_select")`.
+
+##### Limitations
+
+Raw SQL view doesn't have a primary key, so it doesn't support lookup. Other
+@`@table` or @`@view` cannot have @`@ref` to a view either.
+
+View cannot be mutated. You can perform CRUD operations on the underlying
+table to alter its content.
+
+- Important: Data Connect doesn't parse and validate SQL
+
+- If the SQL view is invalid or undefined, related requests may fail.
+- If the SQL view return incompatible types. Firebase Data Connect may surface
+  errors.
+- If a field doesn't have a corresponding column in the SQL SELECT statement,
+  it will always be `null`.
+- There is no way to ensure VIEW to TABLE @`@ref` constraint.
+- All fields must be nullable in case they aren't found in the SELECT statement
+  or in the referenced table.
+- You should always test @`@view`
diff --git a/templates/genkit/firebase.1.0.0.template b/templates/genkit/firebase.1.0.0.template
index 4b0e939d73f..ad33bfcf9b6 100644
--- a/templates/genkit/firebase.1.0.0.template
+++ b/templates/genkit/firebase.1.0.0.template
@@ -15,6 +15,11 @@ import { onCallGenkit, hasClaim } from "firebase-functions/https";
 import { defineSecret } from "firebase-functions/params";
 const apiKey = defineSecret("GOOGLE_GENAI_API_KEY");
 
+// The Firebase telemetry plugin exports a combination of metrics, traces, and logs to Google Cloud
+// Observability. See https://firebase.google.com/docs/genkit/observability/telemetry-collection.
+$TELEMETRY_COMMENTimport {enableFirebaseTelemetry} from "@genkit-ai/firebase";
+$TELEMETRY_COMMENTenableFirebaseTelemetry();
+
 const ai = genkit({
   plugins: [
 $GENKIT_CONFIG_PLUGINS
diff --git a/templates/init/functions/javascript/package.lint.json b/templates/init/functions/javascript/package.lint.json
index b8816bdcd98..1b951d0759f 100644
--- a/templates/init/functions/javascript/package.lint.json
+++ b/templates/init/functions/javascript/package.lint.json
@@ -10,7 +10,7 @@
     "logs": "firebase functions:log"
   },
   "engines": {
-    "node": "22"
+    "node": "{{RUNTIME}}"
   },
   "main": "index.js",
   "dependencies": {
diff --git a/templates/init/functions/javascript/package.nolint.json b/templates/init/functions/javascript/package.nolint.json
index 0d14456d033..4aea0a9f1b6 100644
--- a/templates/init/functions/javascript/package.nolint.json
+++ b/templates/init/functions/javascript/package.nolint.json
@@ -9,7 +9,7 @@
     "logs": "firebase functions:log"
   },
   "engines": {
-    "node": "22"
+    "node": "{{RUNTIME}}"
   },
   "main": "index.js",
   "dependencies": {
diff --git a/templates/init/functions/typescript/package.lint.json b/templates/init/functions/typescript/package.lint.json
index d7788081e69..c2d4f5493e6 100644
--- a/templates/init/functions/typescript/package.lint.json
+++ b/templates/init/functions/typescript/package.lint.json
@@ -11,7 +11,7 @@
     "logs": "firebase functions:log"
   },
   "engines": {
-    "node": "22"
+    "node": "{{RUNTIME}}"
   },
   "main": "lib/index.js",
   "dependencies": {
@@ -25,7 +25,7 @@
     "eslint-config-google": "^0.14.0",
     "eslint-plugin-import": "^2.25.4",
     "firebase-functions-test": "^3.1.0",
-    "typescript": "^4.9.0"
+    "typescript": "^5.7.3"
   },
   "private": true
 }
diff --git a/templates/init/functions/typescript/package.nolint.json b/templates/init/functions/typescript/package.nolint.json
index d167a0ee473..066161c31cd 100644
--- a/templates/init/functions/typescript/package.nolint.json
+++ b/templates/init/functions/typescript/package.nolint.json
@@ -10,7 +10,7 @@
     "logs": "firebase functions:log"
   },
   "engines": {
-    "node": "22"
+    "node": "{{RUNTIME}}"
   },
   "main": "lib/index.js",
   "dependencies": {
@@ -18,8 +18,8 @@
     "firebase-functions": "^6.0.1"
   },
   "devDependencies": {
-    "typescript": "^4.9.0",
+    "typescript": "^5.7.3",
     "firebase-functions-test": "^3.1.0"
   },
   "private": true
-}
\ No newline at end of file
+}
diff --git a/tsconfig.json b/tsconfig.json
index 0468498f49e..84a6a879592 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -8,6 +8,7 @@
     "removeComments": true,
     "allowSyntheticDefaultImports": true,
     "target": "es2017",
+    "resolveJsonModule": true,
     "sourceMap": true,
     "skipLibCheck": true,
     "typeRoots": [