firebase-tools 15.19.0 → 15.19.1

package/lib/gemini/fdcExperience.js

@@ -7,41 +7,186 @@ exports.extractCodeBlock = extractCodeBlock;
 const apiv2_1 = require("../apiv2");
 const api_1 = require("../api");
 const error_1 = require("../error");
-const apiClient = new apiv2_1.Client({ urlPrefix: (0, api_1.cloudAiCompanionOrigin)(), auth: true });
-const SCHEMA_GENERATOR_EXPERIENCE = "/appeco/firebase/fdc-schema-generator";
-const OPERATION_GENERATION_EXPERIENCE = "/appeco/firebase/fdc-query-generator";
-const FIREBASE_CHAT_REQUEST_CONTEXT_TYPE_NAME = "type.googleapis.com/google.cloud.cloudaicompanion.v1main.FirebaseChatRequestContext";
+const logger_1 = require("../logger");
+const apiClient = new apiv2_1.Client({ urlPrefix: (0, api_1.dataconnectOrigin)(), auth: true });
 exports.PROMPT_GENERATE_CONNECTOR = "Create 4 operations for an app using the instance schema with proper authentication.";
 exports.PROMPT_GENERATE_SEED_DATA = "Create a mutation to populate the database with some seed data.";
-async function generateSchema(prompt, project, chatHistory = []) {
-    const res = await apiClient.post(`/v1beta/projects/${project}/locations/global/instances/default:completeTask`, {
-        input: { messages: [...chatHistory, { content: prompt, author: "USER" }] },
-        experienceContext: {
-            experience: SCHEMA_GENERATOR_EXPERIENCE,
-        },
+function logCurl(method, path, body) {
+    const url = `${(0, api_1.dataconnectOrigin)()}${path}`;
+    const headers = [
+        '-H "Content-Type: application/json"',
+        '-H "Authorization: Bearer $(gcloud auth print-access-token)"',
+    ].join(" ");
+    const curl = `curl -X ${method} "${url}" ${headers} -d '${JSON.stringify(body)}'`;
+    logger_1.logger.debug(`[Agent Service] Reusable cURL command:\\n${curl}`);
+}
+async function generateSchema(prompt, project, location, onStatus) {
+    const path = `/v1/projects/${project}/locations/${location}/services/-:generateSchema`;
+    const body = {
+        name: `projects/${project}/locations/${location}/services/-`,
+        prompt,
+    };
+    logCurl("POST", path, body);
+    const res = await apiClient.request({
+        method: "POST",
+        path,
+        body,
+        responseType: "stream",
+        resolveOnHTTPError: true,
+    });
+    if (res.status >= 400) {
+        const errorText = await readStream(res.body);
+        throw new error_1.FirebaseError(`Failed to generate schema. Status: ${res.status}, Message: ${errorText}`);
+    }
+    return consumeStream(res.body, onStatus);
+}
+async function generateOperation(prompt, service, project, schemas, onStatus) {
+    let location = "us-central1";
+    let serviceId = service;
+    if (service.startsWith("projects/")) {
+        const parts = service.split("/");
+        project = parts[1];
+        location = parts[3];
+        serviceId = parts[5];
+    }
+    if (schemas && schemas.length > 0) {
+        serviceId = "-";
+    }
+    const path = `/v1/projects/${project}/locations/${location}/services/${serviceId}:generateQuery`;
+    const body = {
+        name: `projects/${project}/locations/${location}/services/${serviceId}`,
+        prompt,
+        schemas,
+    };
+    logCurl("POST", path, body);
+    const res = await apiClient.request({
+        method: "POST",
+        path,
+        body,
+        responseType: "stream",
+        resolveOnHTTPError: true,
     });
-    return extractCodeBlock(res.body.output.messages[0].content);
+    if (res.status >= 400) {
+        const errorText = await readStream(res.body);
+        throw new error_1.FirebaseError(`Failed to generate operation. Status: ${res.status}, Message: ${errorText}`);
+    }
+    return consumeStream(res.body, onStatus);
 }
-async function generateOperation(prompt, service, project, chatHistory = []) {
-    const res = await apiClient.post(`/v1beta/projects/${project}/locations/global/instances/default:completeTask`, {
-        input: { messages: [...chatHistory, { content: prompt, author: "USER" }] },
-        experienceContext: {
-            experience: OPERATION_GENERATION_EXPERIENCE,
-        },
-        clientContext: {
-            additionalContext: {
-                "@type": FIREBASE_CHAT_REQUEST_CONTEXT_TYPE_NAME,
-                fdcInfo: { fdcServiceName: service, requiresQuery: true },
-            },
-        },
+async function readStream(stream) {
+    return new Promise((resolve, reject) => {
+        let data = "";
+        stream.on("data", (chunk) => {
+            data += chunk.toString();
+        });
+        stream.on("end", () => {
+            resolve(data);
+        });
+        stream.on("error", (err) => {
+            reject(err);
+        });
+    });
+}
+async function consumeStream(stream, onStatus) {
+    return new Promise((resolve, reject) => {
+        let buffer = "";
+        let fullText = "";
+        stream.on("data", (chunk) => {
+            const text = chunk.toString();
+            fullText += text;
+            buffer += text;
+            let newlineIndex;
+            while ((newlineIndex = buffer.indexOf("\n")) !== -1) {
+                const line = buffer.substring(0, newlineIndex).trim();
+                buffer = buffer.substring(newlineIndex + 1);
+                if (line) {
+                    try {
+                        const obj = JSON.parse(line);
+                        if (obj.status && onStatus) {
+                            onStatus(obj.status);
+                        }
+                    }
+                    catch (err) {
+                    }
+                }
+            }
+        });
+        stream.on("end", () => {
+            try {
+                const response = JSON.parse(fullText);
+                if (Array.isArray(response)) {
+                    let code = "";
+                    for (const item of response) {
+                        if (item.status && onStatus) {
+                            onStatus(item.status);
+                        }
+                        if (item.part?.textChunk?.text) {
+                            code += item.part.textChunk.text;
+                        }
+                        if (item.part?.codeChunk?.code) {
+                            code += item.part.codeChunk.code;
+                        }
+                    }
+                    if (code) {
+                        resolve(extractCodeBlock(code));
+                    }
+                    else {
+                        resolve(fullText);
+                    }
+                }
+                else {
+                    const resObj = response;
+                    if (resObj.part?.codeChunk?.code) {
+                        resolve(extractCodeBlock(resObj.part.codeChunk.code));
+                    }
+                    else if (resObj.part?.textChunk?.text) {
+                        resolve(extractCodeBlock(resObj.part.textChunk.text));
+                    }
+                    else {
+                        resolve(fullText);
+                    }
+                }
+            }
+            catch (e) {
+                const lines = fullText.trim().split("\n");
+                let code = "";
+                for (const line of lines) {
+                    try {
+                        const obj = JSON.parse(line);
+                        if (obj.part?.codeChunk?.code) {
+                            code += obj.part.codeChunk.code;
+                        }
+                        else if (obj.part?.textChunk?.text) {
+                            code += obj.part.textChunk.text;
+                        }
+                        if (obj.status && onStatus) {
+                            onStatus(obj.status);
+                        }
+                    }
+                    catch (err) {
+                        logger_1.logger.error("Failed to parse FSQL Generate response: ", err);
+                    }
+                }
+                if (code) {
+                    resolve(extractCodeBlock(code));
+                }
+                else {
+                    resolve(fullText);
+                }
+            }
+        });
+        stream.on("error", (err) => {
+            reject(err);
+        });
     });
-    return extractCodeBlock(res.body.output.messages[0].content);
 }
 function extractCodeBlock(text) {
     const regex = /```(?:[a-z]+\n)?([\s\S]*?)```/m;
-    const match = text.match(regex);
+    const match = regex.exec(text);
     if (match && match[1]) {
         return match[1].trim();
     }
-    throw new error_1.FirebaseError(`No code block found in the generated response: ${text}`);
+    if (!text.includes("{")) {
+        logger_1.logger.warn("[Agent Service] Response seems to be plain text, no GraphQL code block found.");
+    }
+    return text.trim();
 }

package/lib/init/features/dataconnect/index.js

@@ -79,7 +79,6 @@ async function askQuestions(setup, config, options) {
             });
             if (wantToGenerate) {
                 configstore_1.configstore.set("gemini", true);
-                await (0, ensureApis_1.ensureGIFApiTos)(setup.projectId);
                 info.appDescription = await (0, prompt_1.input)({
                     message: `Describe your app idea:`,
                     validate: async (s) => {
@@ -168,25 +167,59 @@ async function actuateWithInfo(setup, config, info, options) {
         return await writeFiles(config, info, templateServiceInfo, options);
     }
     const serviceAlreadyExists = !(await (0, client_1.createService)(projectId, info.locationId, info.serviceId));
-    const schemaGql = await (0, utils_1.promiseWithSpinner)(() => (0, fdcExperience_1.generateSchema)(info.appDescription, projectId), "Generating the SQL Connect Schema...");
+    const schemaGql = await (0, utils_1.promiseWithSpinner)(() => (0, fdcExperience_1.generateSchema)(info.appDescription, projectId, info.locationId), "Generating the SQL Connect Schema...");
     const schemaFiles = [{ path: "schema.gql", content: schemaGql }];
     if (serviceAlreadyExists) {
         (0, utils_1.logLabeledError)("dataconnect", `SQL Connect Service ${serviceName} already exists. Skip saving them...`);
         info.flow += "_save_gemini_service_already_exists";
         return await writeFiles(config, info, { schemaGql: schemaFiles, connectors: [] }, options);
     }
+    const schemas = [
+        {
+            name: `${serviceName}/schemas/${types_1.MAIN_SCHEMA_ID}`,
+            datasources: [],
+            source: {
+                files: schemaFiles,
+            },
+        },
+    ];
+    let operationGql = "";
+    let seedDataGql = "";
+    let genOperationsSuccess = false;
+    let genOperationsError = null;
     await (0, utils_1.promiseWithSpinner)(async () => {
-        const [saveSchemaGql, waitForCloudSQLProvision] = schemasDeploySequence(projectId, info, schemaFiles, info.shouldProvisionCSQL);
-        await (0, client_1.upsertSchema)(saveSchemaGql);
-        if (waitForCloudSQLProvision) {
-            void (0, client_1.upsertSchema)(waitForCloudSQLProvision);
+        const deployPromise = (async () => {
+            const [saveSchemaGql, waitForCloudSQLProvision] = schemasDeploySequence(projectId, info, schemaFiles, info.shouldProvisionCSQL);
+            await (0, client_1.upsertSchema)(saveSchemaGql);
+            if (waitForCloudSQLProvision) {
+                void (0, client_1.upsertSchema)(waitForCloudSQLProvision);
+            }
+        })();
+        const opPromise = (async () => {
+            try {
+                const [op, seed] = await Promise.all([
+                    (0, fdcExperience_1.generateOperation)(fdcExperience_1.PROMPT_GENERATE_CONNECTOR, serviceName, projectId, schemas),
+                    (0, fdcExperience_1.generateOperation)(fdcExperience_1.PROMPT_GENERATE_SEED_DATA, serviceName, projectId, schemas),
+                ]);
+                return { op, seed, success: true };
+            }
+            catch (err) {
+                (0, utils_1.logLabeledError)("dataconnect", `Deployment failed: ${err instanceof Error ? err.message : String(err)}`);
+                return { success: false, error: err };
+            }
+        })();
+        const [, opResult] = await Promise.all([deployPromise, opPromise]);
+        if (opResult.success && opResult.op && opResult.seed) {
+            operationGql = opResult.op;
+            seedDataGql = opResult.seed;
+            genOperationsSuccess = true;
         }
-    }, "Saving the SQL Connect Schema...");
-    try {
-        const [operationGql, seedDataGql] = await (0, utils_1.promiseWithSpinner)(() => Promise.all([
-            (0, fdcExperience_1.generateOperation)(fdcExperience_1.PROMPT_GENERATE_CONNECTOR, serviceName, projectId),
-            (0, fdcExperience_1.generateOperation)(fdcExperience_1.PROMPT_GENERATE_SEED_DATA, serviceName, projectId),
-        ]), "Generating the SQL Connect Operations...");
+        else {
+            (0, utils_1.logLabeledError)("dataconnect", `Operation Generation failed...`);
+            genOperationsError = opResult.error;
+        }
+    }, "Saving the SQL Connect Schema and generating operations...");
+    if (genOperationsSuccess) {
         const connectors = [
             {
                 id: "example",
@@ -202,11 +235,12 @@ async function actuateWithInfo(setup, config, info, options) {
         info.flow += "_save_gemini";
         await writeFiles(config, info, { schemaGql: schemaFiles, connectors: connectors, seedDataGql: seedDataGql }, options);
     }
-    catch (err) {
-        (0, utils_1.logLabeledError)("dataconnect", `Operation Generation failed...`);
+    else {
         info.flow += "_save_gemini_operation_error";
         await writeFiles(config, info, { schemaGql: schemaFiles, connectors: [] }, options);
-        throw err;
+    }
+    if (genOperationsError) {
+        throw genOperationsError;
     }
 }
 function schemasDeploySequence(projectId, info, schemaFiles, linkToCloudSql) {