@cartanova/qgrid-cli 2.8.0 → 2.9.1

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

@@ -5,6 +5,7 @@ import {
   assertSupportedOneMillionSuffix,
   canonicalAnthropicModel,
   hasOneMillionSuffix,
+  isFableFamilyModel,
   needsCli1mSuffix,
   supports1MContext,
   usesAdaptiveThinking,
@@ -18,6 +19,7 @@ describe("canonicalAnthropicModel", () => {
   it("provider prefix 를 제거한다", () => {
     expect(canonicalAnthropicModel("anthropic/claude-opus-4-8")).toBe("claude-opus-4-8");
     expect(canonicalAnthropicModel("anthropic/claude-fable-5")).toBe("claude-fable-5");
+    expect(canonicalAnthropicModel("anthropic/claude-fable-5-1")).toBe("claude-fable-5-1");
   });
 
   it("[1m] suffix 를 base canonical 에서 제거한다", () => {
@@ -28,6 +30,7 @@ describe("canonicalAnthropicModel", () => {
 
 describe("Anthropic 1M context policy", () => {
   it("지원 모델은 실측 확인된 exact set 만 true", () => {
+    expect(supports1MContext("claude-fable-5-1")).toBe(true);
     expect(supports1MContext("claude-fable-5")).toBe(true);
     expect(supports1MContext("claude-opus-5")).toBe(true);
     expect(supports1MContext("claude-sonnet-5")).toBe(true);
@@ -42,6 +45,7 @@ describe("Anthropic 1M context policy", () => {
   });
 
   it("CLI suffix 필요 모델과 기본 1M 모델을 분리한다", () => {
+    expect(needsCli1mSuffix("claude-fable-5-1")).toBe(false);
     expect(needsCli1mSuffix("claude-fable-5")).toBe(false);
     expect(needsCli1mSuffix("claude-opus-5")).toBe(false);
     expect(needsCli1mSuffix("claude-sonnet-5")).toBe(false);
@@ -65,10 +69,18 @@ describe("Anthropic 1M context policy", () => {
     );
     expect(() => assertSupportedOneMillionSuffix("anthropic/claude-sonnet-4-6[1m]")).not.toThrow();
   });
+
+  it("native 1M 모델의 [1m] suffix 는 허용하되 CLI 에는 suffix 없이 전달한다", () => {
+    expect(() => assertSupportedOneMillionSuffix("anthropic/claude-fable-5-1[1m]")).not.toThrow();
+    expect(supports1MContext("anthropic/claude-fable-5-1[1m]")).toBe(true);
+    expect(needsCli1mSuffix("anthropic/claude-fable-5-1[1m]")).toBe(false);
+  });
 });
 
 describe("Anthropic thinking policy", () => {
-  it("Fable 5 와 Opus 5 는 adaptive thinking 을 보존한다", () => {
+  it("Fable 5/5.1 과 Opus 5 는 adaptive thinking 을 보존한다", () => {
+    expect(usesAdaptiveThinking("claude-fable-5-1")).toBe(true);
+    expect(usesAdaptiveThinking("anthropic/claude-fable-5-1")).toBe(true);
     expect(usesAdaptiveThinking("claude-fable-5")).toBe(true);
     expect(usesAdaptiveThinking("anthropic/claude-fable-5")).toBe(true);
     expect(usesAdaptiveThinking("claude-opus-5")).toBe(true);
@@ -77,3 +89,15 @@ describe("Anthropic thinking policy", () => {
     expect(usesAdaptiveThinking("claude-opus-4-8")).toBe(false);
   });
 });
+
+describe("Anthropic Fable family", () => {
+  it("Fable 5/5.1 만 Fable 계열로 판정하고 prefix/[1m] 은 무시한다", () => {
+    expect(isFableFamilyModel("claude-fable-5-1")).toBe(true);
+    expect(isFableFamilyModel("claude-fable-5")).toBe(true);
+    expect(isFableFamilyModel("anthropic/claude-fable-5-1[1m]")).toBe(true);
+
+    expect(isFableFamilyModel("claude-opus-5")).toBe(false);
+    expect(isFableFamilyModel("claude-sonnet-4-6")).toBe(false);
+    expect(isFableFamilyModel(undefined)).toBe(false);
+  });
+});

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

@@ -45,6 +45,7 @@ export function hasOneMillionSuffix(model?: string): boolean {
 // 1M 지원 여부는 Claude Code 내부의 광범위한 prefix 판정이 아니라 qgrid에서 확인한 exact set 으로
 // 고정한다. opus-4-7 은 실측 전까지 미포함. 새 모델 추가 시 공식 사양과 실제 CLI 동작을 확인한다.
 const ONE_MILLION_CONTEXT_MODELS = new Set([
+  "claude-fable-5-1",
   "claude-fable-5",
   "claude-opus-5",
   "claude-sonnet-5",
@@ -54,10 +55,16 @@ const ONE_MILLION_CONTEXT_MODELS = new Set([
 ]);
 
 const CLI_ONE_MILLION_SUFFIX_MODELS = new Set(["claude-sonnet-4-6", "claude-opus-4-6"]);
-// Fable 5 는 adaptive thinking 이 유일한 모드다. Opus 5 는 disabled 를 high 이하에서 지원하지만,
-// 공식 기본값·권장 동작인 adaptive thinking 을 유지한다. qgrid 기본 effort=low 가 비용/지연 제어를
-// 맡으며, 이 정책은 disabled+xhigh/max 400 오류와 disabled 시 tool/XML 출력 오염도 피한다.
-const ADAPTIVE_THINKING_MODELS = new Set(["claude-fable-5", "claude-opus-5"]);
+// Fable 5/5.1 은 adaptive thinking 이 유일한 모드다(CLI 카탈로그 `rejects_disabled_thinking`). Opus 5 는
+// disabled 를 high 이하에서 지원하지만, 공식 기본값·권장 동작인 adaptive thinking 을 유지한다. qgrid
+// 기본 effort=low 가 비용/지연 제어를 맡으며, 이 정책은 disabled+xhigh/max 400 오류와 disabled 시
+// tool/XML 출력 오염도 피한다.
+const ADAPTIVE_THINKING_MODELS = new Set(["claude-fable-5-1", "claude-fable-5", "claude-opus-5"]);
+
+// Fable 계열: 구독 플랜에서 usage credits 가 필요한 최상위 티어. 구독 usage API 의
+// `seven_day_overage_included` 버킷은 이 계열에만 적용되므로 quota threshold 판정이 참조한다.
+// Mythos 는 Project Glasswing 조직 전용이라 구독 토큰 경로에서 도달할 수 없어 포함하지 않는다.
+const FABLE_FAMILY_MODELS = new Set(["claude-fable-5-1", "claude-fable-5"]);
 
 // 불변 계약: suffix 가 필요한 모델은 반드시 1M 지원 모델의 부분집합이어야 한다. 역방향 불일치(suffix
 // 대상인데 지원 집합엔 없음)면 needsCli1mSuffix=true·supports1MContext=false 가 동시에 나서
@@ -68,6 +75,13 @@ for (const model of CLI_ONE_MILLION_SUFFIX_MODELS) {
     throw new Error(`[invariant] CLI 1M suffix model not in context set: ${model}`);
   }
 }
+// Fable 계열은 공식 사양상 1M 기본 컨텍스트 + adaptive thinking 필수다. 새 Fable 버전을 계열 Set
+// 에만 넣고 나머지를 빠뜨리는 실수를 같은 방식으로 모듈 로드 시점에 잡는다.
+for (const model of FABLE_FAMILY_MODELS) {
+  if (!ONE_MILLION_CONTEXT_MODELS.has(model) || !ADAPTIVE_THINKING_MODELS.has(model)) {
+    throw new Error(`[invariant] Fable family model missing from 1M/adaptive set: ${model}`);
+  }
+}
 
 export function supports1MContext(model?: string): boolean {
   return ONE_MILLION_CONTEXT_MODELS.has(canonicalAnthropicModel(model));
@@ -83,6 +97,11 @@ export function usesAdaptiveThinking(model?: string): boolean {
   return ADAPTIVE_THINKING_MODELS.has(canonicalAnthropicModel(model));
 }
 
+// 구독 usage 의 Fable 전용 7일 버킷을 quota 판정에 포함할지 결정한다.
+export function isFableFamilyModel(model?: string): boolean {
+  return FABLE_FAMILY_MODELS.has(canonicalAnthropicModel(model));
+}
+
 export function assertSupportedOneMillionSuffix(model?: string): void {
   if (!hasOneMillionSuffix(model)) return;
   const canonical = canonicalAnthropicModel(model);

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

@@ -34,7 +34,7 @@ describe("readAnthropicQuotaUsage", () => {
     });
   });
 
-  it("uses the separate Fable 5 limit only for Fable requests", async () => {
+  it("uses the separate Fable 7-day limit only for Fable family requests", async () => {
     const usage = {
       data: {
         five_hour: { utilization: 10, resets_at: null },
@@ -48,6 +48,12 @@ describe("readAnthropicQuotaUsage", () => {
       kind: "ok",
       utilizationPct: 100,
     });
+    await expect(
+      readAnthropicQuotaUsage("access-token", "claude-fable-5-1"),
+    ).resolves.toMatchObject({
+      kind: "ok",
+      utilizationPct: 100,
+    });
     await expect(
       readAnthropicQuotaUsage("access-token", "claude-sonnet-4-6"),
     ).resolves.toMatchObject({

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

@@ -2,6 +2,7 @@ import {
   fetchUsageWithMeta,
   invalidateAnthropicQuotaUsage,
 } from "../../../application/qgrid/oauth";
+import { isFableFamilyModel } from "./anthropic-constants";
 
 export { invalidateAnthropicQuotaUsage };
 
@@ -18,7 +19,8 @@ export async function readAnthropicQuotaUsage(
     if (data.error) return { kind: "lookup_failed", reason: data.error };
 
     const utilizations = [data.five_hour?.utilization];
-    if (model === "claude-fable-5") {
+    // Fable 계열(5, 5.1)은 5시간 창과 별개로 usage credits 기반 7일 버킷도 소진될 수 있다.
+    if (isFableFamilyModel(model)) {
       utilizations.push(data.seven_day_overage_included?.utilization);
     }
     const utilization = Math.max(

package/bundle/src/utils/providers/anthropic/claude-session.test.ts

@@ -134,7 +134,9 @@ describe("buildClaudeArgs (멀티턴/격리/structured)", () => {
     expect(oneMillionEnv(false)).toEqual({ CLAUDE_CODE_DISABLE_1M_CONTEXT: "1" });
   });
 
-  it("thinkingEnv: Fable 5/Opus 5 는 adaptive thinking 을 보존하고 나머지는 비활성화", () => {
+  it("thinkingEnv: Fable 5/5.1/Opus 5 는 adaptive thinking 을 보존하고 나머지는 비활성화", () => {
+    expect(thinkingEnv("claude-fable-5-1")).toEqual({});
+    expect(thinkingEnv("anthropic/claude-fable-5-1")).toEqual({});
     expect(thinkingEnv("claude-fable-5")).toEqual({});
     expect(thinkingEnv("anthropic/claude-fable-5")).toEqual({});
     expect(thinkingEnv("claude-opus-5")).toEqual({});
@@ -262,15 +264,17 @@ describe("buildClaudeArgs (멀티턴/격리/structured)", () => {
     expect(args[args.indexOf("--model") + 1]).toBe("claude-opus-5");
   });
 
-  it("Fable 5 는 항상 켜진 adaptive thinking 을 끄지 않고 effort 만 전달한다", () => {
-    const args = buildClaudeArgs({
-      model: "claude-fable-5",
-      sessionId: "u",
-      effort: "low",
-    });
-    expect(args[args.indexOf("--model") + 1]).toBe("claude-fable-5");
-    expect(args).not.toContain("--thinking");
-    expect(args[args.indexOf("--effort") + 1]).toBe("low");
+  it("Fable 5/5.1 은 항상 켜진 adaptive thinking 을 끄지 않고 effort 만 전달한다", () => {
+    for (const model of ["claude-fable-5", "claude-fable-5-1"]) {
+      const args = buildClaudeArgs({
+        model,
+        sessionId: "u",
+        effort: "low",
+      });
+      expect(args[args.indexOf("--model") + 1]).toBe(model);
+      expect(args).not.toContain("--thinking");
+      expect(args[args.indexOf("--effort") + 1]).toBe("low");
+    }
   });
 
   it("Opus 5 는 adaptive thinking 을 보존해 xhigh/max effort 조합도 거부되지 않게 한다", () => {

package/bundle/src/utils/providers/common/model-cost.test.ts

@@ -30,6 +30,8 @@ describe("calculateCostUsd", () => {
   );
 
   it.each([
+    // Fable 5.1 은 cache read 만 0.025x 특례($0.25), 나머지 배율은 표준과 같다.
+    ["claude-fable-5-1", 10, 50, 0.25, 20],
     ["claude-fable-5", 10, 50, 1, 20],
     ["claude-haiku-4-5", 1, 5, 0.1, 2],
     ["claude-sonnet-4", 3, 15, 0.3, 6],
@@ -43,6 +45,7 @@ describe("calculateCostUsd", () => {
     ["claude-opus-4-7", 5, 25, 0.5, 10],
     ["claude-opus-4-8", 5, 25, 0.5, 10],
     ["claude-opus-5", 5, 25, 0.5, 10],
+    ["claude-sonnet-5", 2, 10, 0.2, 4],
   ])(
     "%s official Anthropic rates for 5m/1h cache writes",
     (model, inputTokens, outputTokens, cachedInputTokens, cacheCreationInputTokens) => {
@@ -57,8 +60,8 @@ describe("calculateCostUsd", () => {
     },
   );
 
-  it("Claude Sonnet 5 introductory pricing switches to standard pricing on 2026-09-01", () => {
-    expect(getModelCosts("claude-sonnet-5", Date.UTC(2026, 7, 31))).toEqual({
+  it("Claude Sonnet 5 는 introductory $2/$10 이 정식 단가라 날짜 분기 없이 고정된다", () => {
+    expect(getModelCosts("claude-sonnet-5")).toEqual({
       inputTokens: 2,
       outputTokens: 10,
       cachedInputTokens: 0.2,
@@ -66,18 +69,11 @@ describe("calculateCostUsd", () => {
       cacheCreationInputTokens5m: 2.5,
       cacheCreationInputTokens1h: 4,
     });
-    expect(getModelCosts("claude-sonnet-5", Date.UTC(2026, 8, 1))).toEqual({
-      inputTokens: 3,
-      outputTokens: 15,
-      cachedInputTokens: 0.3,
-      cacheCreationInputTokens: 6,
-      cacheCreationInputTokens5m: 3.75,
-      cacheCreationInputTokens1h: 6,
-    });
   });
 
   it("provider prefix 와 [1m] suffix 를 제거한 canonical model 로 가격을 찾는다", () => {
     expect(getModelCosts("anthropic/claude-fable-5")).toBe(getModelCosts("claude-fable-5"));
+    expect(getModelCosts("anthropic/claude-fable-5-1[1m]")).toBe(getModelCosts("claude-fable-5-1"));
     expect(getModelCosts("anthropic/claude-sonnet-4-6[1m]")).toBe(
       getModelCosts("claude-sonnet-4-6"),
     );
@@ -184,6 +180,17 @@ describe("calculateCostUsd", () => {
     ).toBeCloseTo(5.8, 10);
   });
 
+  it("Fable 5.1 은 cache read 만 $0.25 로 계산하고 나머지 단가는 Fable 5 와 같다", () => {
+    const usage = {
+      inputTokens: 100_000,
+      outputTokens: 100_000,
+      cachedInputTokens: 50_000,
+      cacheCreationInputTokens: 25_000,
+    };
+    // Fable 5: 5.8. cache read 50K 가 $1 → $0.25 로 바뀌면 0.05 → 0.0125 만큼 줄어든다.
+    expect(calculateCostUsd("claude-fable-5-1", usage)).toBeCloseTo(5.7625, 10);
+  });
+
   it("Fable 의 5분/1시간 cache write 단가도 구분한다", () => {
     expect(
       calculateCostUsd("claude-fable-5", {
@@ -197,21 +204,14 @@ describe("calculateCostUsd", () => {
     ).toBeCloseTo(5.725, 10);
   });
 
-  it("Sonnet 5 introductory/standard 단가 전환을 cost 계산에도 적용한다", () => {
+  it("Sonnet 5 는 $2/$10 단가로 cost 를 계산한다", () => {
     const usage = {
       inputTokens: 100_000,
       outputTokens: 100_000,
       cachedInputTokens: 50_000,
       cacheCreationInputTokens: 25_000,
     };
-    expect(calculateCostUsd("claude-sonnet-5", usage, Date.UTC(2026, 7, 31))).toBeCloseTo(
-      1.16,
-      10,
-    );
-    expect(calculateCostUsd("claude-sonnet-5", usage, Date.UTC(2026, 8, 1))).toBeCloseTo(
-      1.74,
-      10,
-    );
+    expect(calculateCostUsd("claude-sonnet-5", usage)).toBeCloseTo(1.16, 10);
   });
 
   it("legacy/원시 Anthropic usage 처럼 cache 가 input 보다 커도 음수 비용을 만들지 않는다", () => {

package/bundle/src/utils/providers/common/model-cost.ts

@@ -79,6 +79,9 @@ const OPENAI_COSTS: Record<string, ModelCosts> = {
     cachedInputTokens: 0.5,
     longContext: LONG_CONTEXT_272K,
   },
+  // 아래 gpt-5.4 / gpt-5.4-mini / gpt-5.3-codex / gpt-5.2 는 qgrid 가 쓰는 ChatGPT 구독 Codex 경로에서
+  // 더 이상 제공되지 않는다(5.4 계열은 2026-08-31 retired, 대체 gpt-5.6-terra / gpt-5.6-luna).
+  // 과거 request log 재산정(cost_source 없는 legacy 행)에 필요하므로 단가 행은 유지한다.
   // https://openai.com/index/introducing-gpt-5-4/ (2026-03 출시)
   "gpt-5.4": {
     inputTokens: 2.5,
@@ -95,11 +98,16 @@ const OPENAI_COSTS: Record<string, ModelCosts> = {
 
 // ── Anthropic ───────────────────────────────────────────────────────
 
-function anthropicCosts(inputTokens: number, outputTokens: number): ModelCosts {
+function anthropicCosts(
+  inputTokens: number,
+  outputTokens: number,
+  overrides: Pick<Partial<ModelCosts>, "cachedInputTokens"> = {},
+): ModelCosts {
   return {
     inputTokens,
     outputTokens,
-    cachedInputTokens: inputTokens / 10,
+    // 표준 cache read 는 base input 의 0.1x. Fable 5.1 처럼 공식 특례 단가가 있으면 override 한다.
+    cachedInputTokens: overrides.cachedInputTokens ?? inputTokens / 10,
     // Claude Code subscription OAuth 는 1h TTL 을 자동 선택한다. 구버전처럼 응답에
     // TTL breakdown 이 없을 때만 이 1h 단가를 fallback 으로 사용한다.
     cacheCreationInputTokens: inputTokens * 2,
@@ -108,7 +116,11 @@ function anthropicCosts(inputTokens: number, outputTokens: number): ModelCosts {
   };
 }
 
+// 가격 출처: https://platform.claude.com/docs/en/about-claude/pricing (2026-09-02 확인)
 const ANTHROPIC_COSTS: Record<string, ModelCosts> = {
+  // Fable 5.1 (2026-09-01 출시): input/output 은 Fable 5 와 같고 cache read 만 0.025x($0.25) 특례.
+  // @see https://platform.claude.com/docs/en/models/fable-5-1/overview
+  "claude-fable-5-1": anthropicCosts(10, 50, { cachedInputTokens: 0.25 }),
   "claude-fable-5": anthropicCosts(10, 50),
   sonnet: anthropicCosts(3, 15),
   "claude-3-5-haiku": anthropicCosts(0.8, 4),
@@ -126,26 +138,18 @@ const ANTHROPIC_COSTS: Record<string, ModelCosts> = {
   "claude-opus-4-7": anthropicCosts(5, 25),
   "claude-opus-4-8": anthropicCosts(5, 25),
   "claude-opus-5": anthropicCosts(5, 25),
+  // Sonnet 5 의 introductory $2/$10 이 정식 단가로 확정됐다. 2026-09-01 에 예정됐던 $3/$15 인상은
+  // 취소됐으므로 날짜 분기 없이 고정 단가로 계산한다.
+  "claude-sonnet-5": anthropicCosts(2, 10),
 };
 
-// Anthropic 공식 introductory pricing: 2026-08-31까지 $2/$10, 이후 $3/$15.
-// qgrid 는 요청 시점에 계산하므로 배포를 다시 하지 않아도 2026-09-01 UTC부터 표준 단가로 전환한다.
-const CLAUDE_SONNET_5_INTRO_PRICING_END_MS = Date.UTC(2026, 8, 1);
-const CLAUDE_SONNET_5_INTRO_COSTS = anthropicCosts(2, 10);
-const CLAUDE_SONNET_5_STANDARD_COSTS = anthropicCosts(3, 15);
-
 // gpt-5.3-codex-spark 는 research preview 로 공식 token 단가가 아직 final 이 아니다.
 // 지원 타입은 유지하되, 공식 단가가 공개될 때까지 아래 generic estimate 로 계산한다.
 // @see https://help.openai.com/en/articles/20001106-codex-rate-card
 const DEFAULT_COSTS: ModelCosts = { inputTokens: 3, outputTokens: 15, cachedInputTokens: 0.3 };
 
-export function getModelCosts(model: string, atMs = Date.now()): ModelCosts {
+export function getModelCosts(model: string): ModelCosts {
   const normalizedModel = (model.split("/").pop() ?? model).replace(/\[1m\]$/i, "");
-  if (normalizedModel === "claude-sonnet-5") {
-    return atMs < CLAUDE_SONNET_5_INTRO_PRICING_END_MS
-      ? CLAUDE_SONNET_5_INTRO_COSTS
-      : CLAUDE_SONNET_5_STANDARD_COSTS;
-  }
   return OPENAI_COSTS[normalizedModel] ?? ANTHROPIC_COSTS[normalizedModel] ?? DEFAULT_COSTS;
 }
 
@@ -159,9 +163,8 @@ export function calculateCostUsd(
     cacheCreationInputTokens5m?: number;
     cacheCreationInputTokens1h?: number;
   },
-  atMs = Date.now(),
 ): number {
-  const costs = getModelCosts(model, atMs);
+  const costs = getModelCosts(model);
   const cachedInput = usage.cachedInputTokens ?? 0;
   const cacheCreationInput5m = Math.max(usage.cacheCreationInputTokens5m ?? 0, 0);
   const cacheCreationInput1h = Math.max(usage.cacheCreationInputTokens1h ?? 0, 0);

package/bundle/src/utils/providers/openai/openai-refresh.test.ts

@@ -1,10 +1,14 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 
-const { findOneMock, saveMock, deactivateMock } = vi.hoisted(() => ({
-  findOneMock: vi.fn(),
-  saveMock: vi.fn(),
-  deactivateMock: vi.fn(),
-}));
+const { findOneMock, saveMock, deactivateMock } = vi.hoisted(() => {
+  // isolate:false 공유 레지스트리에 실제 TokenModel 이 먼저 올라와도 이 파일의 mock을 보장한다.
+  vi.resetModules();
+  return {
+    findOneMock: vi.fn(),
+    saveMock: vi.fn(),
+    deactivateMock: vi.fn(),
+  };
+});
 
 vi.mock("../../../application/token/token.model", () => ({
   TokenModel: { findOne: findOneMock, save: saveMock },
@@ -80,6 +84,7 @@ describe("OpenAI refresh", () => {
     expect(saveMock).toHaveBeenCalledWith([
       expect.objectContaining({
         id: 10,
+        reauth_required: false,
         credentials: expect.objectContaining({
           accessToken: "new-access",
           refreshToken: "new-refresh",
@@ -112,8 +117,12 @@ describe("OpenAI refresh", () => {
 
     await expect(handleChatgptAuthTokensRefresh(11)).rejects.toThrow("OpenAI refresh failed: 401");
     expect(deactivateMock).toHaveBeenCalledWith(
-      { id: 11, name: "token-11", provider: "openai" },
-      "old-refresh",
+      {
+        id: 11,
+        name: "token-11",
+        provider: "openai",
+        credentials: expect.objectContaining({ refreshToken: "old-refresh" }),
+      },
       "openai:refresh_token_reused",
     );
   });

package/bundle/src/utils/providers/openai/openai-refresh.ts

@@ -114,8 +114,7 @@ async function doRefresh(tokenId: number): Promise<RefreshResult> {
     // 상태코드를 바꿀 때 판정이 조용히 멎는다.
     if (errorCode && PERMANENT_FAILURE_CODES.has(errorCode)) {
       await deactivateAuthDeadToken(
-        { id: tokenId, name: token.name, provider: "openai" },
-        creds.refreshToken,
+        { id: tokenId, name: token.name, provider: "openai", credentials: creds },
         `openai:${errorCode}`,
       );
     }
@@ -158,6 +157,7 @@ async function doRefresh(tokenId: number): Promise<RefreshResult> {
         provider: "openai",
         credentials: updatedCreds,
         name: token.name,
+        reauth_required: false,
       },
     ]);
   } catch (e) {