From 7dd903b14ad34b13321eb9e06ee9ae2245878421 Mon Sep 17 00:00:00 2001 From: James Grugett Date: Wed, 22 Apr 2026 16:37:37 -0700 Subject: [PATCH 1/2] Rate-limit freebuff GLM sessions to 5 per 20 hours MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Adds a free_session_admit audit log (one row per queued→active transition) and gates POST /api/v1/freebuff/session against it so GLM 5.1 users who've already had 5 one-hour sessions in the last 20h are blocked with a new rate_limited status (HTTP 429). Queued/active responses now carry an optional rateLimit quota the CLI renders as "N / 5 used in last 20h" so users see their remaining allowance as soon as they join the waitlist. Minimax is left unlimited. Co-Authored-By: Claude Opus 4.7 --- cli/src/app.tsx | 4 +- cli/src/components/waiting-room-screen.tsx | 47 + cli/src/hooks/use-freebuff-session.ts | 14 + common/src/types/freebuff-session.ts | 45 + .../db/migrations/0046_cloudy_firedrake.sql | 9 + .../src/db/migrations/meta/0046_snapshot.json | 3307 +++++++++++++++++ .../src/db/migrations/meta/_journal.json | 7 + packages/internal/src/db/schema.ts | 34 + .../session/__tests__/session.test.ts | 3 + .../app/api/v1/freebuff/session/_handlers.ts | 10 +- .../free-session/__tests__/public-api.test.ts | 176 + web/src/server/free-session/public-api.ts | 112 +- web/src/server/free-session/store.ts | 74 +- 13 files changed, 3825 insertions(+), 17 deletions(-) create mode 100644 packages/internal/src/db/migrations/0046_cloudy_firedrake.sql create mode 100644 packages/internal/src/db/migrations/meta/0046_snapshot.json diff --git a/cli/src/app.tsx b/cli/src/app.tsx index 0661d7d3c..cac6e20ec 100644 --- a/cli/src/app.tsx +++ b/cli/src/app.tsx @@ -380,6 +380,7 @@ const AuthedSurface = ({ // 'queued' → waiting our turn // 'country_blocked' → terminal region-gate message // 'banned' → terminal account-banned message + // 'rate_limited' → hit per-model session quota; terminal for this run // // 'ended' deliberately falls through to : the agent may still be // finishing work under the server-side grace period, and the chat surface @@ -390,7 +391,8 @@ const AuthedSurface = ({ session.status === 'queued' || session.status === 'none' || session.status === 'country_blocked' || - session.status === 'banned') + session.status === 'banned' || + session.status === 'rate_limited') ) { return } diff --git a/cli/src/components/waiting-room-screen.tsx b/cli/src/components/waiting-room-screen.tsx index bfab94808..48ba03b00 100644 --- a/cli/src/components/waiting-room-screen.tsx +++ b/cli/src/components/waiting-room-screen.tsx @@ -44,6 +44,18 @@ const formatElapsed = (ms: number): string => { return `${minutes}m ${seconds.toString().padStart(2, '0')}s` } +/** "in ~3h 20m" / "in ~45 min" / "in under a minute". Used on the + * rate-limited screen so users know when they can try again. */ +const formatRetryAfter = (ms: number): string => { + if (!Number.isFinite(ms) || ms <= 0) return 'any moment now' + const minutes = Math.round(ms / 60_000) + if (minutes < 1) return 'under a minute' + if (minutes < 60) return `${minutes} min` + const hours = Math.floor(minutes / 60) + const rem = minutes % 60 + return rem === 0 ? `${hours}h` : `${hours}h ${rem}m` +} + export const WaitingRoomScreen: React.FC = ({ session, error, @@ -217,6 +229,18 @@ export const WaitingRoomScreen: React.FC = ({ Elapsed {formatElapsed(elapsedMs)} + {/* Per-model session quota (e.g. GLM 5.1 caps at 5/20h). Only + rendered for rate-limited models so the Minimax queue stays + clutter-free. */} + {session.rateLimit && ( + + Sessions + + {session.rateLimit.recentCount} / {session.rateLimit.limit} + + used in last {session.rateLimit.windowHours}h + + )} )} @@ -259,6 +283,29 @@ export const WaitingRoomScreen: React.FC = ({ )} + + {/* Per-model session quota exhausted (e.g. 5+ GLM sessions in the + last 20h). Terminal for this run — the user can exit and come + back once the oldest session in the window rolls off. */} + {session?.status === 'rate_limited' && ( + <> + + ⚠ Session limit reached + + + You've used{' '} + + {session.recentCount} of {session.limit} + {' '} + hour-long sessions on {session.model} in the last{' '} + {session.windowHours}h. Try again in{' '} + + {formatRetryAfter(session.retryAfterMs)} + + . Press Ctrl+C to exit. + + + )} diff --git a/cli/src/hooks/use-freebuff-session.ts b/cli/src/hooks/use-freebuff-session.ts index 407d4afd4..a78cbb4bd 100644 --- a/cli/src/hooks/use-freebuff-session.ts +++ b/cli/src/hooks/use-freebuff-session.ts @@ -86,6 +86,19 @@ async function callSession( return body } } + // 429 from POST is the per-model session-quota reject (e.g. too many GLM + // sessions in the last 20h). Terminal for the current poll — the CLI shows + // a screen explaining the limit and when the user can try again. The 429 + // status (rather than 200) keeps older CLIs in their error path so they + // back off instead of tight-polling an unrecognized 200 body. + if (resp.status === 429 && method === 'POST') { + const body = (await resp.json().catch(() => null)) as + | FreebuffSessionResponse + | null + if (body && body.status === 'rate_limited') { + return body + } + } if (!resp.ok) { const text = await resp.text().catch(() => '') throw new Error( @@ -119,6 +132,7 @@ function nextDelayMs(next: FreebuffSessionResponse): number | null { case 'country_blocked': case 'banned': case 'model_locked': + case 'rate_limited': return null } } diff --git a/common/src/types/freebuff-session.ts b/common/src/types/freebuff-session.ts index e42d9f0be..9e04f67a1 100644 --- a/common/src/types/freebuff-session.ts +++ b/common/src/types/freebuff-session.ts @@ -5,6 +5,22 @@ * * The CLI uses these shapes directly; there are no client-only states. */ + +/** + * Per-model usage counter surfaced to the CLI so the waiting-room UI can + * render "N of M sessions used" alongside queue/active state. Present when + * the joined model has a rate limit applied (today: GLM 5.1 with 5 admits + * per 20-hour window). `recentCount` is the number of admissions inside + * `windowHours` at the time the response was produced — see also the + * standalone `rate_limited` status for the reject path. + */ +export interface FreebuffSessionRateLimit { + model: string + limit: number + windowHours: number + recentCount: number +} + export type FreebuffSessionServerResponse = | { /** Waiting room is globally off; free-mode requests flow through @@ -38,6 +54,10 @@ export type FreebuffSessionServerResponse = queueDepthByModel: Record estimatedWaitMs: number queuedAt: string + /** Rate-limit quota for rate-limited models (GLM 5.1 today). Absent + * for unlimited models or when the status was produced outside the + * rate-limit check path (e.g. pure read via GET). */ + rateLimit?: FreebuffSessionRateLimit } | { status: 'active' @@ -47,6 +67,10 @@ export type FreebuffSessionServerResponse = admittedAt: string expiresAt: string remainingMs: number + /** Rate-limit quota for rate-limited models (GLM 5.1 today). Absent + * for unlimited models or when the status was produced outside the + * rate-limit check path (e.g. pure read via GET). */ + rateLimit?: FreebuffSessionRateLimit } | { /** Session is over. While `instanceId` is present we're inside the @@ -99,3 +123,24 @@ export type FreebuffSessionServerResponse = * stops polling and shows a banned message. */ status: 'banned' } + | { + /** User has used up their per-model admission quota in the rolling + * window (GLM 5.1: 5 one-hour sessions per 20h). Returned from POST + * /session before the user is placed in the queue. `retryAfterMs` is + * the time until the oldest admission inside the window falls off + * and one quota slot opens up — clients should show the user when + * they can try again. Terminal for the CLI's current poll session; + * the user can exit and come back later. */ + status: 'rate_limited' + /** The freebuff model the user tried to join. */ + model: string + /** Max admissions permitted per window (e.g. 5). */ + limit: number + /** Rolling window size in hours (e.g. 20). */ + windowHours: number + /** Admission count inside the window at check time — will be ≥ limit. */ + recentCount: number + /** Milliseconds from now until the oldest admission in the window + * exits and the user regains one quota slot. */ + retryAfterMs: number + } diff --git a/packages/internal/src/db/migrations/0046_cloudy_firedrake.sql b/packages/internal/src/db/migrations/0046_cloudy_firedrake.sql new file mode 100644 index 000000000..53a24ec98 --- /dev/null +++ b/packages/internal/src/db/migrations/0046_cloudy_firedrake.sql @@ -0,0 +1,9 @@ +CREATE TABLE "free_session_admit" ( + "id" text PRIMARY KEY NOT NULL, + "user_id" text NOT NULL, + "model" text NOT NULL, + "admitted_at" timestamp with time zone DEFAULT now() NOT NULL +); +--> statement-breakpoint +ALTER TABLE "free_session_admit" ADD CONSTRAINT "free_session_admit_user_id_user_id_fk" FOREIGN KEY ("user_id") REFERENCES "public"."user"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint +CREATE INDEX "idx_free_session_admit_user_model_time" ON "free_session_admit" USING btree ("user_id","model","admitted_at"); \ No newline at end of file diff --git a/packages/internal/src/db/migrations/meta/0046_snapshot.json b/packages/internal/src/db/migrations/meta/0046_snapshot.json new file mode 100644 index 000000000..48747dd94 --- /dev/null +++ b/packages/internal/src/db/migrations/meta/0046_snapshot.json @@ -0,0 +1,3307 @@ +{ + "id": "3bf6a16c-2fd6-4c9d-a395-f4ca2c080a3c", + "prevId": "76196ef1-2384-4edd-b832-c9ff8085d809", + "version": "7", + "dialect": "postgresql", + "tables": { + "public.account": { + "name": "account", + "schema": "", + "columns": { + "userId": { + "name": "userId", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "type": { + "name": "type", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "provider": { + "name": "provider", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "providerAccountId": { + "name": "providerAccountId", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "refresh_token": { + "name": "refresh_token", + "type": "text", + "primaryKey": false, + "notNull": false + }, + "access_token": { + "name": "access_token", + "type": "text", + "primaryKey": false, + "notNull": false + }, + "expires_at": { + "name": "expires_at", + "type": "integer", + "primaryKey": false, + "notNull": false + }, + "token_type": { + "name": "token_type", + "type": "text", + "primaryKey": false, + "notNull": false + }, + "scope": { + "name": "scope", + "type": "text", + "primaryKey": false, + "notNull": false + }, + "id_token": { + "name": "id_token", + "type": "text", + "primaryKey": false, + "notNull": false + }, + "session_state": { + "name": "session_state", + "type": "text", + "primaryKey": false, + "notNull": false + } + }, + "indexes": {}, + "foreignKeys": { + "account_userId_user_id_fk": { + "name": "account_userId_user_id_fk", + "tableFrom": "account", + "tableTo": "user", + "columnsFrom": [ + "userId" + ], + "columnsTo": [ + "id" + ], + "onDelete": "cascade", + "onUpdate": "no action" + } + }, + "compositePrimaryKeys": { + "account_provider_providerAccountId_pk": { + "name": "account_provider_providerAccountId_pk", + "columns": [ + "provider", + "providerAccountId" + ] + } + }, + "uniqueConstraints": {}, + "policies": {}, + "checkConstraints": {}, + "isRLSEnabled": false + }, + "public.ad_impression": { + "name": "ad_impression", + "schema": "", + "columns": { + "id": { + "name": "id", + "type": "text", + "primaryKey": true, + "notNull": true + }, + "user_id": { + "name": "user_id", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "provider": { + "name": "provider", + "type": "text", + "primaryKey": false, + "notNull": true, + "default": "'gravity'" + }, + "ad_text": { + "name": "ad_text", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "title": { + "name": "title", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "cta": { + "name": "cta", + "type": "text", + "primaryKey": false, + "notNull": true, + "default": "''" + }, + "url": { + "name": "url", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "favicon": { + "name": "favicon", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "click_url": { + "name": "click_url", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "imp_url": { + "name": "imp_url", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "extra_pixels": { + "name": "extra_pixels", + "type": "text[]", + "primaryKey": false, + "notNull": false + }, + "payout": { + "name": "payout", + "type": "numeric(10, 6)", + "primaryKey": false, + "notNull": false + }, + "credits_granted": { + "name": "credits_granted", + "type": "integer", + "primaryKey": false, + "notNull": true + }, + "grant_operation_id": { + "name": "grant_operation_id", + "type": "text", + "primaryKey": false, + "notNull": false + }, + "served_at": { + "name": "served_at", + "type": "timestamp with time zone", + "primaryKey": false, + "notNull": true, + "default": "now()" + }, + "impression_fired_at": { + "name": "impression_fired_at", + "type": "timestamp with time zone", + "primaryKey": false, + "notNull": false + }, + "clicked_at": { + "name": "clicked_at", + "type": "timestamp with time zone", + "primaryKey": false, + "notNull": false + } + }, + "indexes": { + "idx_ad_impression_user": { + "name": "idx_ad_impression_user", + "columns": [ + { + "expression": "user_id", + "isExpression": false, + "asc": true, + "nulls": "last" + }, + { + "expression": "served_at", + "isExpression": false, + "asc": true, + "nulls": "last" + } + ], + "isUnique": false, + "concurrently": false, + "method": "btree", + "with": {} + }, + "idx_ad_impression_imp_url": { + "name": "idx_ad_impression_imp_url", + "columns": [ + { + "expression": "imp_url", + "isExpression": false, + "asc": true, + "nulls": "last" + } + ], + "isUnique": false, + "concurrently": false, + "method": "btree", + "with": {} + } + }, + "foreignKeys": { + "ad_impression_user_id_user_id_fk": { + "name": "ad_impression_user_id_user_id_fk", + "tableFrom": "ad_impression", + "tableTo": "user", + "columnsFrom": [ + "user_id" + ], + "columnsTo": [ + "id" + ], + "onDelete": "cascade", + "onUpdate": "no action" + } + }, + "compositePrimaryKeys": {}, + "uniqueConstraints": { + "ad_impression_imp_url_unique": { + "name": "ad_impression_imp_url_unique", + "nullsNotDistinct": false, + "columns": [ + "imp_url" + ] + } + }, + "policies": {}, + "checkConstraints": {}, + "isRLSEnabled": false + }, + "public.agent_config": { + "name": "agent_config", + "schema": "", + "columns": { + "id": { + "name": "id", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "version": { + "name": "version", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "publisher_id": { + "name": "publisher_id", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "major": { + "name": "major", + "type": "integer", + "primaryKey": false, + "notNull": false, + "generated": { + "as": "CAST(SPLIT_PART(\"agent_config\".\"version\", '.', 1) AS INTEGER)", + "type": "stored" + } + }, + "minor": { + "name": "minor", + "type": "integer", + "primaryKey": false, + "notNull": false, + "generated": { + "as": "CAST(SPLIT_PART(\"agent_config\".\"version\", '.', 2) AS INTEGER)", + "type": "stored" + } + }, + "patch": { + "name": "patch", + "type": "integer", + "primaryKey": false, + "notNull": false, + "generated": { + "as": "CAST(SPLIT_PART(\"agent_config\".\"version\", '.', 3) AS INTEGER)", + "type": "stored" + } + }, + "data": { + "name": "data", + "type": "jsonb", + "primaryKey": false, + "notNull": true + }, + "created_at": { + "name": "created_at", + "type": "timestamp with time zone", + "primaryKey": false, + "notNull": true, + "default": "now()" + }, + "updated_at": { + "name": "updated_at", + "type": "timestamp with time zone", + "primaryKey": false, + "notNull": true, + "default": "now()" + } + }, + "indexes": { + "idx_agent_config_publisher": { + "name": "idx_agent_config_publisher", + "columns": [ + { + "expression": "publisher_id", + "isExpression": false, + "asc": true, + "nulls": "last" + } + ], + "isUnique": false, + "concurrently": false, + "method": "btree", + "with": {} + } + }, + "foreignKeys": { + "agent_config_publisher_id_publisher_id_fk": { + "name": "agent_config_publisher_id_publisher_id_fk", + "tableFrom": "agent_config", + "tableTo": "publisher", + "columnsFrom": [ + "publisher_id" + ], + "columnsTo": [ + "id" + ], + "onDelete": "no action", + "onUpdate": "no action" + } + }, + "compositePrimaryKeys": { + "agent_config_publisher_id_id_version_pk": { + "name": "agent_config_publisher_id_id_version_pk", + "columns": [ + "publisher_id", + "id", + "version" + ] + } + }, + "uniqueConstraints": {}, + "policies": {}, + "checkConstraints": {}, + "isRLSEnabled": false + }, + "public.agent_run": { + "name": "agent_run", + "schema": "", + "columns": { + "id": { + "name": "id", + "type": "text", + "primaryKey": true, + "notNull": true + }, + "user_id": { + "name": "user_id", + "type": "text", + "primaryKey": false, + "notNull": false + }, + "agent_id": { + "name": "agent_id", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "publisher_id": { + "name": "publisher_id", + "type": "text", + "primaryKey": false, + "notNull": false, + "generated": { + "as": "CASE\n WHEN agent_id ~ '^[^/@]+/[^/@]+@[^/@]+$'\n THEN split_part(agent_id, '/', 1)\n ELSE NULL\n END", + "type": "stored" + } + }, + "agent_name": { + "name": "agent_name", + "type": "text", + "primaryKey": false, + "notNull": false, + "generated": { + "as": "CASE\n WHEN agent_id ~ '^[^/@]+/[^/@]+@[^/@]+$'\n THEN split_part(split_part(agent_id, '/', 2), '@', 1)\n ELSE agent_id\n END", + "type": "stored" + } + }, + "agent_version": { + "name": "agent_version", + "type": "text", + "primaryKey": false, + "notNull": false, + "generated": { + "as": "CASE\n WHEN agent_id ~ '^[^/@]+/[^/@]+@[^/@]+$'\n THEN split_part(agent_id, '@', 2)\n ELSE NULL\n END", + "type": "stored" + } + }, + "ancestor_run_ids": { + "name": "ancestor_run_ids", + "type": "text[]", + "primaryKey": false, + "notNull": false + }, + "root_run_id": { + "name": "root_run_id", + "type": "text", + "primaryKey": false, + "notNull": false, + "generated": { + "as": "CASE WHEN array_length(ancestor_run_ids, 1) >= 1 THEN ancestor_run_ids[1] ELSE id END", + "type": "stored" + } + }, + "parent_run_id": { + "name": "parent_run_id", + "type": "text", + "primaryKey": false, + "notNull": false, + "generated": { + "as": "CASE WHEN array_length(ancestor_run_ids, 1) >= 1 THEN ancestor_run_ids[array_length(ancestor_run_ids, 1)] ELSE NULL END", + "type": "stored" + } + }, + "depth": { + "name": "depth", + "type": "integer", + "primaryKey": false, + "notNull": false, + "generated": { + "as": "COALESCE(array_length(ancestor_run_ids, 1), 1)", + "type": "stored" + } + }, + "duration_ms": { + "name": "duration_ms", + "type": "integer", + "primaryKey": false, + "notNull": false, + "generated": { + "as": "CASE WHEN completed_at IS NOT NULL THEN EXTRACT(EPOCH FROM (completed_at - created_at)) * 1000 ELSE NULL END::integer", + "type": "stored" + } + }, + "total_steps": { + "name": "total_steps", + "type": "integer", + "primaryKey": false, + "notNull": false, + "default": 0 + }, + "direct_credits": { + "name": "direct_credits", + "type": "numeric(10, 6)", + "primaryKey": false, + "notNull": false, + "default": "'0'" + }, + "total_credits": { + "name": "total_credits", + "type": "numeric(10, 6)", + "primaryKey": false, + "notNull": false, + "default": "'0'" + }, + "status": { + "name": "status", + "type": "agent_run_status", + "typeSchema": "public", + "primaryKey": false, + "notNull": true, + "default": "'running'" + }, + "error_message": { + "name": "error_message", + "type": "text", + "primaryKey": false, + "notNull": false + }, + "created_at": { + "name": "created_at", + "type": "timestamp with time zone", + "primaryKey": false, + "notNull": true, + "default": "now()" + }, + "completed_at": { + "name": "completed_at", + "type": "timestamp with time zone", + "primaryKey": false, + "notNull": false + } + }, + "indexes": { + "idx_agent_run_user_id": { + "name": "idx_agent_run_user_id", + "columns": [ + { + "expression": "user_id", + "isExpression": false, + "asc": true, + "nulls": "last" + }, + { + "expression": "created_at", + "isExpression": false, + "asc": true, + "nulls": "last" + } + ], + "isUnique": false, + "concurrently": false, + "method": "btree", + "with": {} + }, + "idx_agent_run_parent": { + "name": "idx_agent_run_parent", + "columns": [ + { + "expression": "parent_run_id", + "isExpression": false, + "asc": true, + "nulls": "last" + } + ], + "isUnique": false, + "concurrently": false, + "method": "btree", + "with": {} + }, + "idx_agent_run_root": { + "name": "idx_agent_run_root", + "columns": [ + { + "expression": "root_run_id", + "isExpression": false, + "asc": true, + "nulls": "last" + } + ], + "isUnique": false, + "concurrently": false, + "method": "btree", + "with": {} + }, + "idx_agent_run_agent_id": { + "name": "idx_agent_run_agent_id", + "columns": [ + { + "expression": "agent_id", + "isExpression": false, + "asc": true, + "nulls": "last" + }, + { + "expression": "created_at", + "isExpression": false, + "asc": true, + "nulls": "last" + } + ], + "isUnique": false, + "concurrently": false, + "method": "btree", + "with": {} + }, + "idx_agent_run_publisher": { + "name": "idx_agent_run_publisher", + "columns": [ + { + "expression": "publisher_id", + "isExpression": false, + "asc": true, + "nulls": "last" + }, + { + "expression": "created_at", + "isExpression": false, + "asc": true, + "nulls": "last" + } + ], + "isUnique": false, + "concurrently": false, + "method": "btree", + "with": {} + }, + "idx_agent_run_status": { + "name": "idx_agent_run_status", + "columns": [ + { + "expression": "status", + "isExpression": false, + "asc": true, + "nulls": "last" + } + ], + "isUnique": false, + "where": "\"agent_run\".\"status\" = 'running'", + "concurrently": false, + "method": "btree", + "with": {} + }, + "idx_agent_run_ancestors_gin": { + "name": "idx_agent_run_ancestors_gin", + "columns": [ + { + "expression": "ancestor_run_ids", + "isExpression": false, + "asc": true, + "nulls": "last" + } + ], + "isUnique": false, + "concurrently": false, + "method": "gin", + "with": {} + }, + "idx_agent_run_completed_publisher_agent": { + "name": "idx_agent_run_completed_publisher_agent", + "columns": [ + { + "expression": "publisher_id", + "isExpression": false, + "asc": true, + "nulls": "last" + }, + { + "expression": "agent_name", + "isExpression": false, + "asc": true, + "nulls": "last" + } + ], + "isUnique": false, + "where": "\"agent_run\".\"status\" = 'completed'", + "concurrently": false, + "method": "btree", + "with": {} + }, + "idx_agent_run_completed_recent": { + "name": "idx_agent_run_completed_recent", + "columns": [ + { + "expression": "created_at", + "isExpression": false, + "asc": true, + "nulls": "last" + }, + { + "expression": "publisher_id", + "isExpression": false, + "asc": true, + "nulls": "last" + }, + { + "expression": "agent_name", + "isExpression": false, + "asc": true, + "nulls": "last" + } + ], + "isUnique": false, + "where": "\"agent_run\".\"status\" = 'completed'", + "concurrently": false, + "method": "btree", + "with": {} + }, + "idx_agent_run_completed_version": { + "name": "idx_agent_run_completed_version", + "columns": [ + { + "expression": "publisher_id", + "isExpression": false, + "asc": true, + "nulls": "last" + }, + { + "expression": "agent_name", + "isExpression": false, + "asc": true, + "nulls": "last" + }, + { + "expression": "agent_version", + "isExpression": false, + "asc": true, + "nulls": "last" + }, + { + "expression": "created_at", + "isExpression": false, + "asc": true, + "nulls": "last" + } + ], + "isUnique": false, + "where": "\"agent_run\".\"status\" = 'completed'", + "concurrently": false, + "method": "btree", + "with": {} + }, + "idx_agent_run_completed_user": { + "name": "idx_agent_run_completed_user", + "columns": [ + { + "expression": "user_id", + "isExpression": false, + "asc": true, + "nulls": "last" + } + ], + "isUnique": false, + "where": "\"agent_run\".\"status\" = 'completed'", + "concurrently": false, + "method": "btree", + "with": {} + } + }, + "foreignKeys": { + "agent_run_user_id_user_id_fk": { + "name": "agent_run_user_id_user_id_fk", + "tableFrom": "agent_run", + "tableTo": "user", + "columnsFrom": [ + "user_id" + ], + "columnsTo": [ + "id" + ], + "onDelete": "cascade", + "onUpdate": "no action" + } + }, + "compositePrimaryKeys": {}, + "uniqueConstraints": {}, + "policies": {}, + "checkConstraints": {}, + "isRLSEnabled": false + }, + "public.agent_step": { + "name": "agent_step", + "schema": "", + "columns": { + "id": { + "name": "id", + "type": "text", + "primaryKey": true, + "notNull": true + }, + "agent_run_id": { + "name": "agent_run_id", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "step_number": { + "name": "step_number", + "type": "integer", + "primaryKey": false, + "notNull": true + }, + "duration_ms": { + "name": "duration_ms", + "type": "integer", + "primaryKey": false, + "notNull": false, + "generated": { + "as": "CASE WHEN completed_at IS NOT NULL THEN EXTRACT(EPOCH FROM (completed_at - created_at)) * 1000 ELSE NULL END::integer", + "type": "stored" + } + }, + "credits": { + "name": "credits", + "type": "numeric(10, 6)", + "primaryKey": false, + "notNull": true, + "default": "'0'" + }, + "child_run_ids": { + "name": "child_run_ids", + "type": "text[]", + "primaryKey": false, + "notNull": false + }, + "spawned_count": { + "name": "spawned_count", + "type": "integer", + "primaryKey": false, + "notNull": false, + "generated": { + "as": "array_length(child_run_ids, 1)", + "type": "stored" + } + }, + "message_id": { + "name": "message_id", + "type": "text", + "primaryKey": false, + "notNull": false + }, + "status": { + "name": "status", + "type": "agent_step_status", + "typeSchema": "public", + "primaryKey": false, + "notNull": true, + "default": "'completed'" + }, + "error_message": { + "name": "error_message", + "type": "text", + "primaryKey": false, + "notNull": false + }, + "created_at": { + "name": "created_at", + "type": "timestamp with time zone", + "primaryKey": false, + "notNull": true, + "default": "now()" + }, + "completed_at": { + "name": "completed_at", + "type": "timestamp with time zone", + "primaryKey": false, + "notNull": true, + "default": "now()" + } + }, + "indexes": { + "unique_step_number_per_run": { + "name": "unique_step_number_per_run", + "columns": [ + { + "expression": "agent_run_id", + "isExpression": false, + "asc": true, + "nulls": "last" + }, + { + "expression": "step_number", + "isExpression": false, + "asc": true, + "nulls": "last" + } + ], + "isUnique": true, + "concurrently": false, + "method": "btree", + "with": {} + }, + "idx_agent_step_run_id": { + "name": "idx_agent_step_run_id", + "columns": [ + { + "expression": "agent_run_id", + "isExpression": false, + "asc": true, + "nulls": "last" + } + ], + "isUnique": false, + "concurrently": false, + "method": "btree", + "with": {} + }, + "idx_agent_step_children_gin": { + "name": "idx_agent_step_children_gin", + "columns": [ + { + "expression": "child_run_ids", + "isExpression": false, + "asc": true, + "nulls": "last" + } + ], + "isUnique": false, + "concurrently": false, + "method": "gin", + "with": {} + } + }, + "foreignKeys": { + "agent_step_agent_run_id_agent_run_id_fk": { + "name": "agent_step_agent_run_id_agent_run_id_fk", + "tableFrom": "agent_step", + "tableTo": "agent_run", + "columnsFrom": [ + "agent_run_id" + ], + "columnsTo": [ + "id" + ], + "onDelete": "cascade", + "onUpdate": "no action" + } + }, + "compositePrimaryKeys": {}, + "uniqueConstraints": {}, + "policies": {}, + "checkConstraints": {}, + "isRLSEnabled": false + }, + "public.credit_ledger": { + "name": "credit_ledger", + "schema": "", + "columns": { + "operation_id": { + "name": "operation_id", + "type": "text", + "primaryKey": true, + "notNull": true + }, + "user_id": { + "name": "user_id", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "principal": { + "name": "principal", + "type": "integer", + "primaryKey": false, + "notNull": true + }, + "balance": { + "name": "balance", + "type": "integer", + "primaryKey": false, + "notNull": true + }, + "type": { + "name": "type", + "type": "grant_type", + "typeSchema": "public", + "primaryKey": false, + "notNull": true + }, + "description": { + "name": "description", + "type": "text", + "primaryKey": false, + "notNull": false + }, + "priority": { + "name": "priority", + "type": "integer", + "primaryKey": false, + "notNull": true + }, + "expires_at": { + "name": "expires_at", + "type": "timestamp with time zone", + "primaryKey": false, + "notNull": false + }, + "created_at": { + "name": "created_at", + "type": "timestamp with time zone", + "primaryKey": false, + "notNull": true, + "default": "now()" + }, + "org_id": { + "name": "org_id", + "type": "text", + "primaryKey": false, + "notNull": false + }, + "stripe_subscription_id": { + "name": "stripe_subscription_id", + "type": "text", + "primaryKey": false, + "notNull": false + } + }, + "indexes": { + "idx_credit_ledger_active_balance": { + "name": "idx_credit_ledger_active_balance", + "columns": [ + { + "expression": "user_id", + "isExpression": false, + "asc": true, + "nulls": "last" + }, + { + "expression": "balance", + "isExpression": false, + "asc": true, + "nulls": "last" + }, + { + "expression": "expires_at", + "isExpression": false, + "asc": true, + "nulls": "last" + }, + { + "expression": "priority", + "isExpression": false, + "asc": true, + "nulls": "last" + }, + { + "expression": "created_at", + "isExpression": false, + "asc": true, + "nulls": "last" + } + ], + "isUnique": false, + "where": "\"credit_ledger\".\"balance\" != 0 AND \"credit_ledger\".\"expires_at\" IS NULL", + "concurrently": false, + "method": "btree", + "with": {} + }, + "idx_credit_ledger_org": { + "name": "idx_credit_ledger_org", + "columns": [ + { + "expression": "org_id", + "isExpression": false, + "asc": true, + "nulls": "last" + } + ], + "isUnique": false, + "concurrently": false, + "method": "btree", + "with": {} + }, + "idx_credit_ledger_subscription": { + "name": "idx_credit_ledger_subscription", + "columns": [ + { + "expression": "user_id", + "isExpression": false, + "asc": true, + "nulls": "last" + }, + { + "expression": "type", + "isExpression": false, + "asc": true, + "nulls": "last" + }, + { + "expression": "created_at", + "isExpression": false, + "asc": true, + "nulls": "last" + } + ], + "isUnique": false, + "concurrently": false, + "method": "btree", + "with": {} + } + }, + "foreignKeys": { + "credit_ledger_user_id_user_id_fk": { + "name": "credit_ledger_user_id_user_id_fk", + "tableFrom": "credit_ledger", + "tableTo": "user", + "columnsFrom": [ + "user_id" + ], + "columnsTo": [ + "id" + ], + "onDelete": "cascade", + "onUpdate": "no action" + }, + "credit_ledger_org_id_org_id_fk": { + "name": "credit_ledger_org_id_org_id_fk", + "tableFrom": "credit_ledger", + "tableTo": "org", + "columnsFrom": [ + "org_id" + ], + "columnsTo": [ + "id" + ], + "onDelete": "cascade", + "onUpdate": "no action" + } + }, + "compositePrimaryKeys": {}, + "uniqueConstraints": {}, + "policies": {}, + "checkConstraints": {}, + "isRLSEnabled": false + }, + "public.encrypted_api_keys": { + "name": "encrypted_api_keys", + "schema": "", + "columns": { + "user_id": { + "name": "user_id", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "type": { + "name": "type", + "type": "api_key_type", + "typeSchema": "public", + "primaryKey": false, + "notNull": true + }, + "api_key": { + "name": "api_key", + "type": "text", + "primaryKey": false, + "notNull": true + } + }, + "indexes": {}, + "foreignKeys": { + "encrypted_api_keys_user_id_user_id_fk": { + "name": "encrypted_api_keys_user_id_user_id_fk", + "tableFrom": "encrypted_api_keys", + "tableTo": "user", + "columnsFrom": [ + "user_id" + ], + "columnsTo": [ + "id" + ], + "onDelete": "cascade", + "onUpdate": "no action" + } + }, + "compositePrimaryKeys": { + "encrypted_api_keys_user_id_type_pk": { + "name": "encrypted_api_keys_user_id_type_pk", + "columns": [ + "user_id", + "type" + ] + } + }, + "uniqueConstraints": {}, + "policies": {}, + "checkConstraints": {}, + "isRLSEnabled": false + }, + "public.fingerprint": { + "name": "fingerprint", + "schema": "", + "columns": { + "id": { + "name": "id", + "type": "text", + "primaryKey": true, + "notNull": true + }, + "sig_hash": { + "name": "sig_hash", + "type": "text", + "primaryKey": false, + "notNull": false + }, + "created_at": { + "name": "created_at", + "type": "timestamp", + "primaryKey": false, + "notNull": true, + "default": "now()" + } + }, + "indexes": {}, + "foreignKeys": {}, + "compositePrimaryKeys": {}, + "uniqueConstraints": {}, + "policies": {}, + "checkConstraints": {}, + "isRLSEnabled": false + }, + "public.free_session": { + "name": "free_session", + "schema": "", + "columns": { + "user_id": { + "name": "user_id", + "type": "text", + "primaryKey": true, + "notNull": true + }, + "status": { + "name": "status", + "type": "free_session_status", + "typeSchema": "public", + "primaryKey": false, + "notNull": true + }, + "active_instance_id": { + "name": "active_instance_id", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "model": { + "name": "model", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "queued_at": { + "name": "queued_at", + "type": "timestamp with time zone", + "primaryKey": false, + "notNull": true, + "default": "now()" + }, + "admitted_at": { + "name": "admitted_at", + "type": "timestamp with time zone", + "primaryKey": false, + "notNull": false + }, + "expires_at": { + "name": "expires_at", + "type": "timestamp with time zone", + "primaryKey": false, + "notNull": false + }, + "created_at": { + "name": "created_at", + "type": "timestamp with time zone", + "primaryKey": false, + "notNull": true, + "default": "now()" + }, + "updated_at": { + "name": "updated_at", + "type": "timestamp with time zone", + "primaryKey": false, + "notNull": true, + "default": "now()" + } + }, + "indexes": { + "idx_free_session_queue": { + "name": "idx_free_session_queue", + "columns": [ + { + "expression": "status", + "isExpression": false, + "asc": true, + "nulls": "last" + }, + { + "expression": "model", + "isExpression": false, + "asc": true, + "nulls": "last" + }, + { + "expression": "queued_at", + "isExpression": false, + "asc": true, + "nulls": "last" + } + ], + "isUnique": false, + "concurrently": false, + "method": "btree", + "with": {} + }, + "idx_free_session_expiry": { + "name": "idx_free_session_expiry", + "columns": [ + { + "expression": "expires_at", + "isExpression": false, + "asc": true, + "nulls": "last" + } + ], + "isUnique": false, + "concurrently": false, + "method": "btree", + "with": {} + } + }, + "foreignKeys": { + "free_session_user_id_user_id_fk": { + "name": "free_session_user_id_user_id_fk", + "tableFrom": "free_session", + "tableTo": "user", + "columnsFrom": [ + "user_id" + ], + "columnsTo": [ + "id" + ], + "onDelete": "cascade", + "onUpdate": "no action" + } + }, + "compositePrimaryKeys": {}, + "uniqueConstraints": {}, + "policies": {}, + "checkConstraints": {}, + "isRLSEnabled": false + }, + "public.free_session_admit": { + "name": "free_session_admit", + "schema": "", + "columns": { + "id": { + "name": "id", + "type": "text", + "primaryKey": true, + "notNull": true + }, + "user_id": { + "name": "user_id", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "model": { + "name": "model", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "admitted_at": { + "name": "admitted_at", + "type": "timestamp with time zone", + "primaryKey": false, + "notNull": true, + "default": "now()" + } + }, + "indexes": { + "idx_free_session_admit_user_model_time": { + "name": "idx_free_session_admit_user_model_time", + "columns": [ + { + "expression": "user_id", + "isExpression": false, + "asc": true, + "nulls": "last" + }, + { + "expression": "model", + "isExpression": false, + "asc": true, + "nulls": "last" + }, + { + "expression": "admitted_at", + "isExpression": false, + "asc": true, + "nulls": "last" + } + ], + "isUnique": false, + "concurrently": false, + "method": "btree", + "with": {} + } + }, + "foreignKeys": { + "free_session_admit_user_id_user_id_fk": { + "name": "free_session_admit_user_id_user_id_fk", + "tableFrom": "free_session_admit", + "tableTo": "user", + "columnsFrom": [ + "user_id" + ], + "columnsTo": [ + "id" + ], + "onDelete": "cascade", + "onUpdate": "no action" + } + }, + "compositePrimaryKeys": {}, + "uniqueConstraints": {}, + "policies": {}, + "checkConstraints": {}, + "isRLSEnabled": false + }, + "public.git_eval_results": { + "name": "git_eval_results", + "schema": "", + "columns": { + "id": { + "name": "id", + "type": "text", + "primaryKey": true, + "notNull": true + }, + "cost_mode": { + "name": "cost_mode", + "type": "text", + "primaryKey": false, + "notNull": false + }, + "reasoner_model": { + "name": "reasoner_model", + "type": "text", + "primaryKey": false, + "notNull": false + }, + "agent_model": { + "name": "agent_model", + "type": "text", + "primaryKey": false, + "notNull": false + }, + "metadata": { + "name": "metadata", + "type": "jsonb", + "primaryKey": false, + "notNull": false + }, + "cost": { + "name": "cost", + "type": "integer", + "primaryKey": false, + "notNull": true, + "default": 0 + }, + "is_public": { + "name": "is_public", + "type": "boolean", + "primaryKey": false, + "notNull": true, + "default": false + }, + "created_at": { + "name": "created_at", + "type": "timestamp with time zone", + "primaryKey": false, + "notNull": true, + "default": "now()" + } + }, + "indexes": {}, + "foreignKeys": {}, + "compositePrimaryKeys": {}, + "uniqueConstraints": {}, + "policies": {}, + "checkConstraints": {}, + "isRLSEnabled": false + }, + "public.limit_override": { + "name": "limit_override", + "schema": "", + "columns": { + "user_id": { + "name": "user_id", + "type": "text", + "primaryKey": true, + "notNull": true + }, + "credits_per_block": { + "name": "credits_per_block", + "type": "integer", + "primaryKey": false, + "notNull": true + }, + "block_duration_hours": { + "name": "block_duration_hours", + "type": "integer", + "primaryKey": false, + "notNull": true + }, + "weekly_credit_limit": { + "name": "weekly_credit_limit", + "type": "integer", + "primaryKey": false, + "notNull": true + }, + "created_at": { + "name": "created_at", + "type": "timestamp with time zone", + "primaryKey": false, + "notNull": true, + "default": "now()" + }, + "updated_at": { + "name": "updated_at", + "type": "timestamp with time zone", + "primaryKey": false, + "notNull": true, + "default": "now()" + } + }, + "indexes": {}, + "foreignKeys": { + "limit_override_user_id_user_id_fk": { + "name": "limit_override_user_id_user_id_fk", + "tableFrom": "limit_override", + "tableTo": "user", + "columnsFrom": [ + "user_id" + ], + "columnsTo": [ + "id" + ], + "onDelete": "cascade", + "onUpdate": "no action" + } + }, + "compositePrimaryKeys": {}, + "uniqueConstraints": {}, + "policies": {}, + "checkConstraints": {}, + "isRLSEnabled": false + }, + "public.message": { + "name": "message", + "schema": "", + "columns": { + "id": { + "name": "id", + "type": "text", + "primaryKey": true, + "notNull": true + }, + "finished_at": { + "name": "finished_at", + "type": "timestamp", + "primaryKey": false, + "notNull": true + }, + "client_id": { + "name": "client_id", + "type": "text", + "primaryKey": false, + "notNull": false + }, + "client_request_id": { + "name": "client_request_id", + "type": "text", + "primaryKey": false, + "notNull": false + }, + "model": { + "name": "model", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "agent_id": { + "name": "agent_id", + "type": "text", + "primaryKey": false, + "notNull": false + }, + "request": { + "name": "request", + "type": "jsonb", + "primaryKey": false, + "notNull": false + }, + "last_message": { + "name": "last_message", + "type": "jsonb", + "primaryKey": false, + "notNull": false, + "generated": { + "as": "\"message\".\"request\" -> -1", + "type": "stored" + } + }, + "reasoning_text": { + "name": "reasoning_text", + "type": "text", + "primaryKey": false, + "notNull": false + }, + "response": { + "name": "response", + "type": "jsonb", + "primaryKey": false, + "notNull": true + }, + "input_tokens": { + "name": "input_tokens", + "type": "integer", + "primaryKey": false, + "notNull": true, + "default": 0 + }, + "cache_creation_input_tokens": { + "name": "cache_creation_input_tokens", + "type": "integer", + "primaryKey": false, + "notNull": false + }, + "cache_read_input_tokens": { + "name": "cache_read_input_tokens", + "type": "integer", + "primaryKey": false, + "notNull": true, + "default": 0 + }, + "reasoning_tokens": { + "name": "reasoning_tokens", + "type": "integer", + "primaryKey": false, + "notNull": false + }, + "output_tokens": { + "name": "output_tokens", + "type": "integer", + "primaryKey": false, + "notNull": true + }, + "cost": { + "name": "cost", + "type": "numeric(100, 20)", + "primaryKey": false, + "notNull": true + }, + "credits": { + "name": "credits", + "type": "integer", + "primaryKey": false, + "notNull": true + }, + "byok": { + "name": "byok", + "type": "boolean", + "primaryKey": false, + "notNull": true, + "default": false + }, + "latency_ms": { + "name": "latency_ms", + "type": "integer", + "primaryKey": false, + "notNull": false + }, + "ttft_ms": { + "name": "ttft_ms", + "type": "integer", + "primaryKey": false, + "notNull": false + }, + "user_id": { + "name": "user_id", + "type": "text", + "primaryKey": false, + "notNull": false + }, + "org_id": { + "name": "org_id", + "type": "text", + "primaryKey": false, + "notNull": false + }, + "repo_url": { + "name": "repo_url", + "type": "text", + "primaryKey": false, + "notNull": false + } + }, + "indexes": { + "message_user_id_idx": { + "name": "message_user_id_idx", + "columns": [ + { + "expression": "user_id", + "isExpression": false, + "asc": true, + "nulls": "last" + } + ], + "isUnique": false, + "concurrently": false, + "method": "btree", + "with": {} + }, + "message_finished_at_user_id_idx": { + "name": "message_finished_at_user_id_idx", + "columns": [ + { + "expression": "finished_at", + "isExpression": false, + "asc": true, + "nulls": "last" + }, + { + "expression": "user_id", + "isExpression": false, + "asc": true, + "nulls": "last" + } + ], + "isUnique": false, + "concurrently": false, + "method": "btree", + "with": {} + }, + "message_org_id_idx": { + "name": "message_org_id_idx", + "columns": [ + { + "expression": "org_id", + "isExpression": false, + "asc": true, + "nulls": "last" + } + ], + "isUnique": false, + "concurrently": false, + "method": "btree", + "with": {} + }, + "message_org_id_finished_at_idx": { + "name": "message_org_id_finished_at_idx", + "columns": [ + { + "expression": "org_id", + "isExpression": false, + "asc": true, + "nulls": "last" + }, + { + "expression": "finished_at", + "isExpression": false, + "asc": true, + "nulls": "last" + } + ], + "isUnique": false, + "concurrently": false, + "method": "btree", + "with": {} + } + }, + "foreignKeys": { + "message_user_id_user_id_fk": { + "name": "message_user_id_user_id_fk", + "tableFrom": "message", + "tableTo": "user", + "columnsFrom": [ + "user_id" + ], + "columnsTo": [ + "id" + ], + "onDelete": "cascade", + "onUpdate": "no action" + }, + "message_org_id_org_id_fk": { + "name": "message_org_id_org_id_fk", + "tableFrom": "message", + "tableTo": "org", + "columnsFrom": [ + "org_id" + ], + "columnsTo": [ + "id" + ], + "onDelete": "cascade", + "onUpdate": "no action" + } + }, + "compositePrimaryKeys": {}, + "uniqueConstraints": {}, + "policies": {}, + "checkConstraints": {}, + "isRLSEnabled": false + }, + "public.org": { + "name": "org", + "schema": "", + "columns": { + "id": { + "name": "id", + "type": "text", + "primaryKey": true, + "notNull": true + }, + "name": { + "name": "name", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "slug": { + "name": "slug", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "description": { + "name": "description", + "type": "text", + "primaryKey": false, + "notNull": false + }, + "owner_id": { + "name": "owner_id", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "stripe_customer_id": { + "name": "stripe_customer_id", + "type": "text", + "primaryKey": false, + "notNull": false + }, + "stripe_subscription_id": { + "name": "stripe_subscription_id", + "type": "text", + "primaryKey": false, + "notNull": false + }, + "current_period_start": { + "name": "current_period_start", + "type": "timestamp with time zone", + "primaryKey": false, + "notNull": false + }, + "current_period_end": { + "name": "current_period_end", + "type": "timestamp with time zone", + "primaryKey": false, + "notNull": false + }, + "auto_topup_enabled": { + "name": "auto_topup_enabled", + "type": "boolean", + "primaryKey": false, + "notNull": true, + "default": false + }, + "auto_topup_threshold": { + "name": "auto_topup_threshold", + "type": "integer", + "primaryKey": false, + "notNull": true + }, + "auto_topup_amount": { + "name": "auto_topup_amount", + "type": "integer", + "primaryKey": false, + "notNull": true + }, + "credit_limit": { + "name": "credit_limit", + "type": "integer", + "primaryKey": false, + "notNull": false + }, + "billing_alerts": { + "name": "billing_alerts", + "type": "boolean", + "primaryKey": false, + "notNull": true, + "default": true + }, + "usage_alerts": { + "name": "usage_alerts", + "type": "boolean", + "primaryKey": false, + "notNull": true, + "default": true + }, + "weekly_reports": { + "name": "weekly_reports", + "type": "boolean", + "primaryKey": false, + "notNull": true, + "default": false + }, + "created_at": { + "name": "created_at", + "type": "timestamp with time zone", + "primaryKey": false, + "notNull": true, + "default": "now()" + }, + "updated_at": { + "name": "updated_at", + "type": "timestamp with time zone", + "primaryKey": false, + "notNull": true, + "default": "now()" + } + }, + "indexes": {}, + "foreignKeys": { + "org_owner_id_user_id_fk": { + "name": "org_owner_id_user_id_fk", + "tableFrom": "org", + "tableTo": "user", + "columnsFrom": [ + "owner_id" + ], + "columnsTo": [ + "id" + ], + "onDelete": "cascade", + "onUpdate": "no action" + } + }, + "compositePrimaryKeys": {}, + "uniqueConstraints": { + "org_slug_unique": { + "name": "org_slug_unique", + "nullsNotDistinct": false, + "columns": [ + "slug" + ] + }, + "org_stripe_customer_id_unique": { + "name": "org_stripe_customer_id_unique", + "nullsNotDistinct": false, + "columns": [ + "stripe_customer_id" + ] + } + }, + "policies": {}, + "checkConstraints": {}, + "isRLSEnabled": false + }, + "public.org_feature": { + "name": "org_feature", + "schema": "", + "columns": { + "org_id": { + "name": "org_id", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "feature": { + "name": "feature", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "config": { + "name": "config", + "type": "jsonb", + "primaryKey": false, + "notNull": false + }, + "is_active": { + "name": "is_active", + "type": "boolean", + "primaryKey": false, + "notNull": true, + "default": true + }, + "created_at": { + "name": "created_at", + "type": "timestamp with time zone", + "primaryKey": false, + "notNull": true, + "default": "now()" + }, + "updated_at": { + "name": "updated_at", + "type": "timestamp with time zone", + "primaryKey": false, + "notNull": true, + "default": "now()" + } + }, + "indexes": { + "idx_org_feature_active": { + "name": "idx_org_feature_active", + "columns": [ + { + "expression": "org_id", + "isExpression": false, + "asc": true, + "nulls": "last" + }, + { + "expression": "is_active", + "isExpression": false, + "asc": true, + "nulls": "last" + } + ], + "isUnique": false, + "concurrently": false, + "method": "btree", + "with": {} + } + }, + "foreignKeys": { + "org_feature_org_id_org_id_fk": { + "name": "org_feature_org_id_org_id_fk", + "tableFrom": "org_feature", + "tableTo": "org", + "columnsFrom": [ + "org_id" + ], + "columnsTo": [ + "id" + ], + "onDelete": "cascade", + "onUpdate": "no action" + } + }, + "compositePrimaryKeys": { + "org_feature_org_id_feature_pk": { + "name": "org_feature_org_id_feature_pk", + "columns": [ + "org_id", + "feature" + ] + } + }, + "uniqueConstraints": {}, + "policies": {}, + "checkConstraints": {}, + "isRLSEnabled": false + }, + "public.org_invite": { + "name": "org_invite", + "schema": "", + "columns": { + "id": { + "name": "id", + "type": "text", + "primaryKey": true, + "notNull": true + }, + "org_id": { + "name": "org_id", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "email": { + "name": "email", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "role": { + "name": "role", + "type": "org_role", + "typeSchema": "public", + "primaryKey": false, + "notNull": true + }, + "token": { + "name": "token", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "invited_by": { + "name": "invited_by", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "expires_at": { + "name": "expires_at", + "type": "timestamp with time zone", + "primaryKey": false, + "notNull": true + }, + "created_at": { + "name": "created_at", + "type": "timestamp with time zone", + "primaryKey": false, + "notNull": true, + "default": "now()" + }, + "accepted_at": { + "name": "accepted_at", + "type": "timestamp with time zone", + "primaryKey": false, + "notNull": false + }, + "accepted_by": { + "name": "accepted_by", + "type": "text", + "primaryKey": false, + "notNull": false + } + }, + "indexes": { + "idx_org_invite_token": { + "name": "idx_org_invite_token", + "columns": [ + { + "expression": "token", + "isExpression": false, + "asc": true, + "nulls": "last" + } + ], + "isUnique": false, + "concurrently": false, + "method": "btree", + "with": {} + }, + "idx_org_invite_email": { + "name": "idx_org_invite_email", + "columns": [ + { + "expression": "org_id", + "isExpression": false, + "asc": true, + "nulls": "last" + }, + { + "expression": "email", + "isExpression": false, + "asc": true, + "nulls": "last" + } + ], + "isUnique": false, + "concurrently": false, + "method": "btree", + "with": {} + }, + "idx_org_invite_expires": { + "name": "idx_org_invite_expires", + "columns": [ + { + "expression": "expires_at", + "isExpression": false, + "asc": true, + "nulls": "last" + } + ], + "isUnique": false, + "concurrently": false, + "method": "btree", + "with": {} + } + }, + "foreignKeys": { + "org_invite_org_id_org_id_fk": { + "name": "org_invite_org_id_org_id_fk", + "tableFrom": "org_invite", + "tableTo": "org", + "columnsFrom": [ + "org_id" + ], + "columnsTo": [ + "id" + ], + "onDelete": "cascade", + "onUpdate": "no action" + }, + "org_invite_invited_by_user_id_fk": { + "name": "org_invite_invited_by_user_id_fk", + "tableFrom": "org_invite", + "tableTo": "user", + "columnsFrom": [ + "invited_by" + ], + "columnsTo": [ + "id" + ], + "onDelete": "no action", + "onUpdate": "no action" + }, + "org_invite_accepted_by_user_id_fk": { + "name": "org_invite_accepted_by_user_id_fk", + "tableFrom": "org_invite", + "tableTo": "user", + "columnsFrom": [ + "accepted_by" + ], + "columnsTo": [ + "id" + ], + "onDelete": "no action", + "onUpdate": "no action" + } + }, + "compositePrimaryKeys": {}, + "uniqueConstraints": { + "org_invite_token_unique": { + "name": "org_invite_token_unique", + "nullsNotDistinct": false, + "columns": [ + "token" + ] + } + }, + "policies": {}, + "checkConstraints": {}, + "isRLSEnabled": false + }, + "public.org_member": { + "name": "org_member", + "schema": "", + "columns": { + "org_id": { + "name": "org_id", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "user_id": { + "name": "user_id", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "role": { + "name": "role", + "type": "org_role", + "typeSchema": "public", + "primaryKey": false, + "notNull": true + }, + "joined_at": { + "name": "joined_at", + "type": "timestamp with time zone", + "primaryKey": false, + "notNull": true, + "default": "now()" + } + }, + "indexes": {}, + "foreignKeys": { + "org_member_org_id_org_id_fk": { + "name": "org_member_org_id_org_id_fk", + "tableFrom": "org_member", + "tableTo": "org", + "columnsFrom": [ + "org_id" + ], + "columnsTo": [ + "id" + ], + "onDelete": "cascade", + "onUpdate": "no action" + }, + "org_member_user_id_user_id_fk": { + "name": "org_member_user_id_user_id_fk", + "tableFrom": "org_member", + "tableTo": "user", + "columnsFrom": [ + "user_id" + ], + "columnsTo": [ + "id" + ], + "onDelete": "cascade", + "onUpdate": "no action" + } + }, + "compositePrimaryKeys": { + "org_member_org_id_user_id_pk": { + "name": "org_member_org_id_user_id_pk", + "columns": [ + "org_id", + "user_id" + ] + } + }, + "uniqueConstraints": {}, + "policies": {}, + "checkConstraints": {}, + "isRLSEnabled": false + }, + "public.org_repo": { + "name": "org_repo", + "schema": "", + "columns": { + "id": { + "name": "id", + "type": "text", + "primaryKey": true, + "notNull": true + }, + "org_id": { + "name": "org_id", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "repo_url": { + "name": "repo_url", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "repo_name": { + "name": "repo_name", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "repo_owner": { + "name": "repo_owner", + "type": "text", + "primaryKey": false, + "notNull": false + }, + "approved_by": { + "name": "approved_by", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "approved_at": { + "name": "approved_at", + "type": "timestamp with time zone", + "primaryKey": false, + "notNull": true, + "default": "now()" + }, + "is_active": { + "name": "is_active", + "type": "boolean", + "primaryKey": false, + "notNull": true, + "default": true + } + }, + "indexes": { + "idx_org_repo_active": { + "name": "idx_org_repo_active", + "columns": [ + { + "expression": "org_id", + "isExpression": false, + "asc": true, + "nulls": "last" + }, + { + "expression": "is_active", + "isExpression": false, + "asc": true, + "nulls": "last" + } + ], + "isUnique": false, + "concurrently": false, + "method": "btree", + "with": {} + }, + "idx_org_repo_unique": { + "name": "idx_org_repo_unique", + "columns": [ + { + "expression": "org_id", + "isExpression": false, + "asc": true, + "nulls": "last" + }, + { + "expression": "repo_url", + "isExpression": false, + "asc": true, + "nulls": "last" + } + ], + "isUnique": false, + "concurrently": false, + "method": "btree", + "with": {} + } + }, + "foreignKeys": { + "org_repo_org_id_org_id_fk": { + "name": "org_repo_org_id_org_id_fk", + "tableFrom": "org_repo", + "tableTo": "org", + "columnsFrom": [ + "org_id" + ], + "columnsTo": [ + "id" + ], + "onDelete": "cascade", + "onUpdate": "no action" + }, + "org_repo_approved_by_user_id_fk": { + "name": "org_repo_approved_by_user_id_fk", + "tableFrom": "org_repo", + "tableTo": "user", + "columnsFrom": [ + "approved_by" + ], + "columnsTo": [ + "id" + ], + "onDelete": "no action", + "onUpdate": "no action" + } + }, + "compositePrimaryKeys": {}, + "uniqueConstraints": {}, + "policies": {}, + "checkConstraints": {}, + "isRLSEnabled": false + }, + "public.publisher": { + "name": "publisher", + "schema": "", + "columns": { + "id": { + "name": "id", + "type": "text", + "primaryKey": true, + "notNull": true + }, + "name": { + "name": "name", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "email": { + "name": "email", + "type": "text", + "primaryKey": false, + "notNull": false + }, + "verified": { + "name": "verified", + "type": "boolean", + "primaryKey": false, + "notNull": true, + "default": false + }, + "bio": { + "name": "bio", + "type": "text", + "primaryKey": false, + "notNull": false + }, + "avatar_url": { + "name": "avatar_url", + "type": "text", + "primaryKey": false, + "notNull": false + }, + "user_id": { + "name": "user_id", + "type": "text", + "primaryKey": false, + "notNull": false + }, + "org_id": { + "name": "org_id", + "type": "text", + "primaryKey": false, + "notNull": false + }, + "created_by": { + "name": "created_by", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "created_at": { + "name": "created_at", + "type": "timestamp with time zone", + "primaryKey": false, + "notNull": true, + "default": "now()" + }, + "updated_at": { + "name": "updated_at", + "type": "timestamp with time zone", + "primaryKey": false, + "notNull": true, + "default": "now()" + } + }, + "indexes": {}, + "foreignKeys": { + "publisher_user_id_user_id_fk": { + "name": "publisher_user_id_user_id_fk", + "tableFrom": "publisher", + "tableTo": "user", + "columnsFrom": [ + "user_id" + ], + "columnsTo": [ + "id" + ], + "onDelete": "no action", + "onUpdate": "no action" + }, + "publisher_org_id_org_id_fk": { + "name": "publisher_org_id_org_id_fk", + "tableFrom": "publisher", + "tableTo": "org", + "columnsFrom": [ + "org_id" + ], + "columnsTo": [ + "id" + ], + "onDelete": "no action", + "onUpdate": "no action" + }, + "publisher_created_by_user_id_fk": { + "name": "publisher_created_by_user_id_fk", + "tableFrom": "publisher", + "tableTo": "user", + "columnsFrom": [ + "created_by" + ], + "columnsTo": [ + "id" + ], + "onDelete": "no action", + "onUpdate": "no action" + } + }, + "compositePrimaryKeys": {}, + "uniqueConstraints": {}, + "policies": {}, + "checkConstraints": { + "publisher_single_owner": { + "name": "publisher_single_owner", + "value": "(\"publisher\".\"user_id\" IS NOT NULL AND \"publisher\".\"org_id\" IS NULL) OR\n (\"publisher\".\"user_id\" IS NULL AND \"publisher\".\"org_id\" IS NOT NULL)" + } + }, + "isRLSEnabled": false + }, + "public.referral": { + "name": "referral", + "schema": "", + "columns": { + "referrer_id": { + "name": "referrer_id", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "referred_id": { + "name": "referred_id", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "status": { + "name": "status", + "type": "referral_status", + "typeSchema": "public", + "primaryKey": false, + "notNull": true, + "default": "'pending'" + }, + "credits": { + "name": "credits", + "type": "integer", + "primaryKey": false, + "notNull": true + }, + "is_legacy": { + "name": "is_legacy", + "type": "boolean", + "primaryKey": false, + "notNull": true, + "default": false + }, + "created_at": { + "name": "created_at", + "type": "timestamp", + "primaryKey": false, + "notNull": true, + "default": "now()" + }, + "completed_at": { + "name": "completed_at", + "type": "timestamp", + "primaryKey": false, + "notNull": false + } + }, + "indexes": {}, + "foreignKeys": { + "referral_referrer_id_user_id_fk": { + "name": "referral_referrer_id_user_id_fk", + "tableFrom": "referral", + "tableTo": "user", + "columnsFrom": [ + "referrer_id" + ], + "columnsTo": [ + "id" + ], + "onDelete": "no action", + "onUpdate": "no action" + }, + "referral_referred_id_user_id_fk": { + "name": "referral_referred_id_user_id_fk", + "tableFrom": "referral", + "tableTo": "user", + "columnsFrom": [ + "referred_id" + ], + "columnsTo": [ + "id" + ], + "onDelete": "no action", + "onUpdate": "no action" + } + }, + "compositePrimaryKeys": { + "referral_referrer_id_referred_id_pk": { + "name": "referral_referrer_id_referred_id_pk", + "columns": [ + "referrer_id", + "referred_id" + ] + } + }, + "uniqueConstraints": {}, + "policies": {}, + "checkConstraints": {}, + "isRLSEnabled": false + }, + "public.session": { + "name": "session", + "schema": "", + "columns": { + "sessionToken": { + "name": "sessionToken", + "type": "text", + "primaryKey": true, + "notNull": true + }, + "userId": { + "name": "userId", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "expires": { + "name": "expires", + "type": "timestamp", + "primaryKey": false, + "notNull": true + }, + "fingerprint_id": { + "name": "fingerprint_id", + "type": "text", + "primaryKey": false, + "notNull": false + }, + "type": { + "name": "type", + "type": "session_type", + "typeSchema": "public", + "primaryKey": false, + "notNull": true, + "default": "'web'" + }, + "created_at": { + "name": "created_at", + "type": "timestamp", + "primaryKey": false, + "notNull": true, + "default": "now()" + } + }, + "indexes": {}, + "foreignKeys": { + "session_userId_user_id_fk": { + "name": "session_userId_user_id_fk", + "tableFrom": "session", + "tableTo": "user", + "columnsFrom": [ + "userId" + ], + "columnsTo": [ + "id" + ], + "onDelete": "cascade", + "onUpdate": "no action" + }, + "session_fingerprint_id_fingerprint_id_fk": { + "name": "session_fingerprint_id_fingerprint_id_fk", + "tableFrom": "session", + "tableTo": "fingerprint", + "columnsFrom": [ + "fingerprint_id" + ], + "columnsTo": [ + "id" + ], + "onDelete": "no action", + "onUpdate": "no action" + } + }, + "compositePrimaryKeys": {}, + "uniqueConstraints": {}, + "policies": {}, + "checkConstraints": {}, + "isRLSEnabled": false + }, + "public.subscription": { + "name": "subscription", + "schema": "", + "columns": { + "stripe_subscription_id": { + "name": "stripe_subscription_id", + "type": "text", + "primaryKey": true, + "notNull": true + }, + "stripe_customer_id": { + "name": "stripe_customer_id", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "user_id": { + "name": "user_id", + "type": "text", + "primaryKey": false, + "notNull": false + }, + "stripe_price_id": { + "name": "stripe_price_id", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "tier": { + "name": "tier", + "type": "integer", + "primaryKey": false, + "notNull": false + }, + "scheduled_tier": { + "name": "scheduled_tier", + "type": "integer", + "primaryKey": false, + "notNull": false + }, + "status": { + "name": "status", + "type": "subscription_status", + "typeSchema": "public", + "primaryKey": false, + "notNull": true, + "default": "'active'" + }, + "billing_period_start": { + "name": "billing_period_start", + "type": "timestamp with time zone", + "primaryKey": false, + "notNull": true + }, + "billing_period_end": { + "name": "billing_period_end", + "type": "timestamp with time zone", + "primaryKey": false, + "notNull": true + }, + "cancel_at_period_end": { + "name": "cancel_at_period_end", + "type": "boolean", + "primaryKey": false, + "notNull": true, + "default": false + }, + "canceled_at": { + "name": "canceled_at", + "type": "timestamp with time zone", + "primaryKey": false, + "notNull": false + }, + "created_at": { + "name": "created_at", + "type": "timestamp with time zone", + "primaryKey": false, + "notNull": true, + "default": "now()" + }, + "updated_at": { + "name": "updated_at", + "type": "timestamp with time zone", + "primaryKey": false, + "notNull": true, + "default": "now()" + } + }, + "indexes": { + "idx_subscription_customer": { + "name": "idx_subscription_customer", + "columns": [ + { + "expression": "stripe_customer_id", + "isExpression": false, + "asc": true, + "nulls": "last" + } + ], + "isUnique": false, + "concurrently": false, + "method": "btree", + "with": {} + }, + "idx_subscription_user": { + "name": "idx_subscription_user", + "columns": [ + { + "expression": "user_id", + "isExpression": false, + "asc": true, + "nulls": "last" + } + ], + "isUnique": false, + "concurrently": false, + "method": "btree", + "with": {} + }, + "idx_subscription_status": { + "name": "idx_subscription_status", + "columns": [ + { + "expression": "status", + "isExpression": false, + "asc": true, + "nulls": "last" + } + ], + "isUnique": false, + "where": "\"subscription\".\"status\" = 'active'", + "concurrently": false, + "method": "btree", + "with": {} + } + }, + "foreignKeys": { + "subscription_user_id_user_id_fk": { + "name": "subscription_user_id_user_id_fk", + "tableFrom": "subscription", + "tableTo": "user", + "columnsFrom": [ + "user_id" + ], + "columnsTo": [ + "id" + ], + "onDelete": "cascade", + "onUpdate": "no action" + } + }, + "compositePrimaryKeys": {}, + "uniqueConstraints": {}, + "policies": {}, + "checkConstraints": {}, + "isRLSEnabled": false + }, + "public.sync_failure": { + "name": "sync_failure", + "schema": "", + "columns": { + "id": { + "name": "id", + "type": "text", + "primaryKey": true, + "notNull": true + }, + "provider": { + "name": "provider", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "created_at": { + "name": "created_at", + "type": "timestamp with time zone", + "primaryKey": false, + "notNull": true, + "default": "now()" + }, + "last_attempt_at": { + "name": "last_attempt_at", + "type": "timestamp with time zone", + "primaryKey": false, + "notNull": true, + "default": "now()" + }, + "retry_count": { + "name": "retry_count", + "type": "integer", + "primaryKey": false, + "notNull": true, + "default": 1 + }, + "last_error": { + "name": "last_error", + "type": "text", + "primaryKey": false, + "notNull": true + } + }, + "indexes": { + "idx_sync_failure_retry": { + "name": "idx_sync_failure_retry", + "columns": [ + { + "expression": "retry_count", + "isExpression": false, + "asc": true, + "nulls": "last" + }, + { + "expression": "last_attempt_at", + "isExpression": false, + "asc": true, + "nulls": "last" + } + ], + "isUnique": false, + "where": "\"sync_failure\".\"retry_count\" < 5", + "concurrently": false, + "method": "btree", + "with": {} + } + }, + "foreignKeys": {}, + "compositePrimaryKeys": {}, + "uniqueConstraints": {}, + "policies": {}, + "checkConstraints": {}, + "isRLSEnabled": false + }, + "public.user": { + "name": "user", + "schema": "", + "columns": { + "id": { + "name": "id", + "type": "text", + "primaryKey": true, + "notNull": true + }, + "name": { + "name": "name", + "type": "text", + "primaryKey": false, + "notNull": false + }, + "email": { + "name": "email", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "password": { + "name": "password", + "type": "text", + "primaryKey": false, + "notNull": false + }, + "emailVerified": { + "name": "emailVerified", + "type": "timestamp", + "primaryKey": false, + "notNull": false + }, + "image": { + "name": "image", + "type": "text", + "primaryKey": false, + "notNull": false + }, + "stripe_customer_id": { + "name": "stripe_customer_id", + "type": "text", + "primaryKey": false, + "notNull": false + }, + "next_quota_reset": { + "name": "next_quota_reset", + "type": "timestamp", + "primaryKey": false, + "notNull": false, + "default": "now() + INTERVAL '1 month'" + }, + "created_at": { + "name": "created_at", + "type": "timestamp", + "primaryKey": false, + "notNull": true, + "default": "now()" + }, + "referral_code": { + "name": "referral_code", + "type": "text", + "primaryKey": false, + "notNull": false, + "default": "'ref-' || gen_random_uuid()" + }, + "referral_limit": { + "name": "referral_limit", + "type": "integer", + "primaryKey": false, + "notNull": true, + "default": 5 + }, + "discord_id": { + "name": "discord_id", + "type": "text", + "primaryKey": false, + "notNull": false + }, + "handle": { + "name": "handle", + "type": "text", + "primaryKey": false, + "notNull": false + }, + "auto_topup_enabled": { + "name": "auto_topup_enabled", + "type": "boolean", + "primaryKey": false, + "notNull": true, + "default": false + }, + "auto_topup_threshold": { + "name": "auto_topup_threshold", + "type": "integer", + "primaryKey": false, + "notNull": false + }, + "auto_topup_amount": { + "name": "auto_topup_amount", + "type": "integer", + "primaryKey": false, + "notNull": false + }, + "banned": { + "name": "banned", + "type": "boolean", + "primaryKey": false, + "notNull": true, + "default": false + }, + "fallback_to_a_la_carte": { + "name": "fallback_to_a_la_carte", + "type": "boolean", + "primaryKey": false, + "notNull": true, + "default": false + } + }, + "indexes": {}, + "foreignKeys": {}, + "compositePrimaryKeys": {}, + "uniqueConstraints": { + "user_email_unique": { + "name": "user_email_unique", + "nullsNotDistinct": false, + "columns": [ + "email" + ] + }, + "user_stripe_customer_id_unique": { + "name": "user_stripe_customer_id_unique", + "nullsNotDistinct": false, + "columns": [ + "stripe_customer_id" + ] + }, + "user_referral_code_unique": { + "name": "user_referral_code_unique", + "nullsNotDistinct": false, + "columns": [ + "referral_code" + ] + }, + "user_discord_id_unique": { + "name": "user_discord_id_unique", + "nullsNotDistinct": false, + "columns": [ + "discord_id" + ] + }, + "user_handle_unique": { + "name": "user_handle_unique", + "nullsNotDistinct": false, + "columns": [ + "handle" + ] + } + }, + "policies": {}, + "checkConstraints": {}, + "isRLSEnabled": false + }, + "public.verificationToken": { + "name": "verificationToken", + "schema": "", + "columns": { + "identifier": { + "name": "identifier", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "token": { + "name": "token", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "expires": { + "name": "expires", + "type": "timestamp", + "primaryKey": false, + "notNull": true + } + }, + "indexes": {}, + "foreignKeys": {}, + "compositePrimaryKeys": { + "verificationToken_identifier_token_pk": { + "name": "verificationToken_identifier_token_pk", + "columns": [ + "identifier", + "token" + ] + } + }, + "uniqueConstraints": {}, + "policies": {}, + "checkConstraints": {}, + "isRLSEnabled": false + } + }, + "enums": { + "public.referral_status": { + "name": "referral_status", + "schema": "public", + "values": [ + "pending", + "completed" + ] + }, + "public.agent_run_status": { + "name": "agent_run_status", + "schema": "public", + "values": [ + "running", + "completed", + "failed", + "cancelled" + ] + }, + "public.agent_step_status": { + "name": "agent_step_status", + "schema": "public", + "values": [ + "running", + "completed", + "skipped" + ] + }, + "public.api_key_type": { + "name": "api_key_type", + "schema": "public", + "values": [ + "anthropic", + "gemini", + "openai" + ] + }, + "public.free_session_status": { + "name": "free_session_status", + "schema": "public", + "values": [ + "queued", + "active" + ] + }, + "public.grant_type": { + "name": "grant_type", + "schema": "public", + "values": [ + "free", + "referral", + "referral_legacy", + "subscription", + "purchase", + "admin", + "organization", + "ad" + ] + }, + "public.org_role": { + "name": "org_role", + "schema": "public", + "values": [ + "owner", + "admin", + "member" + ] + }, + "public.session_type": { + "name": "session_type", + "schema": "public", + "values": [ + "web", + "pat", + "cli" + ] + }, + "public.subscription_status": { + "name": "subscription_status", + "schema": "public", + "values": [ + "incomplete", + "incomplete_expired", + "trialing", + "active", + "past_due", + "canceled", + "unpaid", + "paused" + ] + } + }, + "schemas": {}, + "sequences": {}, + "roles": {}, + "policies": {}, + "views": {}, + "_meta": { + "columns": {}, + "schemas": {}, + "tables": {} + } +} \ No newline at end of file diff --git a/packages/internal/src/db/migrations/meta/_journal.json b/packages/internal/src/db/migrations/meta/_journal.json index f67ef37dc..78747c831 100644 --- a/packages/internal/src/db/migrations/meta/_journal.json +++ b/packages/internal/src/db/migrations/meta/_journal.json @@ -323,6 +323,13 @@ "when": 1776813242936, "tag": "0045_mean_sleeper", "breakpoints": true + }, + { + "idx": 46, + "version": "7", + "when": 1776898844362, + "tag": "0046_cloudy_firedrake", + "breakpoints": true } ] } \ No newline at end of file diff --git a/packages/internal/src/db/schema.ts b/packages/internal/src/db/schema.ts index b6f170d29..2ead1fc6d 100644 --- a/packages/internal/src/db/schema.ts +++ b/packages/internal/src/db/schema.ts @@ -870,3 +870,37 @@ export const freeSession = pgTable( index('idx_free_session_expiry').on(table.expires_at), ], ) + +/** + * Audit log of every admission — one row per queued→active transition. Used + * to rate-limit heavy users (e.g. no more than 5 GLM sessions per 20h). + * + * Separate from `free_session` because that table is one-row-per-user (state, + * not history); the UPSERT path there would otherwise destroy prior admissions. + */ +export const freeSessionAdmit = pgTable( + 'free_session_admit', + { + id: text('id') + .primaryKey() + .$defaultFn(() => crypto.randomUUID()), + user_id: text('user_id') + .notNull() + .references(() => user.id, { onDelete: 'cascade' }), + model: text('model').notNull(), + admitted_at: timestamp('admitted_at', { + mode: 'date', + withTimezone: true, + }) + .notNull() + .defaultNow(), + }, + (table) => [ + // Rate-limit lookup: WHERE user_id=$1 AND model=$2 AND admitted_at > $cutoff + index('idx_free_session_admit_user_model_time').on( + table.user_id, + table.model, + table.admitted_at, + ), + ], +) diff --git a/web/src/app/api/v1/freebuff/session/__tests__/session.test.ts b/web/src/app/api/v1/freebuff/session/__tests__/session.test.ts index 657c17f6d..71d3d32c7 100644 --- a/web/src/app/api/v1/freebuff/session/__tests__/session.test.ts +++ b/web/src/app/api/v1/freebuff/session/__tests__/session.test.ts @@ -44,6 +44,9 @@ function makeSessionDeps(overrides: Partial = {}): SessionDeps & { getInstantAdmitCapacity: () => 0, activeCountForModel: async () => 0, promoteQueuedUser: async () => null, + // No admits in handler tests — the rate-limit check reads empty and + // every request falls through to the queue. + listRecentAdmits: async () => [], now: () => now, getSessionRow: async (userId) => rows.get(userId) ?? null, queueDepthsByModel: async () => { diff --git a/web/src/app/api/v1/freebuff/session/_handlers.ts b/web/src/app/api/v1/freebuff/session/_handlers.ts index ec17568a3..e238fec97 100644 --- a/web/src/app/api/v1/freebuff/session/_handlers.ts +++ b/web/src/app/api/v1/freebuff/session/_handlers.ts @@ -142,8 +142,16 @@ export async function postFreebuffSession( // response on the client. banned is a 403 (terminal, mirrors country_blocked) // so older CLIs that don't know the status fall into their `!resp.ok` error // path and back off instead of tight-polling on the unrecognized 200 body. + // rate_limited uses 429 so older CLIs fall into the error path (backing + // off on the 10s cadence) and newer CLIs parse the structured body below. const status = - state.status === 'model_locked' ? 409 : state.status === 'banned' ? 403 : 200 + state.status === 'model_locked' + ? 409 + : state.status === 'banned' + ? 403 + : state.status === 'rate_limited' + ? 429 + : 200 return NextResponse.json(state, { status }) } catch (error) { return serverError(deps, 'POST', auth.userId, error) diff --git a/web/src/server/free-session/__tests__/public-api.test.ts b/web/src/server/free-session/__tests__/public-api.test.ts index a824f6d22..f09a7d787 100644 --- a/web/src/server/free-session/__tests__/public-api.test.ts +++ b/web/src/server/free-session/__tests__/public-api.test.ts @@ -15,12 +15,20 @@ const SESSION_LEN = 60 * 60 * 1000 const GRACE_MS = 30 * 60 * 1000 const DEFAULT_MODEL = 'z-ai/glm-5.1' +interface AdmitRecord { + user_id: string + model: string + admitted_at: Date +} + function makeDeps(overrides: Partial = {}): SessionDeps & { rows: Map + admits: AdmitRecord[] _tick: (n: Date) => void _now: () => Date } { const rows = new Map() + const admits: AdmitRecord[] = [] let currentNow = new Date('2026-04-17T12:00:00Z') let instanceCounter = 0 @@ -28,10 +36,12 @@ function makeDeps(overrides: Partial = {}): SessionDeps & { const deps: SessionDeps & { rows: Map + admits: AdmitRecord[] _tick: (n: Date) => void _now: () => Date } = { rows, + admits, _tick: (n: Date) => { currentNow = n }, @@ -50,6 +60,18 @@ function makeDeps(overrides: Partial = {}): SessionDeps & { } return n }, + listRecentAdmits: async ({ userId, model, since, limit }) => { + return admits + .filter( + (a) => + a.user_id === userId && + a.model === model && + a.admitted_at.getTime() >= since.getTime(), + ) + .sort((a, b) => a.admitted_at.getTime() - b.admitted_at.getTime()) + .slice(0, limit) + .map((a) => a.admitted_at) + }, promoteQueuedUser: async ({ userId, model, sessionLengthMs, now }) => { const row = rows.get(userId) if (!row || row.status !== 'queued' || row.model !== model) return null @@ -57,6 +79,7 @@ function makeDeps(overrides: Partial = {}): SessionDeps & { row.admitted_at = now row.expires_at = new Date(now.getTime() + sessionLengthMs) row.updated_at = now + admits.push({ user_id: userId, model, admitted_at: now }) return row }, now: () => currentNow, @@ -283,6 +306,129 @@ describe('requestSession', () => { expect(s2.status).toBe('queued') expect(s3.status).toBe('active') }) + + // Per-user rate limit (5 GLM admissions per 20h) — the wire limit is + // hard-coded in public-api.ts, so tests seed the fake admit log directly + // rather than configuring it. + const GLM_LIMIT = 5 + const GLM_WINDOW_HOURS = 20 + + test('rate_limited: 5th GLM admit in window blocks the 6th attempt', async () => { + // Seed 5 admits inside the 20h window, spaced so we can verify retryAfter + // points at the oldest one sliding off. + const now = deps._now() + const windowMs = GLM_WINDOW_HOURS * 60 * 60 * 1000 + // Oldest: 19h ago (still in window). Next 4: 1h, 2h, 3h, 4h ago. + const ages = [19, 4, 3, 2, 1] + for (const hoursAgo of ages) { + deps.admits.push({ + user_id: 'u1', + model: DEFAULT_MODEL, + admitted_at: new Date(now.getTime() - hoursAgo * 60 * 60 * 1000), + }) + } + + const state = await requestSession({ + userId: 'u1', + model: DEFAULT_MODEL, + deps, + }) + expect(state.status).toBe('rate_limited') + if (state.status !== 'rate_limited') throw new Error('unreachable') + expect(state.model).toBe(DEFAULT_MODEL) + expect(state.limit).toBe(GLM_LIMIT) + expect(state.windowHours).toBe(GLM_WINDOW_HOURS) + expect(state.recentCount).toBe(GLM_LIMIT) + // Oldest admit is 19h ago; slot opens when it hits 20h, i.e. in 1h. + expect(state.retryAfterMs).toBe(60 * 60 * 1000) + // Blocked before any row is written — the user doesn't take a queue slot. + expect(deps.rows.has('u1')).toBe(false) + }) + + test('rate_limited: admits outside the 20h window do not count', async () => { + // 5 admits, each just over 20h old → all fall off the window. + const now = deps._now() + for (let i = 0; i < 5; i++) { + deps.admits.push({ + user_id: 'u1', + model: DEFAULT_MODEL, + admitted_at: new Date( + now.getTime() - (GLM_WINDOW_HOURS * 60 * 60 * 1000 + 60_000 + i), + ), + }) + } + const state = await requestSession({ + userId: 'u1', + model: DEFAULT_MODEL, + deps, + }) + expect(state.status).toBe('queued') + if (state.status !== 'queued') throw new Error('unreachable') + expect(state.rateLimit?.recentCount).toBe(0) + }) + + test('rate_limited: Minimax is unlimited even with many recent admits', async () => { + const minimax = 'minimax/minimax-m2.7' + const now = deps._now() + for (let i = 0; i < 20; i++) { + deps.admits.push({ + user_id: 'u1', + model: minimax, + admitted_at: new Date(now.getTime() - i * 60_000), + }) + } + const state = await requestSession({ userId: 'u1', model: minimax, deps }) + expect(state.status).toBe('queued') + if (state.status !== 'queued') throw new Error('unreachable') + // No rate-limit info for unrated models — the CLI skips the quota line. + expect(state.rateLimit).toBeUndefined() + }) + + test('queued GLM response carries the current admit count', async () => { + const now = deps._now() + // 2 admits in the window — under the limit so the user still queues. + deps.admits.push({ + user_id: 'u1', + model: DEFAULT_MODEL, + admitted_at: new Date(now.getTime() - 60 * 60 * 1000), + }) + deps.admits.push({ + user_id: 'u1', + model: DEFAULT_MODEL, + admitted_at: new Date(now.getTime() - 30 * 60 * 1000), + }) + const state = await requestSession({ + userId: 'u1', + model: DEFAULT_MODEL, + deps, + }) + if (state.status !== 'queued') throw new Error('unreachable') + expect(state.rateLimit).toEqual({ + model: DEFAULT_MODEL, + limit: GLM_LIMIT, + windowHours: GLM_WINDOW_HOURS, + recentCount: 2, + }) + }) + + test('instant-admit bumps the quota count for the freshly-written admit row', async () => { + const admitDeps = makeDeps({ getInstantAdmitCapacity: () => 3 }) + // 1 existing admit in the window; this new call should instant-admit and + // write a second row, so the response's recentCount reflects 2. + const now = admitDeps._now() + admitDeps.admits.push({ + user_id: 'u1', + model: DEFAULT_MODEL, + admitted_at: new Date(now.getTime() - 30 * 60 * 1000), + }) + const state = await requestSession({ + userId: 'u1', + model: DEFAULT_MODEL, + deps: admitDeps, + }) + if (state.status !== 'active') throw new Error('unreachable') + expect(state.rateLimit?.recentCount).toBe(2) + }) }) describe('getSessionState', () => { @@ -341,6 +487,36 @@ describe('getSessionState', () => { expect(state).toEqual({ status: 'superseded' }) }) + test('getSessionState surfaces rateLimit on queued/active polls', async () => { + // Regression: the POST response attached rateLimit, but GET polls did + // not — so the "Sessions N/M used" line flashed once then disappeared on + // the next 5s poll. GET must attach the same quota snapshot. + const now = deps._now() + deps.admits.push({ + user_id: 'u1', + model: DEFAULT_MODEL, + admitted_at: new Date(now.getTime() - 60 * 60 * 1000), + }) + await requestSession({ userId: 'u1', model: DEFAULT_MODEL, deps }) + const row = deps.rows.get('u1')! + row.status = 'active' + row.admitted_at = now + row.expires_at = new Date(now.getTime() + SESSION_LEN) + + const state = await getSessionState({ + userId: 'u1', + claimedInstanceId: row.active_instance_id, + deps, + }) + if (state.status !== 'active') throw new Error('unreachable') + expect(state.rateLimit).toEqual({ + model: DEFAULT_MODEL, + limit: 5, + windowHours: 20, + recentCount: 1, + }) + }) + test('omitted claimedInstanceId on active session returns active (read-only)', async () => { // Polling without an id (e.g. very first GET before POST has resolved) // must not be classified as superseded — only an explicit mismatch is. diff --git a/web/src/server/free-session/public-api.ts b/web/src/server/free-session/public-api.ts index 450540443..e37374a94 100644 --- a/web/src/server/free-session/public-api.ts +++ b/web/src/server/free-session/public-api.ts @@ -16,15 +16,65 @@ import { FreeSessionModelLockedError, getSessionRow, joinOrTakeOver, + listRecentAdmits, promoteQueuedUser, queueDepthsByModel, queuePositionFor, } from './store' import { toSessionStateResponse } from './session-view' -import type { FreebuffSessionServerResponse } from '@codebuff/common/types/freebuff-session' +import type { + FreebuffSessionRateLimit, + FreebuffSessionServerResponse, +} from '@codebuff/common/types/freebuff-session' import type { InternalSessionRow, SessionStateResponse } from './types' +/** + * Per-model admission rate limits. Keyed by freebuff model id; a model not + * in the map has no rate limit applied. Today only GLM 5.1 is limited + * (Minimax is cheap enough to leave unlimited). + * + * Hard-coded rather than env-driven: the values need to be observable in the + * code review, and the CLI already renders the numbers via `rateLimit` on + * queued/active responses — changing them is a deliberate, typed edit. + */ +const RATE_LIMITS: Record = { + 'z-ai/glm-5.1': { limit: 5, windowHours: 20 }, +} + +/** Fetch the caller's current quota snapshot for `model`, or undefined if the + * model isn't rate-limited. Used by both POST (after admit) and GET polls so + * the CLI's "N of M sessions used" line stays live instead of disappearing + * after the first poll. Also returns the oldest admit in-window so callers + * that need `retryAfterMs` don't have to re-query. */ +async function fetchRateLimitSnapshot( + userId: string, + model: string, + deps: SessionDeps, +): Promise< + { info: FreebuffSessionRateLimit; oldest: Date | null } | undefined +> { + const cfg = RATE_LIMITS[model] + if (!cfg) return undefined + const now = nowOf(deps) + const since = new Date(now.getTime() - cfg.windowHours * 60 * 60 * 1000) + const admits = await deps.listRecentAdmits({ + userId, + model, + since, + limit: cfg.limit, + }) + return { + info: { + model, + limit: cfg.limit, + windowHours: cfg.windowHours, + recentCount: admits.length, + }, + oldest: admits[0] ?? null, + } +} + export interface SessionDeps { getSessionRow: (userId: string) => Promise joinOrTakeOver: (params: { @@ -43,6 +93,15 @@ export interface SessionDeps { * bound to a given model. Compared against the model's configured * `instantAdmitCapacity` to decide whether a new joiner skips the queue. */ activeCountForModel: (model: string) => Promise + /** Rate-limit helper: oldest-first admission timestamps for (userId, model) + * inside the window. The caller uses `rows.length` as the count (capped + * at `limit`) and `rows[0]` as the oldest for `retryAfterMs`. */ + listRecentAdmits: (params: { + userId: string + model: string + since: Date + limit: number + }) => Promise /** Instant-admit promotion: flips a specific queued row to active. Returns * the updated row or null if the row wasn't in a queued state. */ promoteQueuedUser: (params: { @@ -71,6 +130,7 @@ const defaultDeps: SessionDeps = { queueDepthsByModel, queuePositionFor, activeCountForModel, + listRecentAdmits, promoteQueuedUser, getInstantAdmitCapacity, isWaitingRoomEnabled, @@ -122,6 +182,16 @@ export type RequestSessionResult = currentModel: string requestedModel: string } + | { + /** User has hit the per-model admission quota in the rolling window. + * See `FreebuffSessionServerResponse`'s `rate_limited` variant. */ + status: 'rate_limited' + model: string + limit: number + windowHours: number + recentCount: number + retryAfterMs: number + } /** * Client calls this on CLI startup with the model they want to use. @@ -162,6 +232,28 @@ export async function requestSession(params: { return { status: 'disabled' } } + // Rate-limit check runs before joinOrTakeOver so heavy users never even + // create a queued row. Only models listed in RATE_LIMITS are gated; others + // (Minimax today) fall through unchanged. + const snapshot = await fetchRateLimitSnapshot(params.userId, model, deps) + if (snapshot && snapshot.info.recentCount >= snapshot.info.limit) { + // Oldest admit's window-anniversary is when one slot opens back up. + // Clamped at 0 so a clock skew can't surface a negative retry-after. + const windowMs = snapshot.info.windowHours * 60 * 60 * 1000 + const retryAfterMs = Math.max( + 0, + (snapshot.oldest?.getTime() ?? 0) + windowMs - nowOf(deps).getTime(), + ) + return { + status: 'rate_limited', + model, + limit: snapshot.info.limit, + windowHours: snapshot.info.windowHours, + recentCount: snapshot.info.recentCount, + retryAfterMs, + } + } + let row: InternalSessionRow try { row = await deps.joinOrTakeOver({ @@ -212,7 +304,21 @@ export async function requestSession(params: { `joinOrTakeOver returned a row that maps to no view (user=${params.userId})`, ) } - return view + return attachRateLimit(params.userId, view, deps) +} + +/** Thread the current quota snapshot onto queued/active views so the CLI can + * render "N of M sessions used". Other statuses pass through unchanged. + * Called on both POST and GET so the line stays live across polls. */ +async function attachRateLimit( + userId: string, + view: SessionStateResponse, + deps: SessionDeps, +): Promise { + if (view.status !== 'queued' && view.status !== 'active') return view + const snapshot = await fetchRateLimitSnapshot(userId, view.model, deps) + if (!snapshot) return view + return { ...view, rateLimit: snapshot.info } } /** @@ -267,7 +373,7 @@ export async function getSessionState(params: { const view = await viewForRow(params.userId, deps, row) if (!view) return noneResponse() - return view + return attachRateLimit(params.userId, view, deps) } export async function endUserSession(params: { diff --git a/web/src/server/free-session/store.ts b/web/src/server/free-session/store.ts index b3bd2bc48..e84331b69 100644 --- a/web/src/server/free-session/store.ts +++ b/web/src/server/free-session/store.ts @@ -1,7 +1,7 @@ import { db } from '@codebuff/internal/db' import { coerceBool } from '@codebuff/internal/db/advisory-lock' import * as schema from '@codebuff/internal/db/schema' -import { and, asc, count, eq, lt, sql } from 'drizzle-orm' +import { and, asc, count, eq, gte, lt, sql } from 'drizzle-orm' import { FREEBUFF_ADMISSION_LOCK_ID } from './config' @@ -369,6 +369,16 @@ export async function admitFromQueue(params: { ) .returning() + if (admitted.length > 0) { + await tx.insert(schema.freeSessionAdmit).values( + admitted.map((r) => ({ + user_id: r.user_id, + model: r.model, + admitted_at: now, + })), + ) + } + return { admitted: admitted as InternalSessionRow[], skipped: null } }) } @@ -391,23 +401,63 @@ export async function promoteQueuedUser(params: { }): Promise { const { userId, model, sessionLengthMs, now } = params const expiresAt = new Date(now.getTime() + sessionLengthMs) - const [row] = await db - .update(schema.freeSession) - .set({ - status: 'active', + return db.transaction(async (tx) => { + const [row] = await tx + .update(schema.freeSession) + .set({ + status: 'active', + admitted_at: now, + expires_at: expiresAt, + updated_at: now, + }) + .where( + and( + eq(schema.freeSession.user_id, userId), + eq(schema.freeSession.status, 'queued'), + eq(schema.freeSession.model, model), + ), + ) + .returning() + if (!row) return null + await tx.insert(schema.freeSessionAdmit).values({ + user_id: userId, + model, admitted_at: now, - expires_at: expiresAt, - updated_at: now, }) + return row as InternalSessionRow + }) +} + +/** + * List admissions for `userId` on `model` whose `admitted_at` is within the + * window `[since, ∞)`, ordered oldest-first. Caller gets both the count + * (array length, capped at `limit`) and the oldest timestamp (`rows[0]`) — + * the oldest is needed to compute `retryAfterMs` when the window is full, + * so one query covers both the check and the reject path. + * + * Drives the per-user, per-model rate limit (e.g. at most 5 GLM sessions in + * the last 20h) enforced before `joinOrTakeOver`. + */ +export async function listRecentAdmits(params: { + userId: string + model: string + since: Date + limit: number +}): Promise { + const { userId, model, since, limit } = params + const rows = await db + .select({ admitted_at: schema.freeSessionAdmit.admitted_at }) + .from(schema.freeSessionAdmit) .where( and( - eq(schema.freeSession.user_id, userId), - eq(schema.freeSession.status, 'queued'), - eq(schema.freeSession.model, model), + eq(schema.freeSessionAdmit.user_id, userId), + eq(schema.freeSessionAdmit.model, model), + gte(schema.freeSessionAdmit.admitted_at, since), ), ) - .returning() - return (row as InternalSessionRow | undefined) ?? null + .orderBy(asc(schema.freeSessionAdmit.admitted_at)) + .limit(limit) + return rows.map((r) => r.admitted_at) } /** Stable 31-bit hash so model-keyed advisory lock ids don't overflow int4. */ From 27fb6333534a16dc1898f7b3c7f5e508720278db Mon Sep 17 00:00:00 2001 From: James Grugett Date: Fri, 24 Apr 2026 15:37:13 -0700 Subject: [PATCH 2/2] Allow GLM rate-limit reclaim for existing queued/active row MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit requestSession is the takeover path as well as the join path, so a user whose 5th GLM admit put them at the cap would get rate_limited on CLI restart and lose access to their still-active session (or their queue position). Skip the quota check when the caller already holds a queued or active+unexpired row for the same model — admit counts only need to gate fresh admissions, not re-anchoring to an existing row. Expired rows still count as fresh and remain blocked. Co-Authored-By: Claude Opus 4.7 --- .../free-session/__tests__/public-api.test.ts | 119 ++++++++++++++++++ web/src/server/free-session/public-api.ts | 50 +++++--- 2 files changed, 153 insertions(+), 16 deletions(-) diff --git a/web/src/server/free-session/__tests__/public-api.test.ts b/web/src/server/free-session/__tests__/public-api.test.ts index ffcee5c99..8b08d63df 100644 --- a/web/src/server/free-session/__tests__/public-api.test.ts +++ b/web/src/server/free-session/__tests__/public-api.test.ts @@ -436,6 +436,125 @@ describe('requestSession', () => { }) }) + test('rate_limited: takeover of an active GLM row is allowed even when at cap', async () => { + // Reclaim path: user has an active+unexpired GLM session and restarts + // the CLI. POST must rotate their instance id (takeover) and NOT reject + // with rate_limited — otherwise they'd be stranded with a live session + // they can't reconnect to. The 5th admission is already in the log, so + // this also exercises "at the cap" rather than "over the cap". + deps._tick(GLM_OPEN_TIME) + const now = deps._now() + // Seed 5 prior admits (the cap), with the latest one matching the + // active row we're about to install. + const ages = [19, 4, 3, 2, 0] + for (const hoursAgo of ages) { + deps.admits.push({ + user_id: 'u1', + model: GLM_MODEL, + admitted_at: new Date(now.getTime() - hoursAgo * 60 * 60 * 1000), + }) + } + // Install the active row directly (skipping the normal request path so + // we don't have to unwind the rate-limit gate to set up the fixture). + const admittedAt = new Date(now.getTime() - 30 * 60 * 1000) + deps.rows.set('u1', { + user_id: 'u1', + status: 'active', + active_instance_id: 'inst-pre', + model: GLM_MODEL, + queued_at: admittedAt, + admitted_at: admittedAt, + expires_at: new Date(admittedAt.getTime() + SESSION_LEN), + created_at: admittedAt, + updated_at: admittedAt, + }) + + const state = await requestSession({ + userId: 'u1', + model: GLM_MODEL, + deps, + }) + expect(state.status).toBe('active') + if (state.status !== 'active') throw new Error('unreachable') + // Instance id rotated; quota snapshot still reflects the full window. + expect(state.instanceId).not.toBe('inst-pre') + expect(state.rateLimit?.recentCount).toBe(GLM_LIMIT) + }) + + test('rate_limited: reclaim of a queued GLM row is allowed even when at cap', async () => { + // Same reclaim exception for queued rows: if a user has already queued + // (say they slipped in just before their 5th admit landed), a subsequent + // POST from the same CLI must preserve their queue position instead of + // flipping to rate_limited. + deps._tick(GLM_OPEN_TIME) + const now = deps._now() + for (let i = 0; i < GLM_LIMIT; i++) { + deps.admits.push({ + user_id: 'u1', + model: GLM_MODEL, + admitted_at: new Date(now.getTime() - (i + 1) * 60 * 60 * 1000), + }) + } + const queuedAt = new Date(now.getTime() - 5 * 60 * 1000) + deps.rows.set('u1', { + user_id: 'u1', + status: 'queued', + active_instance_id: 'inst-pre', + model: GLM_MODEL, + queued_at: queuedAt, + admitted_at: null, + expires_at: null, + created_at: queuedAt, + updated_at: queuedAt, + }) + + const state = await requestSession({ + userId: 'u1', + model: GLM_MODEL, + deps, + }) + expect(state.status).toBe('queued') + if (state.status !== 'queued') throw new Error('unreachable') + // Same position (1) since we preserved queued_at and nobody else is + // ahead; the instance id rotated so any prior CLI is superseded. + expect(state.instanceId).not.toBe('inst-pre') + expect(state.rateLimit?.recentCount).toBe(GLM_LIMIT) + }) + + test('rate_limited: expired GLM row is not a reclaim — quota still applies', async () => { + // The stored row's expires_at is in the past, so it doesn't represent + // an in-flight session. This POST is effectively a fresh request and + // must be blocked by the quota. + deps._tick(GLM_OPEN_TIME) + const now = deps._now() + const ages = [19, 4, 3, 2, 1] + for (const hoursAgo of ages) { + deps.admits.push({ + user_id: 'u1', + model: GLM_MODEL, + admitted_at: new Date(now.getTime() - hoursAgo * 60 * 60 * 1000), + }) + } + const admittedAt = new Date(now.getTime() - 2 * SESSION_LEN) + deps.rows.set('u1', { + user_id: 'u1', + status: 'active', + active_instance_id: 'inst-pre', + model: GLM_MODEL, + queued_at: admittedAt, + admitted_at: admittedAt, + expires_at: new Date(admittedAt.getTime() + SESSION_LEN), + created_at: admittedAt, + updated_at: admittedAt, + }) + const state = await requestSession({ + userId: 'u1', + model: GLM_MODEL, + deps, + }) + expect(state.status).toBe('rate_limited') + }) + test('instant-admit bumps the quota count for the freshly-written admit row', async () => { const admitDeps = makeDeps({ getInstantAdmitCapacity: () => 3 }) admitDeps._tick(GLM_OPEN_TIME) diff --git a/web/src/server/free-session/public-api.ts b/web/src/server/free-session/public-api.ts index a46bc222f..02c5c05c9 100644 --- a/web/src/server/free-session/public-api.ts +++ b/web/src/server/free-session/public-api.ts @@ -250,22 +250,40 @@ export async function requestSession(params: { // Rate-limit check runs before joinOrTakeOver so heavy users never even // create a queued row. Only models listed in RATE_LIMITS are gated; others // (Minimax today) fall through unchanged. - const snapshot = await fetchRateLimitSnapshot(params.userId, model, deps) - if (snapshot && snapshot.info.recentCount >= snapshot.info.limit) { - // Oldest admit's window-anniversary is when one slot opens back up. - // Clamped at 0 so a clock skew can't surface a negative retry-after. - const windowMs = snapshot.info.windowHours * 60 * 60 * 1000 - const retryAfterMs = Math.max( - 0, - (snapshot.oldest?.getTime() ?? 0) + windowMs - nowOf(deps).getTime(), - ) - return { - status: 'rate_limited', - model, - limit: snapshot.info.limit, - windowHours: snapshot.info.windowHours, - recentCount: snapshot.info.recentCount, - retryAfterMs, + // + // Takeover/reclaim exception: a user who already holds a queued or + // active+unexpired row on this same model is re-anchoring (CLI restart, + // same-account tab switch) rather than starting a new session. Admit + // counts are written at promotion time, so the quota only needs to gate + // fresh admissions — blocking a reclaim here would strand a user with an + // active 5th session unable to reconnect after a CLI restart. + const existing = await deps.getSessionRow(params.userId) + const isReclaim = + !!existing && + existing.model === model && + (existing.status === 'queued' || + (existing.status === 'active' && + !!existing.expires_at && + existing.expires_at.getTime() > now.getTime())) + + if (!isReclaim) { + const snapshot = await fetchRateLimitSnapshot(params.userId, model, deps) + if (snapshot && snapshot.info.recentCount >= snapshot.info.limit) { + // Oldest admit's window-anniversary is when one slot opens back up. + // Clamped at 0 so a clock skew can't surface a negative retry-after. + const windowMs = snapshot.info.windowHours * 60 * 60 * 1000 + const retryAfterMs = Math.max( + 0, + (snapshot.oldest?.getTime() ?? 0) + windowMs - now.getTime(), + ) + return { + status: 'rate_limited', + model, + limit: snapshot.info.limit, + windowHours: snapshot.info.windowHours, + recentCount: snapshot.info.recentCount, + retryAfterMs, + } } }