fix(webapp): don't tell paid plans their message allowance was the Free plan's

Author: kathiekiwi

apps/webapp/app/components/dashboard-agent/AgentUpgradeGate.tsx

@@ -11,9 +11,11 @@ const SLOT = "flex shrink-0 flex-col bg-background-bright px-3 pb-3 pt-1";
 
 export function AgentUpgradeBlock({
   limit,
+  planResolved,
   context,
 }: {
   limit: number;
+  planResolved: boolean;
   context?: React.ReactNode;
 }) {
   const organization = useOrganization();
@@ -28,7 +30,7 @@ export function AgentUpgradeBlock({
             Upgrade to unlock {ASK_AGENT_LABEL}
           </span>
         </div>
-        <p className="text-xs text-text-dimmed">{messageQuotaReachedCopy(limit)}</p>
+        <p className="text-xs text-text-dimmed">{messageQuotaReachedCopy(limit, planResolved)}</p>
         <LinkButton variant="primary/small" to={v3BillingPath(organization)} fullWidth>
           Upgrade
         </LinkButton>

apps/webapp/app/components/dashboard-agent/DashboardAgentChat.tsx

@@ -105,7 +105,9 @@ export function DashboardAgentChat({
   const [input, setInput] = useState("");
   // Set when the server refuses a send over the cap, so the block shows at once rather than
   // waiting for the next quota poll.
-  const [quotaReached, setQuotaReached] = useState<{ limit: number } | null>(null);
+  const [quotaReached, setQuotaReached] = useState<{ limit: number; planResolved: boolean } | null>(
+    null
+  );
   const navigate = useNavigate();
   const location = useLocation();
   const toast = useToast();
@@ -207,6 +209,9 @@ export function DashboardAgentChat({
   const atMessageCap = quota.kind === "reached" || quotaReached !== null;
   const messageCapLimit =
     quotaReached?.limit ?? (quota.kind === "unlimited" ? FREE_PLAN_MESSAGE_LIMIT : quota.limit);
+  // The poll only runs on the free plan, so its cap is the free-plan nudge; a refusal
+  // carries the plan limit the server resolved.
+  const messageCapPlanResolved = quotaReached?.planResolved ?? false;
 
   const isStreaming = status === "streaming";
   // From status, not the last part: the indicator must stay up through silent tool calls.
@@ -438,6 +443,7 @@ export function DashboardAgentChat({
       {atMessageCap ? (
         <AgentUpgradeBlock
           limit={messageCapLimit}
+          planResolved={messageCapPlanResolved}
           context={
             <DashboardAgentContextBanner
               projectSlug={projectSlug}

apps/webapp/app/components/dashboard-agent/DashboardAgentDraft.tsx

@@ -26,7 +26,7 @@ export function DashboardAgentDraft({
   pageContext?: AgentPageContext;
   promotedPrompt?: SuggestedPrompt;
   watchCard?: React.ReactNode;
-  capReached?: { limit: number } | null;
+  capReached?: { limit: number; planResolved: boolean } | null;
 }) {
   const [input, setInput] = useState("");
 
@@ -67,6 +67,7 @@ export function DashboardAgentDraft({
             {watchCard}
             <AgentUpgradeBlock
               limit={capReached.limit}
+              planResolved={capReached.planResolved}
               context={
                 <DashboardAgentContextBanner
                   projectSlug={projectSlug}

apps/webapp/app/components/dashboard-agent/DashboardAgentPanel.tsx

@@ -116,7 +116,9 @@ export function DashboardAgentPanel({
   const [chatsLoaded, setChatsLoaded] = useState(false);
   const [active, setActive] = useState<ActiveChat | null>(null);
   // A refused `create` over the cap: the draft shows the upgrade block instead of a raw toast.
-  const [capReached, setCapReached] = useState<{ limit: number } | null>(null);
+  const [capReached, setCapReached] = useState<{ limit: number; planResolved: boolean } | null>(
+    null
+  );
   // Starts true so an `openWith` request waits for the restore instead of racing it.
   const [loading, setLoading] = useState(
     () => readLastChat(storageKey)?.path === location.pathname

apps/webapp/app/components/dashboard-agent/message-quota.test.ts

@@ -96,12 +96,13 @@ describe("parseQuotaReachedResponse", () => {
     // Both the create path and the `in` transport refuse with this exact body.
     expect(
       parseQuotaReachedResponse(403, { error: MESSAGE_QUOTA_REACHED_ERROR, limit: 20 })
-    ).toEqual({ limit: 20 });
+    ).toEqual({ limit: 20, planResolved: true });
   });
 
   it("falls back to the free limit when the body omits it", () => {
     expect(parseQuotaReachedResponse(403, { error: MESSAGE_QUOTA_REACHED_ERROR })).toEqual({
       limit: FREE_PLAN_MESSAGE_LIMIT,
+      planResolved: false,
     });
   });
 
@@ -113,13 +114,21 @@ describe("parseQuotaReachedResponse", () => {
 });
 
 describe("messageQuotaReachedCopy", () => {
-  it("is a friendly sentence naming the limit, never the raw code", () => {
-    const copy = messageQuotaReachedCopy(20);
-    expect(copy).toContain("all 20 messages");
+  it("names the Free plan only for the client nudge", () => {
+    const copy = messageQuotaReachedCopy(FREE_PLAN_MESSAGE_LIMIT, false);
+    expect(copy).toContain(`all ${FREE_PLAN_MESSAGE_LIMIT} messages`);
     expect(copy).toContain("Free plan");
     // Control break: if the mapping leaked the server code, this fails.
     expect(copy).not.toContain(MESSAGE_QUOTA_REACHED_ERROR);
   });
+
+  it("stays plan-agnostic for a server-resolved limit, which paying orgs also hit", () => {
+    const copy = messageQuotaReachedCopy(500, true);
+    expect(copy).toContain("all 500 messages");
+    expect(copy).toContain("your plan");
+    expect(copy).not.toContain("Free plan");
+    expect(copy).not.toContain(MESSAGE_QUOTA_REACHED_ERROR);
+  });
 });
 
 describe("countUserMessages", () => {

apps/webapp/app/components/dashboard-agent/message-quota.ts

@@ -57,17 +57,24 @@ export const MESSAGE_QUOTA_REACHED_ERROR = "message_quota_reached";
 export function parseQuotaReachedResponse(
   status: number,
   data: { error?: string; limit?: number } | null | undefined
-): { limit: number } | null {
+): { limit: number; planResolved: boolean } | null {
   if (status === 403 && data?.error === MESSAGE_QUOTA_REACHED_ERROR) {
-    return { limit: data.limit ?? FREE_PLAN_MESSAGE_LIMIT };
+    return typeof data.limit === "number"
+      ? { limit: data.limit, planResolved: true }
+      : { limit: FREE_PLAN_MESSAGE_LIMIT, planResolved: false };
   }
   return null;
 }
 
-// The upgrade block's sentence. Pure so the copy is asserted directly, and so the raw
-// server code can never be what the user reads.
-export function messageQuotaReachedCopy(limit: number): string {
-  return `You've used all ${limit} messages included on the Free plan. Your chats stay here to read.`;
+/**
+ * The upgrade block's sentence. Pure so the copy is asserted directly, and so the raw
+ * server code can never be what the user reads. Only the client's free-plan nudge may name
+ * the Free plan — a server-resolved cap also lands on paying orgs, whose allowance isn't it.
+ */
+export function messageQuotaReachedCopy(limit: number, planResolved: boolean): string {
+  return planResolved
+    ? `You've used all ${limit} messages included in your plan this month. Your chats stay here to read.`
+    : `You've used all ${limit} messages included on the Free plan. Your chats stay here to read.`;
 }
 
 // A watch's consent record is a user message the person never typed, so it is