firebase-tools 15.8.0 → 15.9.0

package/lib/emulator/downloadableEmulators.js

@@ -11,6 +11,7 @@ exports.stop = stop;
 exports.downloadIfNecessary = downloadIfNecessary;
 exports.start = start;
 exports.isIncomaptibleArchError = isIncomaptibleArchError;
+exports.emulatorVersionOverride = emulatorVersionOverride;
 const lsofi = require("lsofi");
 const types_1 = require("./types");
 const constants_1 = require("./constants");
@@ -41,9 +42,11 @@ function generateDownloadDetails(emulator) {
         : process.platform === "win32"
             ? EMULATOR_UPDATE_DETAILS.dataconnect.win32
             : EMULATOR_UPDATE_DETAILS.dataconnect.linux;
+    let details;
+    const overrideVersion = emulatorVersionOverride(emulator);
     switch (emulator) {
         case "database":
-            return {
+            details = {
                 downloadPath: path.join(CACHE_DIR, EMULATOR_UPDATE_DETAILS.database.downloadPathRelativeToCacheDir),
                 version: EMULATOR_UPDATE_DETAILS.database.version,
                 opts: {
@@ -52,8 +55,9 @@ function generateDownloadDetails(emulator) {
                     namePrefix: "firebase-database-emulator",
                 },
             };
+            break;
         case "firestore":
-            return {
+            details = {
                 downloadPath: path.join(CACHE_DIR, EMULATOR_UPDATE_DETAILS.firestore.downloadPathRelativeToCacheDir),
                 version: EMULATOR_UPDATE_DETAILS.firestore.version,
                 opts: {
@@ -62,8 +66,9 @@ function generateDownloadDetails(emulator) {
                     namePrefix: "cloud-firestore-emulator",
                 },
             };
+            break;
         case "storage":
-            return {
+            details = {
                 downloadPath: path.join(CACHE_DIR, EMULATOR_UPDATE_DETAILS.storage.downloadPathRelativeToCacheDir),
                 version: EMULATOR_UPDATE_DETAILS.storage.version,
                 opts: {
@@ -72,8 +77,9 @@ function generateDownloadDetails(emulator) {
                     namePrefix: "cloud-storage-rules-emulator",
                 },
             };
+            break;
         case "ui":
-            return {
+            details = {
                 version: emulatorUiDetails.version,
                 downloadPath: path.join(CACHE_DIR, emulatorUiDetails.downloadPathRelativeToCacheDir),
                 unzipDir: path.join(CACHE_DIR, `ui-v${emulatorUiDetails.version}`),
@@ -86,8 +92,9 @@ function generateDownloadDetails(emulator) {
                     namePrefix: "ui",
                 },
             };
+            break;
         case "pubsub":
-            return {
+            details = {
                 downloadPath: path.join(CACHE_DIR, EMULATOR_UPDATE_DETAILS.pubsub.downloadPathRelativeToCacheDir),
                 version: EMULATOR_UPDATE_DETAILS.pubsub.version,
                 unzipDir: path.join(CACHE_DIR, `pubsub-emulator-${EMULATOR_UPDATE_DETAILS.pubsub.version}`),
@@ -98,8 +105,9 @@ function generateDownloadDetails(emulator) {
                     namePrefix: "pubsub-emulator",
                 },
             };
+            break;
         case "dataconnect":
-            return {
+            details = {
                 downloadPath: path.join(CACHE_DIR, dataconnectDetails.downloadPathRelativeToCacheDir),
                 version: dataconnectDetails.version,
                 binaryPath: path.join(CACHE_DIR, dataconnectDetails.downloadPathRelativeToCacheDir),
@@ -111,9 +119,25 @@ function generateDownloadDetails(emulator) {
                     auth: false,
                 },
             };
+            break;
         default:
             throw new Error(`Invalid downloadable emulator: ${emulator}`);
     }
+    if (overrideVersion && overrideVersion !== details.version) {
+        const oldVersion = details.version;
+        const replaceVersion = (s) => s.split(oldVersion).join(overrideVersion);
+        details.version = overrideVersion;
+        details.downloadPath = replaceVersion(details.downloadPath);
+        if (details.unzipDir) {
+            details.unzipDir = replaceVersion(details.unzipDir);
+        }
+        if (details.binaryPath) {
+            details.binaryPath = replaceVersion(details.binaryPath);
+        }
+        details.opts.remoteUrl = replaceVersion(details.opts.remoteUrl);
+        details.opts.skipChecksumAndSize = true;
+    }
+    return details;
 }
 const EmulatorDetails = {
     database: {
@@ -437,3 +461,6 @@ function isIncomaptibleArchError(err) {
         /Unknown system error/.test(err.message ?? "") &&
         process.platform === "darwin");
 }
+function emulatorVersionOverride(emulator) {
+    return process.env[`${emulator.toUpperCase()}_EMULATOR_VERSION`];
+}

package/lib/env.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isFirebaseStudio = isFirebaseStudio;
 exports.isFirebaseMcp = isFirebaseMcp;
+exports.setFirebaseMcp = setFirebaseMcp;
 exports.detectAIAgent = detectAIAgent;
 const fsutils_1 = require("./fsutils");
 let googleIdxFolderExists;
@@ -13,8 +14,12 @@ function isFirebaseStudio() {
     googleIdxFolderExists = (0, fsutils_1.dirExistsSync)("/google/idx");
     return googleIdxFolderExists;
 }
+let isFirebaseMcpFlag = false;
 function isFirebaseMcp() {
-    return !!process.env.IS_FIREBASE_MCP;
+    return isFirebaseMcpFlag;
+}
+function setFirebaseMcp(value) {
+    isFirebaseMcpFlag = value;
 }
 function detectAIAgent() {
     if (process.env.ANTIGRAVITY_CLI_ALIAS)

package/lib/experiments.js

@@ -142,7 +142,7 @@ exports.ALL_EXPERIMENTS = experiments({
     },
     fdcwebhooks: {
         shortDescription: "Enable Firebase Data Connect webhooks feature.",
-        default: false,
+        default: true,
         public: false,
     },
     studioexport: {

package/lib/firebase_studio/migrate.js

@@ -0,0 +1,378 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractMetadata = extractMetadata;
+exports.uploadSecrets = uploadSecrets;
+exports.migrate = migrate;
+const fs = require("fs/promises");
+const path = require("path");
+const child_process_1 = require("child_process");
+const logger_1 = require("../logger");
+const error_1 = require("../error");
+const prompt = require("../prompt");
+const apphosting = require("../gcp/apphosting");
+const utils = require("../utils");
+const templates_1 = require("../templates");
+const secrets_1 = require("../apphosting/secrets");
+const env = require("../functions/env");
+async function downloadGitHubDir(apiUrl, localPath) {
+    const response = await fetch(apiUrl);
+    if (!response.ok) {
+        throw new Error(`Failed to fetch directory listing: ${apiUrl}`);
+    }
+    const items = (await response.json());
+    await fs.mkdir(localPath, { recursive: true });
+    for (const item of items) {
+        const itemLocalPath = path.join(localPath, item.name);
+        if (item.type === "dir") {
+            await downloadGitHubDir(item.url, itemLocalPath);
+        }
+        else if (item.type === "file") {
+            const fileResponse = await fetch(item.download_url);
+            if (fileResponse.ok) {
+                const content = await fileResponse.arrayBuffer();
+                await fs.writeFile(itemLocalPath, Buffer.from(content));
+            }
+        }
+    }
+}
+async function extractMetadata(rootPath, overrideProjectId) {
+    const metadataPath = path.join(rootPath, "metadata.json");
+    let metadata = {};
+    try {
+        const metadataContent = await fs.readFile(metadataPath, "utf8");
+        metadata = JSON.parse(metadataContent);
+    }
+    catch (err) {
+        logger_1.logger.debug(`Could not read metadata.json at ${metadataPath}: ${err}`);
+    }
+    let projectId = overrideProjectId || metadata.projectId;
+    if (!projectId) {
+        try {
+            const firebasercContent = await fs.readFile(path.join(rootPath, ".firebaserc"), "utf8");
+            const firebaserc = JSON.parse(firebasercContent);
+            projectId = firebaserc.projects?.default;
+        }
+        catch (err) {
+            logger_1.logger.debug(`Could not read .firebaserc at ${rootPath}: ${err}`);
+        }
+    }
+    if (projectId) {
+        logger_1.logger.info(`✅ Detected Firebase Project: ${projectId}`);
+    }
+    else {
+        logger_1.logger.info(`✅ Failed to determine the Firebase Project ID`);
+    }
+    let appName = "firebase-studio-export";
+    let blueprintContent = "";
+    const blueprintPath = path.join(rootPath, "docs", "blueprint.md");
+    try {
+        blueprintContent = await fs.readFile(blueprintPath, "utf8");
+        const nameMatch = blueprintContent.match(/# \*\*App Name\*\*: (.*)/);
+        if (nameMatch && nameMatch[1]) {
+            appName = nameMatch[1].trim();
+        }
+    }
+    catch (err) {
+        logger_1.logger.debug(`Could not read blueprint.md at ${blueprintPath}: ${err}`);
+    }
+    if (appName !== "firebase-studio-export") {
+        logger_1.logger.info(`✅ Detected App Name: ${appName}`);
+    }
+    return { projectId, appName, blueprintContent };
+}
+async function updateReadme(rootPath, blueprintContent, appName) {
+    const readmePath = path.join(rootPath, "README.md");
+    const readmeTemplate = await (0, templates_1.readTemplate)("firebase-studio-export/readme_template.md");
+    const newReadme = readmeTemplate
+        .replace(/\${appName}/g, appName)
+        .replace("${exportDate}", new Date().toISOString().split("T")[0])
+        .replace("${blueprintContent}", blueprintContent.replace(/# \*\*App Name\*\*: .*/, "").trim());
+    await fs.writeFile(readmePath, newReadme);
+    logger_1.logger.info("✅ Updated README.md with project details and origin info");
+}
+async function injectAgyContext(rootPath, projectId, appName) {
+    const agentDir = path.join(rootPath, ".agent");
+    const rulesDir = path.join(agentDir, "rules");
+    const workflowsDir = path.join(agentDir, "workflows");
+    const skillsDir = path.join(agentDir, "skills");
+    await fs.mkdir(rulesDir, { recursive: true });
+    await fs.mkdir(workflowsDir, { recursive: true });
+    await fs.mkdir(skillsDir, { recursive: true });
+    logger_1.logger.info("⏳ Fetching AGY skills from firebase/agent-skills...");
+    try {
+        const skillsResponse = await fetch("https://api.github.com/repos/firebase/agent-skills/contents/skills");
+        if (!skillsResponse.ok) {
+            throw new Error(`GitHub API returned ${skillsResponse.status}`);
+        }
+        const skillsData = (await skillsResponse.json());
+        if (Array.isArray(skillsData)) {
+            for (const item of skillsData) {
+                if (item.type === "dir") {
+                    const skillName = item.name;
+                    const skillDir = path.join(skillsDir, skillName);
+                    await downloadGitHubDir(item.url, skillDir);
+                }
+            }
+        }
+        else {
+            utils.logWarning("GitHub API response for skills is not an array.");
+        }
+        logger_1.logger.info(`✅ Downloaded Firebase skills`);
+    }
+    catch (err) {
+        utils.logWarning(`Could not download AGY skills, skipping. ${err}`);
+    }
+    logger_1.logger.info("⏳ Fetching Genkit skill...");
+    try {
+        const genkitSkillDir = path.join(skillsDir, "developing-genkit-js");
+        await downloadGitHubDir("https://api.github.com/repos/genkit-ai/skills/contents/skills/developing-genkit-js?ref=main", genkitSkillDir);
+        logger_1.logger.info(`✅ Downloaded Genkit skill`);
+    }
+    catch (err) {
+        utils.logWarning(`Could not download Genkit skill, skipping. ${err}`);
+    }
+    const systemInstructionsTemplate = await (0, templates_1.readTemplate)("firebase-studio-export/system_instructions_template.md");
+    const systemInstructions = systemInstructionsTemplate
+        .replace("${projectId}", projectId || "None")
+        .replace("${appName}", appName);
+    await fs.writeFile(path.join(rulesDir, "migration-context.md"), systemInstructions);
+    logger_1.logger.info("✅ Injected AGY rules");
+    try {
+        const startupWorkflow = await (0, templates_1.readTemplate)("firebase-studio-export/workflows/startup_workflow.md");
+        await fs.writeFile(path.join(workflowsDir, "startup.md"), startupWorkflow);
+        logger_1.logger.info("✅ Created AGY startup workflow");
+    }
+    catch (err) {
+        logger_1.logger.debug(`Could not read or write startup workflow: ${err}`);
+    }
+}
+async function assertSystemState(startAgy) {
+    if (startAgy === false) {
+        return;
+    }
+    try {
+        (0, child_process_1.execSync)("agy --version", { stdio: "ignore" });
+        logger_1.logger.info("✅ Antigravity IDE CLI (agy) detected");
+    }
+    catch (err) {
+        const downloadLink = "https://antigravity.google/download";
+        throw new error_1.FirebaseError(`Antigravity IDE CLI (agy) not found in your PATH. To ensure a seamless migration, please download and install Antigravity: ${downloadLink}`, { exit: 1 });
+    }
+}
+async function createFirebaseConfigs(rootPath, projectId) {
+    if (!projectId) {
+        return;
+    }
+    const firebaserc = {
+        projects: {
+            default: projectId,
+        },
+    };
+    await fs.writeFile(path.join(rootPath, ".firebaserc"), JSON.stringify(firebaserc, null, 2));
+    logger_1.logger.info("✅ Created .firebaserc");
+    const firebaseJsonPath = path.join(rootPath, "firebase.json");
+    try {
+        await fs.access(firebaseJsonPath);
+        logger_1.logger.info("ℹ️ firebase.json already exists, skipping creation.");
+    }
+    catch {
+        let backendId = "studio";
+        try {
+            logger_1.logger.info(`⏳ Fetching App Hosting backends for project ${projectId}...`);
+            const backendsData = await apphosting.listBackends(projectId, "-");
+            const backends = backendsData.backends || [];
+            if (backends.length > 0) {
+                const studioBackend = backends.find((b) => b.name.endsWith("/studio") || b.name.toLowerCase().includes("studio"));
+                if (studioBackend) {
+                    backendId = studioBackend.name.split("/").pop();
+                }
+                else {
+                    backendId = backends[0].name.split("/").pop();
+                }
+                logger_1.logger.info(`✅ Selected App Hosting backend: ${backendId}`);
+            }
+            else {
+                utils.logWarning('No App Hosting backends found, using default "studio"');
+            }
+        }
+        catch (err) {
+            utils.logWarning(`Could not fetch backends from Firebase CLI, using default "studio". ${err}`);
+        }
+        const firebaseJson = {
+            apphosting: {
+                backendId: backendId,
+                ignore: [
+                    "node_modules",
+                    ".git",
+                    ".agent",
+                    ".idx",
+                    "firebase-debug.log",
+                    "firebase-debug.*.log",
+                    "functions",
+                ],
+            },
+        };
+        await fs.writeFile(firebaseJsonPath, JSON.stringify(firebaseJson, null, 2));
+        logger_1.logger.info(`✅ Created firebase.json with backendId: ${backendId}`);
+    }
+}
+async function writeAgyConfigs(rootPath) {
+    const vscodeDir = path.join(rootPath, ".vscode");
+    await fs.mkdir(vscodeDir, { recursive: true });
+    const tasksJson = {
+        version: "2.0.0",
+        tasks: [
+            {
+                label: "npm-install",
+                type: "shell",
+                command: "npm install",
+                problemMatcher: [],
+            },
+        ],
+    };
+    await fs.writeFile(path.join(vscodeDir, "tasks.json"), JSON.stringify(tasksJson, null, 2));
+    logger_1.logger.info("✅ Created .vscode/tasks.json");
+    const settingsPath = path.join(vscodeDir, "settings.json");
+    let settings = {};
+    try {
+        const settingsContent = await fs.readFile(settingsPath, "utf8");
+        settings = JSON.parse(settingsContent);
+    }
+    catch (err) {
+        logger_1.logger.debug(`Could not read ${settingsPath}: ${err}`);
+    }
+    const cleanSettings = {};
+    for (const [key, value] of Object.entries(settings)) {
+        if (!key.startsWith("IDX.")) {
+            cleanSettings[key] = value;
+        }
+    }
+    cleanSettings["workbench.startupEditor"] = "readme";
+    await fs.writeFile(settingsPath, JSON.stringify(cleanSettings, null, 2));
+    logger_1.logger.info("✅ Updated .vscode/settings.json with startup preferences");
+    const launchJson = {
+        version: "0.2.0",
+        configurations: [
+            {
+                type: "node",
+                request: "launch",
+                name: "Next.js: debug server-side",
+                runtimeExecutable: "npm",
+                runtimeArgs: ["run", "dev"],
+                port: 9002,
+                console: "integratedTerminal",
+                preLaunchTask: "npm-install",
+            },
+        ],
+    };
+    await fs.writeFile(path.join(vscodeDir, "launch.json"), JSON.stringify(launchJson, null, 2));
+    logger_1.logger.info("✅ Created .vscode/launch.json");
+}
+async function cleanupUnusedFiles(rootPath) {
+    const docsDir = path.join(rootPath, "docs");
+    const blueprintPath = path.join(docsDir, "blueprint.md");
+    try {
+        await fs.unlink(blueprintPath);
+        logger_1.logger.info("✅ Cleaned up docs/blueprint.md");
+    }
+    catch (err) {
+        logger_1.logger.debug(`Could not delete ${blueprintPath}: ${err}`);
+    }
+    try {
+        const files = await fs.readdir(docsDir);
+        if (files.length === 0) {
+            await fs.rmdir(docsDir);
+            logger_1.logger.info("✅ Removed empty docs directory");
+        }
+    }
+    catch (err) {
+        logger_1.logger.debug(`Could not remove ${docsDir}: ${err}`);
+    }
+    const metadataPath = path.join(rootPath, "metadata.json");
+    try {
+        await fs.unlink(metadataPath);
+        logger_1.logger.info("✅ Cleaned up metadata.json");
+    }
+    catch (err) {
+        logger_1.logger.debug(`Could not delete ${metadataPath}: ${err}`);
+    }
+    const modifiedPath = path.join(rootPath, ".modified");
+    try {
+        await fs.unlink(modifiedPath);
+        logger_1.logger.info("✅ Cleaned up .modified");
+    }
+    catch (err) {
+        logger_1.logger.debug(`Could not delete ${modifiedPath}: ${err}`);
+    }
+}
+async function uploadSecrets(rootPath, projectId) {
+    if (!projectId) {
+        return;
+    }
+    const envPath = path.join(rootPath, ".env");
+    try {
+        await fs.access(envPath);
+    }
+    catch {
+        return;
+    }
+    try {
+        const envContent = await fs.readFile(envPath, "utf8");
+        const parsedEnv = env.parse(envContent);
+        const geminiApiKey = parsedEnv.envs["GEMINI_API_KEY"];
+        if (geminiApiKey && geminiApiKey.trim().length > 0) {
+            logger_1.logger.info("⏳ Uploading GEMINI_API_KEY from .env to App Hosting secrets...");
+            await (0, secrets_1.apphostingSecretsSetAction)("GEMINI_API_KEY", projectId, undefined, undefined, envPath, true);
+            logger_1.logger.info("✅ Uploaded GEMINI_API_KEY secret");
+        }
+        else {
+            logger_1.logger.debug("Skipping GEMINI_API_KEY upload: key is missing or blank in .env");
+        }
+    }
+    catch (err) {
+        utils.logWarning(`Failed to upload GEMINI_API_KEY secret: ${err}`);
+    }
+}
+async function askToOpenAntigravity(rootPath, appName, startAgy) {
+    if (startAgy === false) {
+        logger_1.logger.info('\n👉 Next steps: Open this folder in Antigravity and run the "Initial Project Setup" workflow.');
+        return;
+    }
+    const answer = await prompt.confirm({
+        message: `Migration complete for ${appName}! Would you like to open it in Antigravity now?`,
+        default: true,
+    });
+    if (answer) {
+        logger_1.logger.info(`⏳ Opening ${appName} in Antigravity...`);
+        try {
+            const agyProcess = (0, child_process_1.spawn)("agy", ["."], {
+                cwd: rootPath,
+                stdio: "ignore",
+                detached: true,
+            });
+            agyProcess.unref();
+        }
+        catch (err) {
+            utils.logWarning("Could not open Antigravity IDE automatically. Please open it manually.");
+        }
+    }
+    else {
+        logger_1.logger.info('\n👉 Next steps: Open this folder in Antigravity and run the "Initial Project Setup" workflow.');
+    }
+}
+async function migrate(rootPath, options = { startAgy: true }) {
+    logger_1.logger.info("🚀 Starting Firebase Studio to Antigravity migration...");
+    await assertSystemState(options.startAgy);
+    const { projectId, appName, blueprintContent } = await extractMetadata(rootPath, options.project);
+    await updateReadme(rootPath, blueprintContent, appName);
+    await createFirebaseConfigs(rootPath, projectId);
+    await uploadSecrets(rootPath, projectId);
+    await injectAgyContext(rootPath, projectId, appName);
+    await writeAgyConfigs(rootPath);
+    await cleanupUnusedFiles(rootPath);
+    const currentFolderName = path.basename(rootPath);
+    if (currentFolderName === "download") {
+        logger_1.logger.info(`\n💡 Tip: You might want to rename this folder to "${appName.toLowerCase().replace(/\s+/g, "-")}"`);
+    }
+    await askToOpenAntigravity(rootPath, appName, options.startAgy);
+}

package/lib/functionsConfig.js

@@ -27,11 +27,11 @@ const utils_1 = require("./utils");
 exports.RESERVED_NAMESPACES = ["firebase"];
 const apiClient = new apiv2_1.Client({ urlPrefix: (0, api_1.firebaseApiOrigin)() });
 const LEGACY_RUNTIME_CONFIG_EXPERIMENT = "legacyRuntimeConfigCommands";
-const FUNCTIONS_CONFIG_DEPRECATION_MESSAGE = `DEPRECATION NOTICE: Action required before March 2026
+const FUNCTIONS_CONFIG_DEPRECATION_MESSAGE = `DEPRECATION NOTICE: Action required before March 2027
 
-The functions.config() API and the Cloud Runtime Config service are deprecated. Deploys that rely on functions.config() will fail once Runtime Config shuts down in March 2026.
+The functions.config() API and the Cloud Runtime Config service are deprecated. Deploys that rely on functions.config() will fail once Runtime Config shuts down in March 2027.
 
-The legacy functions:config:* CLI commands are deprecated and will be removed before March 2026.
+The legacy functions:config:* CLI commands are deprecated and will be removed before March 2027.
 
 Learn how to migrate from functions.config() to the params package:
 

package/lib/gcp/cloudsql/cloudsqladmin.js

@@ -23,6 +23,7 @@ const projectUtils_1 = require("../../projectUtils");
 const logger_1 = require("../../logger");
 const iam_1 = require("../iam");
 const error_1 = require("../../error");
+const freeTrial_1 = require("../../dataconnect/freeTrial");
 const API_VERSION = "v1";
 const client = new apiv2_1.Client({
     urlPrefix: (0, api_1.cloudSQLAdminOrigin)(),
@@ -91,7 +92,7 @@ async function createInstance(args) {
         return;
     }
     catch (err) {
-        handleAllowlistError(err, args.location);
+        await handleCreateInstanceError(err, args.location, args.projectId);
         throw err;
     }
 }
@@ -119,10 +120,14 @@ async function updateInstanceForDataConnect(instance, enableGoogleMlIntegration)
     });
     return pollRes;
 }
-function handleAllowlistError(err, region) {
-    if (err.message.includes("Not allowed to set system label: firebase-data-connect")) {
+async function handleCreateInstanceError(err, region, projectId) {
+    if (err?.message?.includes("Not allowed to set system label: firebase-data-connect")) {
         throw new error_1.FirebaseError(`Cloud SQL free trial instances are not yet available in ${region}. Please check https://firebase.google.com/docs/data-connect/ for a full list of available regions.`);
     }
+    if (err?.message?.includes("The billing account is not in good standing") &&
+        (await (0, freeTrial_1.checkFreeTrialInstanceUsed)(projectId))) {
+        throw new error_1.FirebaseError(`You have already used your Cloud SQL free trial. To create more instances, you need to attach a billing account to project ${projectId}.`);
+    }
 }
 function setDatabaseFlag(flag, flags = []) {
     const temp = flags.filter((f) => f.name !== flag.name);

package/lib/gcp/cloudsql/fbToolsAuthClient.js

@@ -36,7 +36,7 @@ class FBToolsAuthClient extends google_auth_library_1.AuthClient {
     async getRequestHeaders() {
         const token = await this.getAccessToken();
         return {
-            ...apiv2.STANDARD_HEADERS,
+            ...apiv2.standardHeaders(),
             Authorization: `Bearer ${token.token}`,
         };
     }

package/lib/mcp/prompts/apptesting/run_test.js

@@ -64,8 +64,9 @@ Here are a list of prerequisite steps that must be completed before running a te
 
 	* Goal (required): In one sentence or less, describe what you want the agent to do in this step.
 	* Hint (optional): Provide additional information to help Gemini understand and navigate your app.
-	* Success Criteria (optional): Your success criteria should be phrased as an observation, such as 'The screen shows a
-    success message' or 'The checkout page is visible'.
+	* Final Screen Assertion (required for last step): Your final screen assertion should be phrased as an observation, such
+    as 'The screen shows a success message' or 'The checkout page is visible'. You can think of these as test assertions
+    that are checked at the end of the step. Optional except for the last step, for which it is required.
 
   The developer has optionally specified the following description for their test:
   * ${testDescription}
@@ -79,8 +80,8 @@ Here are a list of prerequisite steps that must be completed before running a te
     For example, if a step has a list in it, it should probably be broken up into multiple steps. Steps do not need
     to be too small though. The test case should provide a good balance between strict guidance and flexibility. As a
     rule of thumb, each step should require between 2-5 actions.
-	* Include a hint and success criteria whenever possible. Specifically, try to always include a success criteria to help
-    the agent determine when the goal has been completed.
+	* Include a hint and final screen assertion whenever possible. Specifically, try to always include a final screen assertion
+    to help the agent determine when the goal has been completed.
 	* Avoid functionality that the app testing agent struggles with. The app testing agent struggles with the following:
 		* Journeys that require specific timing (like observing that something should be visible for a certain number of
       seconds), interacting with moving or transient elements, etc.
@@ -96,7 +97,7 @@ Here are a list of prerequisite steps that must be completed before running a te
   above, convert the test description provided by the user to make it easier for the agent to follow so that the tests can
   be re-run reliably. If there is no test description, generate a test case that you think will be useful given the functionality 
   of the app. Generate an explanation on why you generated the new test case the way you did, and then generate the
-  new test case, which again is an array of steps where each step contains a goal, hint, and success criteria. Show this
+  new test case, which again is an array of steps where each step contains a goal, hint, and final screen assertion. Show this
   to the user and have them confirm before moving forward. 
 
 ## Run Test

package/lib/mcp/tools/apptesting/tests.js

@@ -17,17 +17,17 @@ const TestDeviceSchema = zod_1.z
     orientation: zod_1.z.string(),
 })
     .describe(`Device to run automated test on. Can run 'gcloud firebase test android|ios models list' to see available devices.`);
-const AIStepSchema = zod_1.z
+const AiStepSchema = zod_1.z
     .object({
     goal: zod_1.z.string().describe("A goal to be accomplished during the test."),
     hint: zod_1.z
         .string()
         .optional()
         .describe("Hint text containing suggestions to help the agent accomplish the goal."),
-    successCriteria: zod_1.z
+    finalScreenAssertion: zod_1.z
         .string()
         .optional()
-        .describe("A description of criteria the agent should use to determine if the goal has been successfully completed."),
+        .describe("A description of what the screen should look like at the end of the step, to determine if the goal has been successfully completed."),
 })
     .describe("Step within a test case; run during the execution of the test.");
 const defaultDevices = [
@@ -47,7 +47,7 @@ exports.run_tests = (0, tool_1.tool)("apptesting", {
         testDevices: zod_1.z.array(TestDeviceSchema).default(defaultDevices),
         testCase: zod_1.z.object({
             steps: zod_1.z
-                .array(AIStepSchema)
+                .array(AiStepSchema)
                 .describe("Test case containing the steps that are run during its execution."),
         }),
     }),