@cartanova/qgrid-cli 2.7.9 → 2.8.0

package/bundle/src/utils/providers/anthropic/anthropic-dispatcher.ts

@@ -26,7 +26,11 @@ import {
 import { serializeAndValidateDispatchSchema } from "../common/schema-validation";
 import { SmoothWeightedRoundRobin } from "../common/smooth-weighted-round-robin";
 import { assertSupportedOneMillionSuffix, canonicalAnthropicModel } from "./anthropic-constants";
-import { readAnthropicQuotaUsage, type AnthropicQuotaUsageResult } from "./anthropic-quota";
+import {
+  invalidateAnthropicQuotaUsage,
+  readAnthropicQuotaUsage,
+  type AnthropicQuotaUsageResult,
+} from "./anthropic-quota";
 import { makeAnthropicWorkerId, runClaudeSession } from "./claude-session";
 
 const logger = getLogger(["qgrid", "anthropic-dispatcher"]);
@@ -163,7 +167,7 @@ export class AnthropicDispatcher implements ProviderDispatcher {
 
   // 지정 요청은 해당 토큰만 quota 판정하고 weighted 상태를 건드리지 않는다.
   // 미지정 요청만 quota 통과 후보로 smooth weighted round-robin 을 진행한다.
-  private async selectToken(preferredTokenId?: number): Promise<PooledToken | null> {
+  private async selectToken(model: string, preferredTokenId?: number): Promise<PooledToken | null> {
     const preferred =
       preferredTokenId === undefined ? undefined : this.tokenPool.get(preferredTokenId);
     if (preferredTokenId !== undefined && !preferred) {
@@ -172,7 +176,7 @@ export class AnthropicDispatcher implements ProviderDispatcher {
 
     const rows = preferred ? [preferred] : [...this.tokenPool.values()];
     if (rows.length === 0) return null;
-    const { eligible, overThresholdTokens } = await this.filterEligibleTokens(rows);
+    const { eligible, overThresholdTokens } = await this.filterEligibleTokens(rows, model);
     if (eligible.length === 0) {
       logger.warn("quota_threshold gate: all_exceeded", {
         provider: "anthropic",
@@ -193,7 +197,10 @@ export class AnthropicDispatcher implements ProviderDispatcher {
     return this.tokenPool.get(selectedId) ?? null;
   }
 
-  private async filterEligibleTokens(rows: PooledToken[]): Promise<{
+  private async filterEligibleTokens(
+    rows: PooledToken[],
+    model: string,
+  ): Promise<{
     eligible: PooledToken[];
     overThresholdTokens: Array<{ tokenName: string; threshold: number }>;
   }> {
@@ -207,7 +214,7 @@ export class AnthropicDispatcher implements ProviderDispatcher {
     const checks = await Promise.allSettled(
       thresholded.map(async (token) => ({
         token,
-        result: await readAnthropicQuotaUsage(token.credentials.accessToken),
+        result: await readAnthropicQuotaUsage(token.credentials.accessToken, model),
       })),
     );
 
@@ -314,7 +321,7 @@ export class AnthropicDispatcher implements ProviderDispatcher {
     const model = canonicalAnthropicModel(req.model);
     const jsonSchema = serializeAndValidateDispatchSchema(req.outputSchema, "anthropic");
 
-    const token = await this.selectToken(req.preferredTokenId);
+    const token = await this.selectToken(model, req.preferredTokenId);
     if (!token) throw new Error("No anthropic tokens available");
 
     const exec = async (): Promise<GenerateResult> => {
@@ -359,7 +366,13 @@ export class AnthropicDispatcher implements ProviderDispatcher {
         onDelta,
       );
 
-      if (session.quotaExhausted) throw new Error(`quota exhausted (${token.name})`);
+      if (session.quotaExhausted) {
+        invalidateAnthropicQuotaUsage(token.credentials.accessToken);
+        if (accessToken !== token.credentials.accessToken) {
+          invalidateAnthropicQuotaUsage(accessToken);
+        }
+        throw new Error(`quota exhausted (${token.name})`);
+      }
       if (session.isError) {
         // 진단(SON-495): isError 판정 사유(subtype/terminal_reason)를 메시지 앞에 드러낸다.
         // 그동안 detail 이 session.text(완전한 JSON 본문)뿐이라 "schema 위반인지 / max retries 인지 /

package/bundle/src/utils/providers/anthropic/anthropic-quota.test.ts

@@ -34,6 +34,28 @@ describe("readAnthropicQuotaUsage", () => {
     });
   });
 
+  it("uses the separate Fable 5 limit only for Fable requests", async () => {
+    const usage = {
+      data: {
+        five_hour: { utilization: 10, resets_at: null },
+        seven_day_overage_included: { utilization: 100, resets_at: null },
+      },
+      cachedAt: Date.now(),
+    };
+    fetchUsageWithMetaMock.mockResolvedValue(usage);
+
+    await expect(readAnthropicQuotaUsage("access-token", "claude-fable-5")).resolves.toMatchObject({
+      kind: "ok",
+      utilizationPct: 100,
+    });
+    await expect(
+      readAnthropicQuotaUsage("access-token", "claude-sonnet-4-6"),
+    ).resolves.toMatchObject({
+      kind: "ok",
+      utilizationPct: 10,
+    });
+  });
+
   it("keeps low percent utilization unchanged", async () => {
     fetchUsageWithMetaMock.mockResolvedValueOnce({
       data: { five_hour: { utilization: 1, resets_at: null } },

package/bundle/src/utils/providers/anthropic/anthropic-quota.ts

@@ -1,4 +1,9 @@
-import { fetchUsageWithMeta } from "../../../application/qgrid/oauth";
+import {
+  fetchUsageWithMeta,
+  invalidateAnthropicQuotaUsage,
+} from "../../../application/qgrid/oauth";
+
+export { invalidateAnthropicQuotaUsage };
 
 export type AnthropicQuotaUsageResult =
   | { kind: "ok"; utilizationPct: number; cacheAgeMs: number }
@@ -6,12 +11,21 @@ export type AnthropicQuotaUsageResult =
 
 export async function readAnthropicQuotaUsage(
   accessToken: string,
+  model?: string,
 ): Promise<AnthropicQuotaUsageResult> {
   try {
     const { data, cachedAt } = await fetchUsageWithMeta(accessToken);
     if (data.error) return { kind: "lookup_failed", reason: data.error };
 
-    const utilization = data.five_hour?.utilization;
+    const utilizations = [data.five_hour?.utilization];
+    if (model === "claude-fable-5") {
+      utilizations.push(data.seven_day_overage_included?.utilization);
+    }
+    const utilization = Math.max(
+      ...utilizations.filter(
+        (value): value is number => typeof value === "number" && Number.isFinite(value),
+      ),
+    );
     if (typeof utilization !== "number" || !Number.isFinite(utilization)) {
       return { kind: "lookup_failed", reason: "five_hour utilization unavailable" };
     }