fix(webapp): honor a zero message allowance and prefer the server-resolved limit over the client constant

Author: kathiekiwi

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

@@ -206,7 +206,7 @@ export function DashboardAgentChat({
   // Either the poll saw the cap, or a send was just refused over it.
   const atMessageCap = quota.kind === "reached" || quotaReached !== null;
   const messageCapLimit =
-    quotaReached?.limit ?? (quota.kind === "reached" ? quota.limit : FREE_PLAN_MESSAGE_LIMIT);
+    quotaReached?.limit ?? (quota.kind === "unlimited" ? FREE_PLAN_MESSAGE_LIMIT : quota.limit);
 
   const isStreaming = status === "streaming";
   // From status, not the last part: the indicator must stay up through silent tool calls.

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

@@ -5,9 +5,51 @@ import {
   MESSAGE_QUOTA_REACHED_ERROR,
   messageQuotaReachedCopy,
   parseQuotaReachedResponse,
+  quotaResponseUpdate,
+  resolveMessageLimit,
   resolveMessageQuota,
 } from "./message-quota";
 
+describe("quotaResponseUpdate", () => {
+  it("takes both fields from a coherent body", () => {
+    expect(quotaResponseUpdate({ used: 30, limit: 50 })).toEqual({ used: 30, limit: 50 });
+    expect(quotaResponseUpdate({ used: 30, limit: null })).toEqual({ used: 30, limit: null });
+    expect(quotaResponseUpdate({ used: 0, limit: 0 })).toEqual({ used: 0, limit: 0 });
+  });
+
+  it("changes nothing on a degraded body", () => {
+    // Control break: apply `{}` field-by-field and a good {used:30, limit:50} read decays to
+    // used 30 against the client's 20 — "reached" against a cap the server never set.
+    expect(quotaResponseUpdate({})).toBeNull();
+    expect(quotaResponseUpdate(null)).toBeNull();
+    expect(quotaResponseUpdate({ limit: 50 })).toBeNull();
+  });
+});
+
+describe("resolveMessageLimit", () => {
+  it("prefers a finite server-resolved limit over the client constant", () => {
+    expect(resolveMessageLimit(5)).toBe(5);
+    expect(resolveMessageLimit(0)).toBe(0);
+    expect(resolveMessageLimit(500)).toBe(500);
+  });
+
+  it("keeps the free-plan nudge when the server has no finite limit", () => {
+    // Pre-P0 the server limit is the unlimited sentinel and is sent as null: the client's
+    // own 20 IS the nudge. Control break: thread the server number here and it disappears.
+    expect(resolveMessageLimit(null)).toBe(FREE_PLAN_MESSAGE_LIMIT);
+    expect(resolveMessageLimit(undefined)).toBe(FREE_PLAN_MESSAGE_LIMIT);
+  });
+
+  it("caps against the server limit once it is known", () => {
+    expect(
+      resolveMessageQuota({ isFreePlan: true, used: 5, limit: resolveMessageLimit(5) })
+    ).toMatchObject({ kind: "reached", limit: 5 });
+    expect(
+      resolveMessageQuota({ isFreePlan: true, used: 5, limit: resolveMessageLimit(null) })
+    ).toMatchObject({ kind: "within", limit: FREE_PLAN_MESSAGE_LIMIT, remaining: 15 });
+  });
+});
+
 describe("resolveMessageQuota", () => {
   it("caps a Free plan at the limit", () => {
     expect(resolveMessageQuota({ isFreePlan: true, used: 0 })).toEqual({

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

@@ -4,6 +4,27 @@ import { isWatchRequestMessageId } from "@internal/dashboard-agent-contracts";
 // would reset.
 export const FREE_PLAN_MESSAGE_LIMIT = 20;
 
+/**
+ * The cap to show: the plan limit the server resolved, when it resolved a finite one. The
+ * server sends null while no plan limit exists (self-hosted, or before billing carries one),
+ * and then the free-plan nudge is the cap — dropping it would remove the nudge entirely.
+ */
+export function resolveMessageLimit(serverLimit: number | null | undefined): number {
+  return typeof serverLimit === "number" ? serverLimit : FREE_PLAN_MESSAGE_LIMIT;
+}
+
+/**
+ * What a `?quota=1` body should change, or null for a degraded one. Both fields move together:
+ * applying a `{}` on top of a good read would keep the count and drop back to the nudge limit,
+ * which reads as "reached" against a cap the server never set.
+ */
+export function quotaResponseUpdate(
+  data: { used?: number; limit?: number | null } | null | undefined
+): { used: number; limit: number | null } | null {
+  if (typeof data?.used !== "number") return null;
+  return { used: data.used, limit: typeof data.limit === "number" ? data.limit : null };
+}
+
 export type MessageQuota =
   | { kind: "unlimited" }
   | { kind: "within"; used: number; limit: number; remaining: number }

apps/webapp/app/components/dashboard-agent/useAgentMessageQuota.ts

@@ -1,6 +1,11 @@
 import { useEffect, useRef, useState } from "react";
 import { useCurrentPlan } from "~/routes/_app.orgs.$organizationSlug/route";
-import { resolveMessageQuota, type MessageQuota } from "./message-quota";
+import {
+  quotaResponseUpdate,
+  resolveMessageLimit,
+  resolveMessageQuota,
+  type MessageQuota,
+} from "./message-quota";
 
 // Gated on billing PRESENCE, not the plan value: no subscription means billing isn't wired
 // up (self-hosted), so there is no cap and no upgrade UI. A wired-up, non-paying plan is free.
@@ -24,6 +29,7 @@ export function useAgentMessageQuota({
 }): MessageQuota {
   const isFreePlan = useIsFreePlan();
   const [used, setUsed] = useState<number | undefined>(undefined);
+  const [serverLimit, setServerLimit] = useState<number | null>(null);
 
   // Bumped each time the status leaves streaming/submitted, which drives the re-read.
   const [settleTick, setSettleTick] = useState(0);
@@ -42,14 +48,18 @@ export function useAgentMessageQuota({
       try {
         const res = await fetch(`${actionPath}?quota=1`, { signal: controller.signal });
         if (!res.ok) return;
-        const data = (await res.json()) as { used?: number };
-        if (typeof data.used === "number") setUsed(data.used);
+        const update = quotaResponseUpdate(
+          (await res.json()) as { used?: number; limit?: number | null }
+        );
+        if (!update) return;
+        setUsed(update.used);
+        setServerLimit(update.limit);
       } catch {
         // Leave the count unknown, which means no cap. See `resolveMessageQuota`.
       }
     })();
     return () => controller.abort();
   }, [isFreePlan, actionPath, chatId, settleTick]);
 
-  return resolveMessageQuota({ isFreePlan, used });
+  return resolveMessageQuota({ isFreePlan, used, limit: resolveMessageLimit(serverLimit) });
 }

apps/webapp/app/routes/resources.orgs.$organizationSlug.projects.$projectParam.env.$envParam.dashboard-agent.ts

@@ -3,7 +3,6 @@ import {
   chatExists,
   countUnreadWatchWakes,
   countChatsWithUnreadWork,
-  getAgentMessageUsage,
   createChat,
   getChatMessages,
   getSession,
@@ -55,9 +54,9 @@ import { watchErrorStatus } from "~/services/dashboardAgentWatchErrorStatus.serv
 import { startDashboardAgentHeadStart } from "~/services/dashboardAgentHeadStart.server";
 import { dashboardAgentDb } from "~/services/dashboardAgentDb.server";
 import {
-  currentAgentMessagePeriod,
   recordAgentMessageSent,
   resolveAgentMessageQuota,
+  UNLIMITED_AGENT_MESSAGES,
 } from "~/services/dashboardAgentQuota.server";
 import { logger } from "~/services/logger.server";
 import { resolveTriggerUri } from "~/services/resolveTriggerUri.server";
@@ -159,11 +158,16 @@ export const loader = async ({ request, params }: LoaderFunctionArgs) => {
 
   // The per-period counter, org-wide: a deleted chat can't lower it within the period.
   if (searchParams.get("quota") === "1") {
-    const used = await getAgentMessageUsage(dashboardAgentDb, {
+    const quota = await resolveAgentMessageQuota(dashboardAgentDb, {
       organizationId: project.organizationId,
-      period: currentAgentMessagePeriod(),
     });
-    return json({ used });
+    if (!quota) return json({});
+    // The sentinel is "no plan limit" — send null so the client keeps its own free-plan nudge
+    // instead of showing a number nobody would ever reach.
+    return json({
+      used: quota.used,
+      limit: quota.limit < UNLIMITED_AGENT_MESSAGES ? quota.limit : null,
+    });
   }
 
   const chatId = searchParams.get("chatId");

apps/webapp/app/services/dashboardAgentQuota.server.ts

@@ -4,7 +4,7 @@ import {
   incrementAgentMessageUsage,
   type DashboardAgentDb,
 } from "@internal/dashboard-agent-db";
-import { getCachedLimit } from "./platform.v3.server";
+import { getCachedLimitAllowingZero } from "./platform.v3.server";
 import { logger } from "./logger.server";
 
 // The repo's unlimited sentinel. Never Infinity: it serializes to null in the limit cache.
@@ -44,7 +44,10 @@ export async function resolveAgentMessageQuota(
   const readLimit =
     params.readLimit ??
     (async (organizationId: string) => {
-      const cached = await getCachedLimit(
+      // Allowing zero: a plan that includes no messages must cap at 0, not read as absent.
+      // This call isn't covered directly; the limitValueAllowingZero cases in
+      // dashboardAgentQuota.test.ts guard the rule it depends on.
+      const cached = await getCachedLimitAllowingZero(
         organizationId,
         AGENT_MESSAGE_LIMIT_KEY,
         UNLIMITED_AGENT_MESSAGES

apps/webapp/test/dashboardAgentQuota.test.ts

@@ -19,6 +19,7 @@ import {
   resolveAgentMessageQuota,
   UNLIMITED_AGENT_MESSAGES,
 } from "~/services/dashboardAgentQuota.server";
+import { limitValueAllowingZero } from "~/services/platform.v3.server";
 
 /**
  * Server-side agent message quota (TRI-12863): a per-(org, period) counter that a deleted chat
@@ -168,6 +169,31 @@ describe("resolveAgentMessageQuota", () => {
     }
   );
 
+  postgresTest(
+    "a plan allowance of zero caps immediately, it is not read as unlimited",
+    async ({ prisma, postgresContainer }) => {
+      const db = await boot(prisma, postgresContainer.getConnectionUri());
+      const now = new Date();
+
+      expect(
+        await resolveAgentMessageQuota(db, { organizationId: ORG, now, readLimit: async () => 0 })
+      ).toEqual({ reached: true, used: 0, limit: 0 });
+
+      // The read the default limit path performs. Control break: with the `!result` fallback
+      // of `getCachedLimit`, a plan value of 0 comes back as the unlimited sentinel.
+      expect(
+        limitValueAllowingZero(
+          { agentMessages: 0 } as never,
+          "agentMessages" as never,
+          UNLIMITED_AGENT_MESSAGES
+        )
+      ).toBe(0);
+      expect(
+        limitValueAllowingZero(undefined, "agentMessages" as never, UNLIMITED_AGENT_MESSAGES)
+      ).toBe(UNLIMITED_AGENT_MESSAGES);
+    }
+  );
+
   it("fails open when the counter read throws", async () => {
     const throwingDb = {
       select: () => {