@tinybirdco/sdk 0.0.51 → 0.0.53

package/src/api/deploy.test.ts

@@ -1,4 +1,4 @@
-import { describe, it, expect, beforeAll, beforeEach, afterEach, afterAll } from "vitest";
+import { describe, it, expect, beforeAll, afterEach, afterAll, vi } from "vitest";
 import { setupServer } from "msw/node";
 import { http, HttpResponse } from "msw";
 import { deployToMain } from "./deploy.js";
@@ -6,25 +6,14 @@ import type { BuildConfig } from "./build.js";
 import {
   BASE_URL,
   createDeploySuccessResponse,
-  createDeploymentStatusResponse,
-  createSetLiveSuccessResponse,
   createBuildFailureResponse,
   createBuildMultipleErrorsResponse,
-  createDeploymentsListResponse,
 } from "../test/handlers.js";
 import type { GeneratedResources } from "../generator/index.js";
 
 const server = setupServer();
 
 beforeAll(() => server.listen({ onUnhandledRequest: "error" }));
-beforeEach(() => {
-  // Set up default handler for deployments list (used by stale deployment cleanup)
-  server.use(
-    http.get(`${BASE_URL}/v1/deployments`, () => {
-      return HttpResponse.json(createDeploymentsListResponse());
-    })
-  );
-});
 afterEach(() => server.resetHandlers());
 afterAll(() => server.close());
 
