[pull] dev from anomalyco:dev

infra/console.ts

@@ -118,7 +118,6 @@ const ZEN_LITE_PRICE = new sst.Linkable("ZEN_LITE_PRICE", {
     price: zenLitePrice.id,
   },
 })
-const ZEN_LITE_LIMITS = new sst.Secret("ZEN_LITE_LIMITS")
 
 const zenBlackProduct = new stripe.Product("ZenBlack", {
   name: "OpenCode Black",
@@ -142,7 +141,6 @@ const ZEN_BLACK_PRICE = new sst.Linkable("ZEN_BLACK_PRICE", {
     plan20: zenBlackPrice20.id,
   },
 })
-const ZEN_BLACK_LIMITS = new sst.Secret("ZEN_BLACK_LIMITS")
 
 const ZEN_MODELS = [
   new sst.Secret("ZEN_MODELS1"),
@@ -215,9 +213,8 @@ new sst.cloudflare.x.SolidStart("Console", {
     AWS_SES_ACCESS_KEY_ID,
     AWS_SES_SECRET_ACCESS_KEY,
     ZEN_BLACK_PRICE,
-    ZEN_BLACK_LIMITS,
     ZEN_LITE_PRICE,
-    ZEN_LITE_LIMITS,
+    new sst.Secret("ZEN_LIMITS"),
     new sst.Secret("ZEN_SESSION_SECRET"),
     ...ZEN_MODELS,
     ...($dev

nix/node_modules.nix

@@ -31,6 +31,7 @@ stdenvNoCC.mkDerivation {
         ../package.json
         ../patches
         ../install # required by desktop build (cli.rs include_str!)
+        ../.github/TEAM_MEMBERS # required by @opencode-ai/script
       ]
     );
   };

packages/console/app/src/routes/zen/util/handler.ts

@@ -97,9 +97,9 @@ export async function handler(
     const zenData = ZenData.list(opts.modelList)
     const modelInfo = validateModel(zenData, model)
     const dataDumper = createDataDumper(sessionId, requestId, projectId)
-    const trialLimiter = createTrialLimiter(modelInfo.trial, ip, ocClient)
-    const isTrial = await trialLimiter?.isTrial()
-    const rateLimiter = createRateLimiter(modelInfo.rateLimit, ip, input.request)
+    const trialLimiter = createTrialLimiter(modelInfo.trialProvider, ip)
+    const trialProvider = await trialLimiter?.check()
+    const rateLimiter = createRateLimiter(modelInfo.allowAnonymous, ip, input.request)
     await rateLimiter?.check()
     const stickyTracker = createStickyTracker(modelInfo.stickyProvider, sessionId)
     const stickyProvider = await stickyTracker?.get()
@@ -114,7 +114,7 @@ export async function handler(
         authInfo,
         modelInfo,
         sessionId,
-        isTrial ?? false,
+        trialProvider,
         retry,
         stickyProvider,
       )
@@ -144,9 +144,6 @@ export async function handler(
           Object.entries(providerInfo.headerMappings ?? {}).forEach(([k, v]) => {
             headers.set(k, headers.get(v)!)
           })
-          Object.entries(providerInfo.headers ?? {}).forEach(([k, v]) => {
-            headers.set(k, v)
-          })
           headers.delete("host")
           headers.delete("content-length")
           headers.delete("x-opencode-request")
@@ -295,18 +292,13 @@ export async function handler(
                 part = part.trim()
                 usageParser.parse(part)
 
-                if (providerInfo.responseModifier) {
-                  for (const [k, v] of Object.entries(providerInfo.responseModifier)) {
-                    part = part.replace(k, v)
-                  }
-                  c.enqueue(encoder.encode(part + "\n\n"))
-                } else if (providerInfo.format !== opts.format) {
+                if (providerInfo.format !== opts.format) {
                   part = streamConverter(part)
                   c.enqueue(encoder.encode(part + "\n\n"))
                 }
               }
 
-              if (!providerInfo.responseModifier && providerInfo.format === opts.format) {
+              if (providerInfo.format === opts.format) {
                 c.enqueue(value)
               }
 
@@ -398,7 +390,7 @@ export async function handler(
     authInfo: AuthInfo,
     modelInfo: ModelInfo,
     sessionId: string,
-    isTrial: boolean,
+    trialProvider: string | undefined,
     retry: RetryOptions,
     stickyProvider: string | undefined,
   ) {
@@ -407,8 +399,8 @@ export async function handler(
         return modelInfo.providers.find((provider) => provider.id === modelInfo.byokProvider)
       }
 
-      if (isTrial) {
-        return modelInfo.providers.find((provider) => provider.id === modelInfo.trial!.provider)
+      if (trialProvider) {
+        return modelInfo.providers.find((provider) => provider.id === trialProvider)
       }
 
       if (stickyProvider) {

packages/console/app/src/routes/zen/util/rateLimiter.ts

@@ -2,29 +2,28 @@ import { Database, eq, and, sql, inArray } from "@opencode-ai/console-core/drizz
 import { IpRateLimitTable } from "@opencode-ai/console-core/schema/ip.sql.js"
 import { FreeUsageLimitError } from "./error"
 import { logger } from "./logger"
-import { ZenData } from "@opencode-ai/console-core/model.js"
 import { i18n } from "~/i18n"
 import { localeFromRequest } from "~/lib/language"
+import { Subscription } from "@opencode-ai/console-core/subscription.js"
 
-export function createRateLimiter(limit: ZenData.RateLimit | undefined, rawIp: string, request: Request) {
-  if (!limit) return
+export function createRateLimiter(allowAnonymous: boolean | undefined, rawIp: string, request: Request) {
+  if (!allowAnonymous) return
   const dict = i18n(localeFromRequest(request))
 
-  const limitValue = limit.checkHeader && !request.headers.get(limit.checkHeader) ? limit.fallbackValue! : limit.value
+  const limits = Subscription.getFreeLimits()
+  const limitValue =
+    limits.checkHeader && !request.headers.get(limits.checkHeader) ? limits.fallbackValue : limits.dailyRequests
 
   const ip = !rawIp.length ? "unknown" : rawIp
   const now = Date.now()
-  const intervals =
-    limit.period === "day"
-      ? [buildYYYYMMDD(now)]
-      : [buildYYYYMMDDHH(now), buildYYYYMMDDHH(now - 3_600_000), buildYYYYMMDDHH(now - 7_200_000)]
+  const interval = buildYYYYMMDD(now)
 
   return {
     track: async () => {
       await Database.use((tx) =>
         tx
           .insert(IpRateLimitTable)
-          .values({ ip, interval: intervals[0], count: 1 })
+          .values({ ip, interval, count: 1 })
           .onDuplicateKeyUpdate({ set: { count: sql`${IpRateLimitTable.count} + 1` } }),
       )
     },
@@ -33,15 +32,12 @@ export function createRateLimiter(limit: ZenData.RateLimit | undefined, rawIp: s
         tx
           .select({ interval: IpRateLimitTable.interval, count: IpRateLimitTable.count })
           .from(IpRateLimitTable)
-          .where(and(eq(IpRateLimitTable.ip, ip), inArray(IpRateLimitTable.interval, intervals))),
+          .where(and(eq(IpRateLimitTable.ip, ip), inArray(IpRateLimitTable.interval, [interval]))),
       )
       const total = rows.reduce((sum, r) => sum + r.count, 0)
       logger.debug(`rate limit total: ${total}`)
       if (total >= limitValue)
-        throw new FreeUsageLimitError(
-          dict["zen.api.error.rateLimitExceeded"],
-          limit.period === "day" ? getRetryAfterDay(now) : getRetryAfterHour(rows, intervals, limitValue, now),
-        )
+        throw new FreeUsageLimitError(dict["zen.api.error.rateLimitExceeded"], getRetryAfterDay(now))
     },
   }
 }
@@ -50,37 +46,9 @@ export function getRetryAfterDay(now: number) {
   return Math.ceil((86_400_000 - (now % 86_400_000)) / 1000)
 }
 
-export function getRetryAfterHour(
-  rows: { interval: string; count: number }[],
-  intervals: string[],
-  limit: number,
-  now: number,
-) {
-  const counts = new Map(rows.map((r) => [r.interval, r.count]))
-  // intervals are ordered newest to oldest: [current, -1h, -2h]
-  // simulate dropping oldest intervals one at a time
-  let running = intervals.reduce((sum, i) => sum + (counts.get(i) ?? 0), 0)
-  for (let i = intervals.length - 1; i >= 0; i--) {
-    running -= counts.get(intervals[i]) ?? 0
-    if (running < limit) {
-      // interval at index i rolls out of the window (intervals.length - i) hours from the current hour start
-      const hours = intervals.length - i
-      return Math.ceil((hours * 3_600_000 - (now % 3_600_000)) / 1000)
-    }
-  }
-  return Math.ceil((3_600_000 - (now % 3_600_000)) / 1000)
-}
-
 function buildYYYYMMDD(timestamp: number) {
   return new Date(timestamp)
     .toISOString()
     .replace(/[^0-9]/g, "")
     .substring(0, 8)
 }
-
-function buildYYYYMMDDHH(timestamp: number) {
-  return new Date(timestamp)
-    .toISOString()
-    .replace(/[^0-9]/g, "")
-    .substring(0, 10)
-}

packages/console/app/src/routes/zen/util/trialLimiter.ts

@@ -1,21 +1,18 @@
 import { Database, eq, sql } from "@opencode-ai/console-core/drizzle/index.js"
 import { IpTable } from "@opencode-ai/console-core/schema/ip.sql.js"
 import { UsageInfo } from "./provider/provider"
-import { ZenData } from "@opencode-ai/console-core/model.js"
+import { Subscription } from "@opencode-ai/console-core/subscription.js"
 
-export function createTrialLimiter(trial: ZenData.Trial | undefined, ip: string, client: string) {
-  if (!trial) return
+export function createTrialLimiter(trialProvider: string | undefined, ip: string) {
+  if (!trialProvider) return
   if (!ip) return
 
-  const limit =
-    trial.limits.find((limit) => limit.client === client)?.limit ??
-    trial.limits.find((limit) => limit.client === undefined)?.limit
-  if (!limit) return
+  const limit = Subscription.getFreeLimits().promoTokens
 
   let _isTrial: boolean
 
   return {
-    isTrial: async () => {
+    check: async () => {
       const data = await Database.use((tx) =>
         tx
           .select({
@@ -27,7 +24,7 @@ export function createTrialLimiter(trial: ZenData.Trial | undefined, ip: string,
       )
 
       _isTrial = (data?.usage ?? 0) < limit
-      return _isTrial
+      return _isTrial ? trialProvider : undefined
     },
     track: async (usageInfo: UsageInfo) => {
       if (!_isTrial) return

packages/console/app/test/rateLimiter.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, test } from "bun:test"
-import { getRetryAfterDay, getRetryAfterHour } from "../src/routes/zen/util/rateLimiter"
+import { getRetryAfterDay } from "../src/routes/zen/util/rateLimiter"
 
 describe("getRetryAfterDay", () => {
   test("returns full day at midnight UTC", () => {
@@ -17,76 +17,3 @@ describe("getRetryAfterDay", () => {
     expect(getRetryAfterDay(almost)).toBe(1)
   })
 })
-
-describe("getRetryAfterHour", () => {
-  // 14:30:00 UTC — 30 minutes into the current hour
-  const now = Date.UTC(2026, 0, 15, 14, 30, 0, 0)
-  const intervals = ["2026011514", "2026011513", "2026011512"]
-
-  test("waits 3 hours when all usage is in current hour", () => {
-    const rows = [{ interval: "2026011514", count: 10 }]
-    // only current hour has usage — it won't leave the window for 3 hours from hour start
-    // 3 * 3600 - 1800 = 9000s
-    expect(getRetryAfterHour(rows, intervals, 10, now)).toBe(9000)
-  })
-
-  test("waits 1 hour when dropping oldest interval is sufficient", () => {
-    const rows = [
-      { interval: "2026011514", count: 2 },
-      { interval: "2026011512", count: 10 },
-    ]
-    // total=12, drop oldest (-2h, count=10) -> 2 < 10
-    // hours = 3 - 2 = 1 -> 1 * 3600 - 1800 = 1800s
-    expect(getRetryAfterHour(rows, intervals, 10, now)).toBe(1800)
-  })
-
-  test("waits 2 hours when usage spans oldest two intervals", () => {
-    const rows = [
-      { interval: "2026011513", count: 8 },
-      { interval: "2026011512", count: 5 },
-    ]
-    // total=13, drop -2h (5) -> 8, 8 >= 8, drop -1h (8) -> 0 < 8
-    // hours = 3 - 1 = 2 -> 2 * 3600 - 1800 = 5400s
-    expect(getRetryAfterHour(rows, intervals, 8, now)).toBe(5400)
-  })
-
-  test("waits 1 hour when oldest interval alone pushes over limit", () => {
-    const rows = [
-      { interval: "2026011514", count: 1 },
-      { interval: "2026011513", count: 1 },
-      { interval: "2026011512", count: 10 },
-    ]
-    // total=12, drop -2h (10) -> 2 < 10
-    // hours = 3 - 2 = 1 -> 1800s
-    expect(getRetryAfterHour(rows, intervals, 10, now)).toBe(1800)
-  })
-
-  test("waits 2 hours when middle interval keeps total over limit", () => {
-    const rows = [
-      { interval: "2026011514", count: 4 },
-      { interval: "2026011513", count: 4 },
-      { interval: "2026011512", count: 4 },
-    ]
-    // total=12, drop -2h (4) -> 8, 8 >= 5, drop -1h (4) -> 4 < 5
-    // hours = 3 - 1 = 2 -> 5400s
-    expect(getRetryAfterHour(rows, intervals, 5, now)).toBe(5400)
-  })
-
-  test("rounds up to nearest second", () => {
-    const offset = Date.UTC(2026, 0, 15, 14, 30, 0, 500)
-    const rows = [
-      { interval: "2026011514", count: 2 },
-      { interval: "2026011512", count: 10 },
-    ]
-    // hours=1 -> 3_600_000 - 1_800_500 = 1_799_500ms -> ceil(1799.5) = 1800
-    expect(getRetryAfterHour(rows, intervals, 10, offset)).toBe(1800)
-  })
-
-  test("fallback returns time until next hour when rows are empty", () => {
-    // edge case: rows empty but function called (shouldn't happen in practice)
-    // loop drops all zeros, running stays 0 which is < any positive limit on first iteration
-    const rows: { interval: string; count: number }[] = []
-    // drop -2h (0) -> 0 < 1 -> hours = 3 - 2 = 1 -> 1800s
-    expect(getRetryAfterHour(rows, intervals, 1, now)).toBe(1800)
-  })
-})

packages/console/core/package.json

@@ -34,12 +34,9 @@
     "promote-models-to-prod": "script/promote-models.ts production",
     "pull-models-from-dev": "script/pull-models.ts dev",
     "pull-models-from-prod": "script/pull-models.ts production",
-    "update-black": "script/update-black.ts",
-    "promote-black-to-dev": "script/promote-black.ts dev",
-    "promote-black-to-prod": "script/promote-black.ts production",
-    "update-lite": "script/update-lite.ts",
-    "promote-lite-to-dev": "script/promote-lite.ts dev",
-    "promote-lite-to-prod": "script/promote-lite.ts production",
+    "update-limits": "script/update-limits.ts",
+    "promote-limits-to-dev": "script/promote-limits.ts dev",
+    "promote-limits-to-prod": "script/promote-limits.ts production",
     "typecheck": "tsgo --noEmit"
   },
   "devDependencies": {