@cartanova/qgrid-cli 2.9.2 → 2.9.4

package/bundle/src/application/token/token.model.ts

@@ -267,14 +267,13 @@ class TokenModelClass extends BaseModelClass<
   }
 
   /**
-   * 인증 사망을 한 번만 기록하고, 다른 활성 토큰이 있으면 라우팅에서도 제외한다.
-   * 마지막 활성 토큰은 systemic 장애 안전판 때문에 active 상태를 유지하되 재로그인
-   * 필요 상태는 기록한다. `marked`가 공유 DB 인스턴스들의 알림 발송 게이트다.
+   * Record confirmed expiry and remove the token from routing atomically.
+   * The last active token is also deactivated; its notification is urgent.
    */
   async markReauthRequired(
     id: number,
     expectedCredentials: TokenCredentials,
-  ): Promise<{ marked: boolean; keptAsLastActive: boolean; staleCredentials: boolean }> {
+  ): Promise<{ marked: boolean; wasLastActive: boolean; staleCredentials: boolean }> {
     const wdb = this.getPuri("w");
     return wdb.transaction(async (trx) => {
       const token = await trx
@@ -288,42 +287,50 @@ class TokenModelClass extends BaseModelClass<
         .forUpdate()
         .first();
       if (!token || token.reauth_required) {
-        return { marked: false, keptAsLastActive: false, staleCredentials: false };
+        return { marked: false, wasLastActive: false, staleCredentials: false };
       }
       if (!isDeepStrictEqual(token.credentials, expectedCredentials)) {
-        return { marked: false, keptAsLastActive: false, staleCredentials: true };
+        return { marked: false, wasLastActive: false, staleCredentials: true };
       }
 
       await trx.knex.raw("SELECT pg_advisory_xact_lock(?, hashtext(?))", [
         TOKEN_AUTH_DEATH_LOCK_CLASS_ID,
         token.provider,
       ]);
-      const updated = await trx.knex.raw<{ rows: { active: boolean }[] }>(
-        `UPDATE tokens
+      const updated = await trx.knex.raw<{ rows: { was_last_active: boolean }[] }>(
+        `WITH previous AS (
+           SELECT active AND NOT EXISTS (
+             SELECT 1 FROM tokens peer
+             WHERE peer.provider = tokens.provider AND peer.active
+               AND NOT peer.reauth_required AND peer.id <> tokens.id
+           ) AS was_last_active FROM tokens WHERE id = ?
+         )
+         UPDATE tokens
          SET reauth_required = true,
-             active = CASE
-               WHEN active AND (SELECT count(*) FROM tokens peer
-                 WHERE peer.provider = tokens.provider AND peer.active) > 1
-               THEN false
-               ELSE active
-             END
+             active = false
          WHERE id = ? AND reauth_required = false
-         RETURNING active`,
-        [id],
+         RETURNING (SELECT was_last_active FROM previous) AS was_last_active`,
+        [id, id],
       );
       const marked = updated.rows[0];
-      if (!marked) return { marked: false, keptAsLastActive: false, staleCredentials: false };
+      if (!marked) return { marked: false, wasLastActive: false, staleCredentials: false };
 
-      if (marked.active) {
-        logger.error(
-          `refusing to auto-deactivate token ${id}: last active provider token — ` +
-            `systemic refresh failure suspected, keeping the pool non-empty`,
-        );
+      if (marked.was_last_active) {
+        logger.error(`deactivated expired token ${id}: no usable provider tokens remain`);
       }
-      return { marked: true, keptAsLastActive: marked.active, staleCredentials: false };
+      return { marked: true, wasLastActive: marked.was_last_active, staleCredentials: false };
     });
   }
 
+  /** Repair rows retained by the former last-active exception before pool reconciliation. */
+  async deactivateExpiredTokens(): Promise<void> {
+    await this.getPuri("w")
+      .table("tokens")
+      .where("reauth_required", true)
+      .where("active", true)
+      .update({ active: false });
+  }
+
   @api({ httpMethod: "POST", clients: ["axios", "tanstack-mutation"] })
   async reorder(ids: number[]): Promise<{ done: boolean }> {
     const wdb = this.getPuri("w");

package/bundle/src/utils/providers/common/effort.test.ts

@@ -8,6 +8,14 @@ import {
 } from "./effort";
 
 describe("resolveOpenAIEffort", () => {
+  it("preserves every Astra Codex catalog effort including ultra", () => {
+    for (const effort of OPENAI_EFFORTS) {
+      expect(resolveOpenAIEffort("gpt-6-astra", effort)).toBe(effort);
+    }
+    expect(resolveOpenAIEffort("gpt-6-astra", "none")).toBeUndefined();
+    expect(resolveOpenAIEffort("gpt-6-astra", "minimal")).toBeUndefined();
+  });
+
   it("Codex 카탈로그 어휘는 그대로 통과한다", () => {
     for (const effort of ["low", "medium", "high", "xhigh"]) {
       expect(resolveOpenAIEffort("gpt-5.5", effort)).toBe(effort);

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

@@ -4,9 +4,18 @@ import { calculateCostUsd, getModelCosts } from "./model-cost";
 
 describe("calculateCostUsd", () => {
   it.each([
-    ["gpt-5.6-sol", 5, 30, 0.5, 6.25],
-    ["gpt-5.6-terra", 2.5, 15, 0.25, 3.125],
-    ["gpt-5.6-luna", 1, 6, 0.1, 1.25],
+    [272_000, 2.77],
+    [272_001, 5.51502],
+  ])("Astra applies the long-context rate only above 272K (%i input)", (inputTokens, expected) => {
+    expect(
+      calculateCostUsd("openai/gpt-6-astra", { inputTokens, outputTokens: 1_000 }),
+    ).toBeCloseTo(expected, 10);
+  });
+  it.each([
+    ["gpt-6-astra", 10, 50, 1, 12.5],
+    ["gpt-5.6-sol", 4, 20, 0.4, 5],
+    ["gpt-5.6-terra", 2, 12, 0.2, 2.5],
+    ["gpt-5.6-luna", 0.2, 1.2, 0.02, 0.25],
     ["gpt-5.5", 5, 30, 0.5, undefined],
     ["gpt-5.4", 2.5, 15, 0.25, undefined],
     ["gpt-5.4-mini", 0.75, 4.5, 0.075, undefined],
@@ -77,13 +86,15 @@ describe("calculateCostUsd", () => {
     expect(getModelCosts("anthropic/claude-sonnet-4-6[1m]")).toBe(
       getModelCosts("claude-sonnet-4-6"),
     );
+    expect(getModelCosts("openai/gpt-6-astra")).toBe(getModelCosts("gpt-6-astra"));
     expect(getModelCosts("openai/gpt-5.6-sol")).toBe(getModelCosts("gpt-5.6-sol"));
   });
 
   it.each([
-    ["gpt-5.6-sol", 5, 30, 0.5, 6.25, 3.30625],
-    ["gpt-5.6-terra", 2.5, 15, 0.25, 3.125, 1.653125],
-    ["gpt-5.6-luna", 1, 6, 0.1, 1.25, 0.66125],
+    ["gpt-6-astra", 10, 50, 1, 12.5, 5.6125],
+    ["gpt-5.6-sol", 4, 20, 0.4, 5, 2.245],
+    ["gpt-5.6-terra", 2, 12, 0.2, 2.5, 1.3225],
+    ["gpt-5.6-luna", 0.2, 1.2, 0.02, 0.25, 0.13225],
   ])(
     "%s applies published input, output, cache-read, and cache-write pricing",
     (model, inputTokens, outputTokens, cachedInputTokens, cacheCreationInputTokens, expectedCost) => {
@@ -106,9 +117,10 @@ describe("calculateCostUsd", () => {
   );
 
   it.each([
-    ["gpt-5.6-sol", 1.245],
-    ["gpt-5.6-terra", 0.6225],
-    ["gpt-5.6-luna", 0.249],
+    ["gpt-6-astra", 2.475],
+    ["gpt-5.6-sol", 0.99],
+    ["gpt-5.6-terra", 0.498],
+    ["gpt-5.6-luna", 0.0498],
   ])("%s applies the published long-context surcharge", (model, expectedCost) => {
     expect(
       calculateCostUsd(model, {
@@ -120,9 +132,10 @@ describe("calculateCostUsd", () => {
   });
 
   it.each([
-    ["gpt-5.6-sol", 1.37],
-    ["gpt-5.6-terra", 0.685],
-    ["gpt-5.6-luna", 0.274],
+    ["gpt-6-astra", 2.725],
+    ["gpt-5.6-sol", 1.09],
+    ["gpt-5.6-terra", 0.548],
+    ["gpt-5.6-luna", 0.0548],
   ])("%s applies the long-context input multiplier to cache writes", (model, expectedCost) => {
     expect(
       calculateCostUsd(model, {

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

@@ -34,7 +34,7 @@ export interface ModelCosts {
 
 // ── OpenAI ─────────────────────────────────────────────────────────
 //
-// 가격 출처: https://developers.openai.com/api/docs/models (2026-07-18 확인)
+// Standard pricing verified 2026-09-07: https://developers.openai.com/api/docs/pricing
 // 신모델 출시마다 단가가 바뀌므로(5.2→5.4→5.5) 모델 추가 시 반드시 공식 페이지 재확인해야함
 
 // GPT-5.4에서 처음 도입된 long-context 할증 (5.2/5.3-codex는 해당 없음, 5.4-mini/nano는 공식 표에서 long-context 단가 없음)
@@ -48,38 +48,52 @@ const LONG_CONTEXT_272K: NonNullable<ModelCosts["longContext"]> = {
 };
 
 // OpenAI 모델 카탈로그. 단가와 함께 Codex 백엔드가 모델별로 받는 최대 reasoning effort 를 한 곳에 둔다.
-// maxEffort 출처: ~/.codex/models_cache.json 의 supported_reasoning_levels (2026-09-02 확인).
+// maxEffort 출처: ~/.codex/models_cache.json 의 supported_reasoning_levels (2026-09-07 확인).
 // 미기재 모델은 xhigh 까지만 받는다.
 type OpenAIModelSpec = ModelCosts & { maxEffort?: OpenAIEffort };
 
 const OPENAI_COSTS: Record<string, OpenAIModelSpec> = {
+  // GPT-6 Astra: Standard API-equivalent pricing, verified 2026-09-07.
+  // Codex subscription catalog supports ultra; the public API lists only through max.
+  // @see https://developers.openai.com/api/docs/models/gpt-6-astra
+  // @see https://developers.openai.com/api/docs/pricing
+  "gpt-6-astra": {
+    maxEffort: "ultra",
+    inputTokens: 10,
+    outputTokens: 50,
+    cachedInputTokens: 1,
+    cacheCreationInputTokens: 12.5,
+    longContext: LONG_CONTEXT_272K,
+  },
   // GPT-5.6 Sol, Terra, Luna. cache write 단가는 외부 logger/manual usage 입력을 위해
   // 유지한다. 현재 OpenAI 응답 usage 에 cache write 토큰 필드가 없으면 비용은 0으로 계산된다.
   // @see https://developers.openai.com/api/docs/models/gpt-5.6-sol
   // @see https://developers.openai.com/api/docs/models/gpt-5.6-terra
   // @see https://developers.openai.com/api/docs/models/gpt-5.6-luna
+  // Sol promotional rates are available at least through 2026-11-21.
+  // No confirmed end date/replacement rate: recheck official pricing instead of auto-reverting.
   "gpt-5.6-sol": {
     maxEffort: "ultra",
-    inputTokens: 5,
-    outputTokens: 30,
-    cachedInputTokens: 0.5,
-    cacheCreationInputTokens: 6.25,
+    inputTokens: 4,
+    outputTokens: 20,
+    cachedInputTokens: 0.4,
+    cacheCreationInputTokens: 5,
     longContext: LONG_CONTEXT_272K,
   },
   "gpt-5.6-terra": {
     maxEffort: "ultra",
-    inputTokens: 2.5,
-    outputTokens: 15,
-    cachedInputTokens: 0.25,
-    cacheCreationInputTokens: 3.125,
+    inputTokens: 2,
+    outputTokens: 12,
+    cachedInputTokens: 0.2,
+    cacheCreationInputTokens: 2.5,
     longContext: LONG_CONTEXT_272K,
   },
   "gpt-5.6-luna": {
     maxEffort: "max",
-    inputTokens: 1,
-    outputTokens: 6,
-    cachedInputTokens: 0.1,
-    cacheCreationInputTokens: 1.25,
+    inputTokens: 0.2,
+    outputTokens: 1.2,
+    cachedInputTokens: 0.02,
+    cacheCreationInputTokens: 0.25,
     longContext: LONG_CONTEXT_272K,
   },
   // https://openai.com/index/introducing-gpt-5-5/ (2026-04 출시)

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

@@ -430,6 +430,7 @@ describe("effort 어휘 해석 (Codex 카탈로그 기준)", () => {
   }
 
   it("모델이 지원하는 값은 그대로 보내고, 상한 초과·공개 API 어휘는 reasoning 에서 빼 백엔드 기본값을 쓴다", async () => {
+    await expect(mappedEffortFor("gpt-6-astra", "ultra")).resolves.toBe("ultra");
     await expect(mappedEffortFor("gpt-5.6-terra", "ultra")).resolves.toBe("ultra");
     await expect(mappedEffortFor("gpt-5.5", "xhigh")).resolves.toBe("xhigh");
     await expect(mappedEffortFor("gpt-5.5", "max")).resolves.toBeUndefined();