@@ -35,17 +24,12 @@ describe("Deploy API", () => {
   };
 
   const resources: GeneratedResources = {
-    datasources: [
-      { name: "events", content: "SCHEMA > timestamp DateTime" },
-    ],
-    pipes: [
-      { name: "top_events", content: "NODE main\nSQL > SELECT * FROM events" },
-    ],
+    datasources: [{ name: "events", content: "SCHEMA > timestamp DateTime" }],
+    pipes: [{ name: "top_events", content: "NODE main\nSQL > SELECT * FROM events" }],
     connections: [],
   };
 
-  // Helper to set up successful deploy flow
-  function setupSuccessfulDeployFlow(deploymentId = "deploy-abc") {
+  function setupAutoPromoteSuccessFlow(deploymentId = "deploy-abc") {
     server.use(
       http.post(`${BASE_URL}/v1/deploy`, () => {
         return HttpResponse.json(
@@ -53,64 +37,42 @@ describe("Deploy API", () => {
         );
       }),
       http.get(`${BASE_URL}/v1/deployments/${deploymentId}`, () => {
-        return HttpResponse.json(
-          createDeploymentStatusResponse({ deploymentId, status: "data_ready" })
-        );
-      }),
-      http.post(`${BASE_URL}/v1/deployments/${deploymentId}/set-live`, () => {
-        return HttpResponse.json(createSetLiveSuccessResponse());
+        return HttpResponse.json({
+          result: "success",
+          deployment: {
+            id: deploymentId,
+            status: "data_ready",
+            live: true,
+          },
+        });
       })
     );
   }
 
   describe("deployToMain", () => {
-    it("successfully deploys resources with full flow", async () => {
-      setupSuccessfulDeployFlow("deploy-abc");
+    it("successfully deploys resources with auto-promote flow", async () => {
+      setupAutoPromoteSuccessFlow("deploy-abc");
 
-      const result = await deployToMain(config, resources, { pollIntervalMs: 1 });
+      const onDeploymentLive = vi.fn();
+      const result = await deployToMain(config, resources, {
+        pollIntervalMs: 1,
+        callbacks: { onDeploymentLive },
+      });
 
       expect(result.success).toBe(true);
       expect(result.result).toBe("success");
       expect(result.buildId).toBe("deploy-abc");
       expect(result.datasourceCount).toBe(1);
       expect(result.pipeCount).toBe(1);
-    });
-
-    it("polls until deployment is ready", async () => {
-      let pollCount = 0;
-
-      server.use(
-        http.post(`${BASE_URL}/v1/deploy`, () => {
-          return HttpResponse.json(
-            createDeploySuccessResponse({ deploymentId: "deploy-poll", status: "pending" })
-          );
-        }),
-        http.get(`${BASE_URL}/v1/deployments/deploy-poll`, () => {
-          pollCount++;
-          // Return pending for first 2 polls, then data_ready
-          const status = pollCount < 3 ? "pending" : "data_ready";
-          return HttpResponse.json(
-            createDeploymentStatusResponse({ deploymentId: "deploy-poll", status })
-          );
-        }),
-        http.post(`${BASE_URL}/v1/deployments/deploy-poll/set-live`, () => {
-          return HttpResponse.json(createSetLiveSuccessResponse());
-        })
-      );
-
-      const result = await deployToMain(config, resources, { pollIntervalMs: 1 });
-
-      expect(result.success).toBe(true);
-      expect(pollCount).toBe(3);
+      expect(onDeploymentLive).toHaveBeenCalledWith("deploy-abc");
     });
 
     it("handles deploy failure with single error", async () => {
       server.use(
         http.post(`${BASE_URL}/v1/deploy`, () => {
-          return HttpResponse.json(
-            createBuildFailureResponse("Permission denied"),
-            { status: 200 }
-          );
+          return HttpResponse.json(createBuildFailureResponse("Permission denied"), {
+            status: 200,
+          });
         })
       );
 
@@ -144,10 +106,7 @@ describe("Deploy API", () => {
     it("handles HTTP error responses", async () => {
       server.use(
         http.post(`${BASE_URL}/v1/deploy`, () => {
-          return HttpResponse.json(
-            { result: "failed", error: "Forbidden" },
-            { status: 403 }
-          );
+          return HttpResponse.json({ result: "failed", error: "Forbidden" }, { status: 403 });
         })
       );
 
@@ -167,28 +126,24 @@ describe("Deploy API", () => {
         })
       );
 
-      await expect(deployToMain(config, resources)).rejects.toThrow(
-        "Failed to parse response"
-      );
+      await expect(deployToMain(config, resources)).rejects.toThrow("Failed to parse response");
     });
 
-    it("uses /v1/deploy endpoint (not /v1/build)", async () => {
+    it("uses /v1/deploy endpoint and sends auto_promote by default", async () => {
       let capturedUrl: string | null = null;
 
       server.use(
         http.post(`${BASE_URL}/v1/deploy`, ({ request }) => {
           capturedUrl = request.url;
           return HttpResponse.json(
-            createDeploySuccessResponse({ deploymentId: "deploy-url-test" })
+            createDeploySuccessResponse({ deploymentId: "deploy-url-test", status: "pending" })
           );
         }),
         http.get(`${BASE_URL}/v1/deployments/deploy-url-test`, () => {
-          return HttpResponse.json(
-            createDeploymentStatusResponse({ deploymentId: "deploy-url-test", status: "data_ready" })
-          );
-        }),
-        http.post(`${BASE_URL}/v1/deployments/deploy-url-test/set-live`, () => {
-          return HttpResponse.json(createSetLiveSuccessResponse());
+          return HttpResponse.json({
+            result: "success",
+            deployment: { id: "deploy-url-test", status: "data_ready", live: true },
+          });
         })
       );
 
@@ -197,49 +152,76 @@ describe("Deploy API", () => {
       const parsed = new URL(capturedUrl ?? "");
       expect(parsed.pathname).toBe("/v1/deploy");
       expect(parsed.searchParams.get("from")).toBe("ts-sdk");
+      expect(parsed.searchParams.get("auto_promote")).toBe("true");
     });
 
-    it("handles failed deployment status", async () => {
+    it("passes allow_destructive_operations when explicitly enabled", async () => {
+      let capturedUrl: string | null = null;
+
       server.use(
-        http.post(`${BASE_URL}/v1/deploy`, () => {
+        http.post(`${BASE_URL}/v1/deploy`, ({ request }) => {
+          capturedUrl = request.url;
           return HttpResponse.json(
-            createDeploySuccessResponse({ deploymentId: "deploy-fail", status: "pending" })
+            createDeploySuccessResponse({ deploymentId: "deploy-destructive", status: "pending" })
           );
         }),
-        http.get(`${BASE_URL}/v1/deployments/deploy-fail`, () => {
-          return HttpResponse.json(
-            createDeploymentStatusResponse({ deploymentId: "deploy-fail", status: "failed" })
-          );
+        http.get(`${BASE_URL}/v1/deployments/deploy-destructive`, () => {
+          return HttpResponse.json({
+            result: "success",
+            deployment: { id: "deploy-destructive", status: "data_ready", live: true },
+          });
         })
       );
 
-      const result = await deployToMain(config, resources, { pollIntervalMs: 1 });
+      await deployToMain(config, resources, {
+        pollIntervalMs: 1,
+        allowDestructiveOperations: true,
+      });
 
-      expect(result.success).toBe(false);
-      expect(result.error).toContain("Deployment failed with status: failed");
+      const parsed = new URL(capturedUrl ?? "");
+      expect(parsed.searchParams.get("allow_destructive_operations")).toBe("true");
+      expect(parsed.searchParams.get("auto_promote")).toBe("true");
+    });
+
+    it("does not send auto_promote in check mode", async () => {
+      let capturedUrl: string | null = null;
+
+      server.use(
+        http.post(`${BASE_URL}/v1/deploy`, ({ request }) => {
+          capturedUrl = request.url;
+          return HttpResponse.json({ result: "success" });
+        })
+      );
+
+      const result = await deployToMain(config, resources, { check: true });
+
+      expect(result.success).toBe(true);
+      const parsed = new URL(capturedUrl ?? "");
+      expect(parsed.searchParams.get("check")).toBe("true");
+      expect(parsed.searchParams.get("auto_promote")).toBeNull();
     });
 
-    it("handles set-live failure", async () => {
+    it("adds actionable guidance to Forward/Classic workspace errors", async () => {
       server.use(
         http.post(`${BASE_URL}/v1/deploy`, () => {
           return HttpResponse.json(
-            createDeploySuccessResponse({ deploymentId: "deploy-setlive-fail" })
+            {
+              result: "failed",
+              error:
+                "This is a Tinybird Forward workspace, and this operation is only available for Tinybird Classic workspaces.",
+            },
+            { status: 400 }
           );
-        }),
-        http.get(`${BASE_URL}/v1/deployments/deploy-setlive-fail`, () => {
-          return HttpResponse.json(
-            createDeploymentStatusResponse({ deploymentId: "deploy-setlive-fail", status: "data_ready" })
-          );
-        }),
-        http.post(`${BASE_URL}/v1/deployments/deploy-setlive-fail/set-live`, () => {
-          return HttpResponse.json({ error: "Set live failed" }, { status: 500 });
         })
       );
 
-      const result = await deployToMain(config, resources, { pollIntervalMs: 1 });
+      const result = await deployToMain(config, resources);
 
       expect(result.success).toBe(false);
-      expect(result.error).toContain("Failed to set deployment as live");
+      expect(result.error).toContain("Tinybird Forward workspace");
+      expect(result.error).toContain(
+        "Use the Tinybird Classic CLI (`tb`) from a Tinybird Classic workspace for this operation."
+      );
     });
 
     it("normalizes baseUrl with trailing slash", async () => {
@@ -249,16 +231,14 @@ describe("Deploy API", () => {
         http.post(`${BASE_URL}/v1/deploy`, ({ request }) => {
           capturedUrl = request.url;
           return HttpResponse.json(
-            createDeploySuccessResponse({ deploymentId: "deploy-slash" })
+            createDeploySuccessResponse({ deploymentId: "deploy-slash", status: "pending" })
           );
         }),
         http.get(`${BASE_URL}/v1/deployments/deploy-slash`, () => {
-          return HttpResponse.json(
-            createDeploymentStatusResponse({ deploymentId: "deploy-slash", status: "data_ready" })
-          );
-        }),
-        http.post(`${BASE_URL}/v1/deployments/deploy-slash/set-live`, () => {
-          return HttpResponse.json(createSetLiveSuccessResponse());
+          return HttpResponse.json({
+            result: "success",
+            deployment: { id: "deploy-slash", status: "data_ready", live: true },
+          });
         })
       );
 
@@ -271,29 +251,7 @@ describe("Deploy API", () => {
       const parsed = new URL(capturedUrl ?? "");
       expect(parsed.pathname).toBe("/v1/deploy");
       expect(parsed.searchParams.get("from")).toBe("ts-sdk");
-    });
-
-    it("times out when deployment never becomes ready", async () => {
-      server.use(
-        http.post(`${BASE_URL}/v1/deploy`, () => {
-          return HttpResponse.json(
-            createDeploySuccessResponse({ deploymentId: "deploy-timeout", status: "pending" })
-          );
-        }),
-        http.get(`${BASE_URL}/v1/deployments/deploy-timeout`, () => {
-          return HttpResponse.json(
-            createDeploymentStatusResponse({ deploymentId: "deploy-timeout", status: "pending" })
-          );
-        })
-      );
-
-      const result = await deployToMain(config, resources, {
-        pollIntervalMs: 1,
-        maxPollAttempts: 3,
-      });
-
-      expect(result.success).toBe(false);
-      expect(result.error).toContain("Deployment timed out");
+      expect(parsed.searchParams.get("auto_promote")).toBe("true");
     });
   });
 });

package/src/api/deploy.ts

@@ -1,12 +1,15 @@
 /**
  * Deploy resources to Tinybird main workspace
- * Uses the /v1/deploy endpoint to create a deployment, then sets it live
+ * Uses the /v1/deploy endpoint with auto-promotion enabled
  */
 
 import type { GeneratedResources } from "../generator/index.js";
 import type { BuildConfig, BuildApiResult } from "./build.js";
 import { tinybirdFetch } from "./fetcher.js";
 
+const FORWARD_CLASSIC_GUIDANCE =
+  "Use the Tinybird Classic CLI (`tb`) from a Tinybird Classic workspace for this operation.";
+
 /**
  * Feedback item from deployment response
  */
@@ -28,13 +31,6 @@ export interface Deployment {
   feedback?: DeploymentFeedback[];
 }
 
-/**
- * Response from /v1/deployments list endpoint
- */
-export interface DeploymentsListResponse {
-  deployments: Deployment[];
-}
-
 /**
  * Response from /v1/deploy endpoint
  */
@@ -45,6 +41,14 @@ export interface DeployResponse {
   errors?: Array<{ filename?: string; error: string }>;
 }
 
+/**
+ * Response from /v1/deployments/{id} endpoint
+ */
+export interface DeploymentStatusResponse {
+  result: string;
+  deployment: Deployment;
+}
+
 /**
  * Detailed deployment information with resource changes
  */
@@ -71,21 +75,11 @@ export interface DeploymentDetails extends Deployment {
   errors?: Array<{ filename?: string; error: string }>;
 }
 
-/**
- * Response from /v1/deployments/{id} endpoint
- */
-export interface DeploymentStatusResponse {
-  result: string;
-  deployment: Deployment;
-}
-
 /**
  * Deploy generated resources to Tinybird main workspace
  *
  * Uses the /v1/deploy endpoint which accepts all resources in a single
- * multipart form request. After creating the deployment, this function:
- * 1. Polls until the deployment is ready (status === 'data_ready')
- * 2. Sets the deployment as live via /v1/deployments/{id}/set-live
+ * multipart form request.
  *
  * @param config - Build configuration with API URL and token
  * @param resources - Generated resources to deploy
@@ -158,13 +152,14 @@ export async function deployToMain(
     pollIntervalMs?: number;
     maxPollAttempts?: number;
     check?: boolean;
+    autoPromote?: boolean;
     allowDestructiveOperations?: boolean;
     callbacks?: DeployCallbacks;
   }
 ): Promise<BuildApiResult> {
   const debug = options?.debug ?? !!process.env.TINYBIRD_DEBUG;
   const pollIntervalMs = options?.pollIntervalMs ?? 1000;
-  const maxPollAttempts = options?.maxPollAttempts ?? 120; // 2 minutes max
+  const maxPollAttempts = options?.maxPollAttempts ?? 120;
   const baseUrl = config.baseUrl.replace(/\/$/, "");
 
   const formData = new FormData();
@@ -199,46 +194,17 @@ export async function deployToMain(
     );
   }
 
-  // Step 0: Clean up any stale non-live deployments that might block the new deployment
-  try {
-    const deploymentsUrl = `${baseUrl}/v1/deployments`;
-    const deploymentsResponse = await tinybirdFetch(deploymentsUrl, {
-      headers: {
-        Authorization: `Bearer ${config.token}`,
-      },
-    });
-
-    if (deploymentsResponse.ok) {
-      const deploymentsBody = (await deploymentsResponse.json()) as DeploymentsListResponse;
-      const staleDeployments = deploymentsBody.deployments.filter(
-        (d) => !d.live && d.status !== "live"
-      );
-
-      for (const stale of staleDeployments) {
-        if (debug) {
-          console.log(`[debug] Cleaning up stale deployment: ${stale.id} (status: ${stale.status})`);
-        }
-        await tinybirdFetch(`${baseUrl}/v1/deployments/${stale.id}`, {
-          method: "DELETE",
-          headers: {
-            Authorization: `Bearer ${config.token}`,
-          },
-        });
-      }
-    }
-  } catch (e) {
-    // Ignore errors during cleanup - we'll try to deploy anyway
-    if (debug) {
-      console.log(`[debug] Failed to clean up stale deployments: ${e}`);
-    }
-  }
-
-  // Step 1: Create deployment via /v1/deploy
+  // Create deployment via /v1/deploy.
+  // `auto_promote=true` makes the API promote the deployment automatically.
   const deployUrlBase = `${baseUrl}/v1/deploy`;
   const urlParams = new URLSearchParams();
   if (options?.check) {
     urlParams.set("check", "true");
   }
+  const autoPromote = options?.autoPromote ?? !options?.check;
+  if (autoPromote) {
+    urlParams.set("auto_promote", "true");
+  }
   if (options?.allowDestructiveOperations) {
     urlParams.set("allow_destructive_operations", "true");
   }
@@ -280,7 +246,7 @@ export async function deployToMain(
       .map((f) => {
         // Extract just the filename from "Datasource events.datasource" format
         const resourceName = f.resource.split(" ").pop() ?? f.resource;
-        return `${resourceName}: ${f.message}`;
+        return `${resourceName}: ${normalizeDeployErrorMessage(f.message)}`;
       })
       .join("\n");
   };
@@ -298,12 +264,12 @@ export async function deployToMain(
       return body.errors
         .map((e) => {
           const prefix = e.filename ? `[${e.filename}] ` : "";
-          return `${prefix}${e.error}`;
+          return `${prefix}${normalizeDeployErrorMessage(e.error)}`;
         })
         .join("\n");
     }
     if (body.error) {
-      return body.error;
+      return normalizeDeployErrorMessage(body.error);
     }
     // Include raw response body for debugging when no structured error is available
     return `HTTP ${response.status}: ${response.statusText}\nResponse: ${rawBody}`;
@@ -405,18 +371,22 @@ export async function deployToMain(
     });
   }
 
-  // Step 2: Poll until deployment is ready
-  let deployment = body.deployment;
-  let attempts = 0;
+  let deployment = deploymentDetails;
+  let statusAttempts = 0;
 
   options?.callbacks?.onWaitingForReady?.();
 
-  while (deployment.status !== "data_ready" && attempts < maxPollAttempts) {
+  while (
+    deployment.status !== "data_ready" &&
+    deployment.status !== "failed" &&
+    deployment.status !== "error" &&
+    statusAttempts < maxPollAttempts
+  ) {
     await sleep(pollIntervalMs);
-    attempts++;
+    statusAttempts++;
 
     if (debug) {
-      console.log(`[debug] Polling deployment status (attempt ${attempts})...`);
+      console.log(`[debug] Polling deployment status (attempt ${statusAttempts})...`);
     }
 
     const statusUrl = `${baseUrl}/v1/deployments/${deploymentId}`;
@@ -440,30 +410,13 @@ export async function deployToMain(
 
     const statusBody = (await statusResponse.json()) as DeploymentStatusResponse;
     deployment = statusBody.deployment;
-
-    if (debug) {
-      console.log(`[debug] Deployment status: ${deployment.status}`);
-    }
-
-    // Check for failed status
-    if (deployment.status === "failed" || deployment.status === "error") {
-      return {
-        success: false,
-        result: "failed",
-        error: `Deployment failed with status: ${deployment.status}`,
-        datasourceCount: resources.datasources.length,
-        pipeCount: resources.pipes.length,
-        connectionCount: resources.connections?.length ?? 0,
-        buildId: deploymentId,
-      };
-    }
   }
 
-  if (deployment.status !== "data_ready") {
+  if (deployment.status === "failed" || deployment.status === "error") {
     return {
       success: false,
       result: "failed",
-      error: `Deployment timed out after ${maxPollAttempts} attempts. Last status: ${deployment.status}`,
+      error: `Deployment failed with status: ${deployment.status}`,
       datasourceCount: resources.datasources.length,
       pipeCount: resources.pipes.length,
       connectionCount: resources.connections?.length ?? 0,
@@ -471,28 +424,11 @@ export async function deployToMain(
     };
   }
 
-  options?.callbacks?.onDeploymentReady?.();
-
-  // Step 3: Set the deployment as live
-  const setLiveUrl = `${baseUrl}/v1/deployments/${deploymentId}/set-live`;
-
-  if (debug) {
-    console.log(`[debug] POST ${setLiveUrl}`);
-  }
-
-  const setLiveResponse = await tinybirdFetch(setLiveUrl, {
-    method: "POST",
-    headers: {
-      Authorization: `Bearer ${config.token}`,
-    },
-  });
-
-  if (!setLiveResponse.ok) {
-    const setLiveBody = await setLiveResponse.text();
+  if (deployment.status !== "data_ready") {
     return {
       success: false,
       result: "failed",
-      error: `Failed to set deployment as live: ${setLiveResponse.status} ${setLiveResponse.statusText}\n${setLiveBody}`,
+      error: `Deployment timed out after ${maxPollAttempts} attempts. Last status: ${deployment.status}`,
       datasourceCount: resources.datasources.length,
       pipeCount: resources.pipes.length,
       connectionCount: resources.connections?.length ?? 0,
@@ -500,11 +436,66 @@ export async function deployToMain(
     };
   }
 
+  options?.callbacks?.onDeploymentReady?.();
+
+  if (autoPromote && !deployment.live) {
+    let promotionAttempts = 0;
+    options?.callbacks?.onWaitingForPromote?.();
+
+    while (!deployment.live && promotionAttempts < maxPollAttempts) {
+      await sleep(pollIntervalMs);
+      promotionAttempts++;
+
+      if (debug) {
+        console.log(`[debug] Polling auto-promote status (attempt ${promotionAttempts})...`);
+      }
+
+      const statusUrl = `${baseUrl}/v1/deployments/${deploymentId}`;
+      const statusResponse = await tinybirdFetch(statusUrl, {
+        headers: {
+          Authorization: `Bearer ${config.token}`,
+        },
+      });
+
+      if (!statusResponse.ok) {
+        return {
+          success: false,
+          result: "failed",
+          error: `Failed to check deployment status: ${statusResponse.status} ${statusResponse.statusText}`,
+          datasourceCount: resources.datasources.length,
+          pipeCount: resources.pipes.length,
+          connectionCount: resources.connections?.length ?? 0,
+          buildId: deploymentId,
+        };
+      }
+
+      const statusBody = (await statusResponse.json()) as DeploymentStatusResponse;
+      deployment = statusBody.deployment;
+    }
+
+    if (!deployment.live) {
+      return {
+        success: false,
+        result: "failed",
+        error: `Deployment reached data_ready but auto-promote did not complete after ${maxPollAttempts} attempts`,
+        datasourceCount: resources.datasources.length,
+        pipeCount: resources.pipes.length,
+        connectionCount: resources.connections?.length ?? 0,
+        buildId: deploymentId,
+      };
+    }
+
+    options?.callbacks?.onDeploymentPromoted?.();
+  }
+
   if (debug) {
-    console.log(`[debug] Deployment ${deploymentId} is now live`);
+    const stateLabel = deployment.live ? "live" : "ready";
+    console.log(`[debug] Deployment ${deploymentId} is now ${stateLabel}`);
   }
 
-  options?.callbacks?.onDeploymentLive?.(deploymentId);
+  if (deployment.live) {
+    options?.callbacks?.onDeploymentLive?.(deploymentId);
+  }
 
   return {
     success: true,
@@ -526,9 +517,19 @@ export async function deployToMain(
   };
 }
 
-/**
- * Helper function to sleep for a given number of milliseconds
- */
 function sleep(ms: number): Promise<void> {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
+
+function normalizeDeployErrorMessage(message: string): string {
+  const trimmedMessage = message.trim();
+  const isForwardClassicError =
+    trimmedMessage.includes("Tinybird Forward workspace") &&
+    trimmedMessage.includes("Tinybird Classic workspaces");
+
+  if (!isForwardClassicError || trimmedMessage.includes(FORWARD_CLASSIC_GUIDANCE)) {
+    return message;
+  }
+
+  return `${trimmedMessage}\n${FORWARD_CLASSIC_GUIDANCE}`;
+}