@cartanova/qgrid-cli 2.9.2 → 2.9.5

package/bundle/src/application/qgrid/token-death.test.ts

@@ -39,7 +39,7 @@ describe("deactivateAuthDeadToken", () => {
   it("deactivates and notifies when the failed attempt used the current refresh token", async () => {
     deactivateMock.mockResolvedValue({
       marked: true,
-      keptAsLastActive: false,
+      wasLastActive: false,
       staleCredentials: false,
     });
 
@@ -60,7 +60,7 @@ describe("deactivateAuthDeadToken", () => {
   it("skips deactivation when credentials rotated since the failed attempt", async () => {
     deactivateMock.mockResolvedValue({
       marked: false,
-      keptAsLastActive: false,
+      wasLastActive: false,
       staleCredentials: true,
     });
 
@@ -73,7 +73,7 @@ describe("deactivateAuthDeadToken", () => {
   it("does not notify when another process won the deactivation race", async () => {
     deactivateMock.mockResolvedValue({
       marked: false,
-      keptAsLastActive: false,
+      wasLastActive: false,
       staleCredentials: false,
     });
 
@@ -82,18 +82,19 @@ describe("deactivateAuthDeadToken", () => {
     expect(notifySlackMock).not.toHaveBeenCalled();
   });
 
-  it("alerts instead of deactivating when the dying token is the last active one", async () => {
+  it("deactivates the last active token and sends an urgent expiry alert", async () => {
     deactivateMock.mockResolvedValue({
       marked: true,
-      keptAsLastActive: true,
+      wasLastActive: true,
       staleCredentials: false,
     });
 
-    await expect(deactivateAuthDeadToken(token, "anthropic:400")).resolves.toBe(false);
+    await expect(deactivateAuthDeadToken(token, "anthropic:400")).resolves.toBe(true);
 
     expect(notifySlackMock).toHaveBeenCalledTimes(1);
     const notification = notifySlackMock.mock.calls[0]![0] as { title: string; context: string };
-    expect(notification.title).toContain("마지막");
+    expect(notification.title).toBe("세션 만료");
+    expect(notifySlackMock.mock.calls[0]![0]).toMatchObject({ urgent: true });
     expect(notification.context).toContain("anthropic:400");
   });
 
@@ -101,12 +102,12 @@ describe("deactivateAuthDeadToken", () => {
     deactivateMock
       .mockResolvedValueOnce({
         marked: true,
-        keptAsLastActive: true,
+        wasLastActive: true,
         staleCredentials: false,
       })
       .mockResolvedValue({
         marked: false,
-        keptAsLastActive: false,
+        wasLastActive: false,
         staleCredentials: false,
       });
 
@@ -120,7 +121,7 @@ describe("deactivateAuthDeadToken", () => {
   it("never puts the raw provider error body in the notification", async () => {
     deactivateMock.mockResolvedValue({
       marked: true,
-      keptAsLastActive: false,
+      wasLastActive: false,
       staleCredentials: false,
     });
 

package/bundle/src/application/qgrid/token-death.ts

@@ -24,7 +24,7 @@ export async function deactivateAuthDeadToken(
   token: DeadTokenRef,
   reasonCode: string,
 ): Promise<boolean> {
-  const { marked, keptAsLastActive, staleCredentials } = await TokenModel.markReauthRequired(
+  const { marked, wasLastActive, staleCredentials } = await TokenModel.markReauthRequired(
     token.id,
     token.credentials,
   );
@@ -35,10 +35,6 @@ export async function deactivateAuthDeadToken(
     return false;
   }
   if (!marked) return false;
-  if (keptAsLastActive) {
-    notifyLastActiveTokenDying(token, reasonCode);
-    return false;
-  }
 
   logger.warn(`token requires re-login: ${token.name}(id=${token.id}) reason=${reasonCode}`);
   // 만료 직후가 재로그인하기 가장 좋은 타이밍이다. 소유자를 멘션해 그 순간 당사자에게
@@ -47,29 +43,21 @@ export async function deactivateAuthDeadToken(
   void notifySlack({
     title: "세션 만료",
     subject: token.name,
-    context: [mention, token.provider, reasonCode, "재로그인이 필요합니다"]
+    context: [
+      mention,
+      token.provider,
+      reasonCode,
+      "재로그인이 필요합니다",
+      wasLastActive ? "사용 가능한 토큰이 없습니다" : null,
+    ]
       .filter(Boolean)
       .join(" · "),
     color: SLACK_COLOR.bad,
+    urgent: wasLastActive,
   });
   return true;
 }
 
-function notifyLastActiveTokenDying(token: DeadTokenRef, reasonCode: string): void {
-  const mention = mentionFor(token.name, getSlackUserMap());
-  void notifySlack({
-    title: "마지막 토큰 사망",
-    subject: token.name,
-    context:
-      [mention, token.provider, reasonCode].filter(Boolean).join(" · ") +
-      ` · 풀이 비지 않도록 유지 중입니다. ` +
-      `전 토큰이 동시에 실패했다면 client_id 취소나 OAuth 계약 변경을 의심하세요`,
-    color: SLACK_COLOR.bad,
-    // provider 전체가 죽었다는 신호다. 조용 시간에 묻히면 다음 근무일까지 서비스가 멈춘다.
-    urgent: true,
-  });
-}
-
 /** 로그인이 완료돼 토큰이 저장됐을 때. 신규·재로그인을 가리지 않는다. */
 export function notifyTokenAdded(name: string, provider: string): void {
   logger.info(`token added: ${name} (${provider})`);

package/bundle/src/application/qgrid/token-subscriber.test.ts

@@ -2,15 +2,17 @@ import { beforeEach, describe, expect, it, vi } from "vitest";
 
 import { TokenSubscriber } from "./token-subscriber";
 
-const { findOneMock, findActiveMock } = vi.hoisted(() => ({
+const { findOneMock, findActiveMock, deactivateExpiredTokensMock } = vi.hoisted(() => ({
   findOneMock: vi.fn(),
   findActiveMock: vi.fn(),
+  deactivateExpiredTokensMock: vi.fn(),
 }));
 
 vi.mock("../token/token.model", () => ({
   TokenModel: {
     findOne: findOneMock,
     findActive: findActiveMock,
+    deactivateExpiredTokens: deactivateExpiredTokensMock,
   },
 }));
 
@@ -264,6 +266,8 @@ describe("TokenSubscriber OpenAI notifications", () => {
 
     await subscriber.reconcile();
 
+    expect(deactivateExpiredTokensMock).toHaveBeenCalled();
+
     expect(anthropicDispatcher.replaceTokens).toHaveBeenCalledWith([
       expect.objectContaining({ id: 1, quotaThreshold: 80, weight: 4 }),
     ]);

package/bundle/src/application/qgrid/token-subscriber.ts

@@ -271,6 +271,7 @@ export class TokenSubscriber {
             .map((row) => row.id),
         )
       : null;
+    await TokenModel.deactivateExpiredTokens();
     const rows = await TokenModel.findActive("A");
     this.dispatcher.replaceCache(rows);
     // NOTIFY 유실 대비: AnthropicDispatcher 풀도 DB active anthropic 토큰 기준으로 재동기화.

package/bundle/src/application/qgrid/tool-emulation.test.ts

@@ -56,6 +56,24 @@ describe("applyToolCallEmulation image parts", () => {
     });
     expect(out.content).toEqual([{ type: "text", text: "here is your image" }]);
   });
+
+  it("preserves observed image settings and attaches response usage only once", () => {
+    const generation = {
+      route: "codex-images" as const, model: "gpt-image-2" as const,
+      size: "1254x1254", quality: "medium", background: "transparent",
+    };
+    const usage = { input_tokens: 10, output_tokens: 100, total_tokens: 110 };
+    const out = applyToolCallEmulation(baseResult, undefined, {
+      answerKind: "text",
+      images: [
+        { ...img, generation: { ...generation, usage } },
+        { ...img, generation },
+      ],
+    });
+    expect(out.content.filter((item) => item.type === "image").map((item) => item.generation))
+      .toEqual([{ ...generation, usage }, generation]);
+    expect(out.usage).toEqual(baseResult.usage);
+  });
 });
 
 describe("applyToolCallEmulation envelope validation", () => {

package/bundle/src/application/qgrid/tool-emulation.ts

@@ -12,6 +12,7 @@ const STRUCTURED_ENVELOPE_LIMITS = {
   maxDepth: 132,
 } as const;
 import {
+  type ImageGenerationMetadata,
   type QgridContent,
   type QgridThreadCoord,
   type QgridTool,
@@ -70,6 +71,7 @@ export class ToolCallEmulationError extends Error {
 interface EmulationImage {
   data: string;
   revisedPrompt?: string | null;
+  generation?: ImageGenerationMetadata;
 }
 
 // answer 인코딩 종류. envelope 디코더는 한 벌이고 이 값은 answer 브랜치의 타입과
@@ -212,6 +214,7 @@ function appendImages(content: QgridContent[], images?: EmulationImage[]): Qgrid
         type: "image",
         data: image.data,
         revisedPrompt: image.revisedPrompt ?? null,
+        ...(image.generation ? { generation: image.generation } : {}),
       }),
     ),
   ];

package/bundle/src/application/setting/setting.model.test.ts

@@ -6,6 +6,26 @@ import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { resetNativeRunRegistryForTests } from "../qgrid/qgrid-run-lifecycle";
 import { resetServerRestartForTests } from "../../utils/server-restart";
 import { SettingModel } from "./setting.model";
+import * as reminders from "../qgrid/expired-token-reminder";
+import { SlackNotificationError } from "../../utils/slack-notify";
+
+describe("SettingModel.triggerExpiryReminder", () => {
+  afterEach(() => vi.restoreAllMocks());
+
+  it("returns the sent count after successful delivery", async () => {
+    vi.spyOn(reminders, "sendExpiredTokenReminderNow").mockResolvedValue(3);
+    await expect(SettingModel.triggerExpiryReminder()).resolves.toEqual({ sent: 3 });
+  });
+
+  it("returns a readable API error when Slack rejects a manual send", async () => {
+    vi.spyOn(reminders, "sendExpiredTokenReminderNow").mockRejectedValue(
+      new SlackNotificationError("Slack 알림 발송 실패: not_in_channel"),
+    );
+    await expect(SettingModel.triggerExpiryReminder()).rejects.toMatchObject({
+      statusCode: 400, message: "Slack 알림 발송 실패: not_in_channel",
+    });
+  });
+});
 
 function installContext(headers: Record<string, string>) {
   const raw = Object.assign(new EventEmitter(), {

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

@@ -11,9 +11,10 @@ import {
   exhaustive,
 } from "sonamu";
 
-import { SD } from "../../i18n/sd.generated";
+import { SD, type LocalizedString } from "../../i18n/sd.generated";
 import { detectSupervisor } from "../../utils/process-supervisor";
 import { armServerRestartExit, beginServerRestart } from "../../utils/server-restart";
+import { SlackNotificationError } from "../../utils/slack-notify";
 import { type SettingSubsetKey, type SettingSubsetMapping } from "../sonamu.generated";
 import { settingSubsetQueries, settingLoaderQueries } from "../sonamu.generated.sso";
 import {
@@ -315,7 +316,14 @@ class SettingModelClass extends BaseModelClass<
     // setting.model → expired-token-reminder → token.model 경로가 생겨,
     // token.model 을 mock 하는 테스트가 실제 모듈을 먼저 로드하게 된다.
     const { sendExpiredTokenReminderNow } = await import("../qgrid/expired-token-reminder");
-    return { sent: await sendExpiredTokenReminderNow() };
+    try {
+      return { sent: await sendExpiredTokenReminderNow() };
+    } catch (error) {
+      if (error instanceof SlackNotificationError) {
+        throw new BadRequestException(error.message as LocalizedString);
+      }
+      throw error;
+    }
   }
 
   /**

package/bundle/src/application/sonamu.generated.http

@@ -326,7 +326,8 @@ Content-Type: application/json
     "imageGeneration": false,
     "imageGenerationOptions": {
       "quality": "low",
-      "size": "1024x1024"
+      "size": "1024x1024",
+      "background": "auto"
     }
   }
 }
@@ -388,7 +389,8 @@ Content-Type: application/json
     "imageGeneration": false,
     "imageGenerationOptions": {
       "quality": "low",
-      "size": "1024x1024"
+      "size": "1024x1024",
+      "background": "auto"
     }
   }
 }

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

@@ -213,7 +213,25 @@ describe("TokenModel.markReauthRequired", () => {
     await Sonamu.initForTesting();
   });
 
-  it("serializes provider deaths, preserves one active token, and rejects stale credentials", async () => {
+  it("repairs legacy active expired tokens without changing healthy or manually inactive tokens", async () => {
+    const ids = await TokenModel.save([
+      { ...baseToken, name: "legacy-expired", active: true, reauth_required: true },
+      { ...baseToken, name: "healthy", active: true, reauth_required: false },
+      { ...baseToken, name: "manual-inactive", active: false, reauth_required: false },
+    ]);
+    try {
+      await TokenModel.deactivateExpiredTokens();
+      await TokenModel.deactivateExpiredTokens();
+      const { rows } = await TokenModel.findMany("A", { id: ids, num: 3 });
+      expect(rows.find((row) => row.id === ids[0])).toMatchObject({ active: false, reauth_required: true });
+      expect(rows.find((row) => row.id === ids[1])).toMatchObject({ active: true, reauth_required: false });
+      expect(rows.find((row) => row.id === ids[2])).toMatchObject({ active: false, reauth_required: false });
+    } finally {
+      await TokenModel.del(ids);
+    }
+  });
+
+  it("deactivates every expired token and rejects stale credentials", async () => {
     const suffix = randomUUID();
     const tokens = [
       {
@@ -237,7 +255,7 @@ describe("TokenModel.markReauthRequired", () => {
         }),
       ).resolves.toEqual({
         marked: false,
-        keptAsLastActive: false,
+        wasLastActive: false,
         staleCredentials: true,
       });
 
@@ -246,16 +264,17 @@ describe("TokenModel.markReauthRequired", () => {
         TokenModel.markReauthRequired(ids[1]!, tokens[1]!.credentials),
       ]);
       expect(results.every((result) => result.marked)).toBe(true);
+      expect(results.filter((result) => result.wasLastActive)).toHaveLength(1);
 
       const { rows } = await TokenModel.findMany("A", { id: ids, num: 2 });
       expect(rows.every((row) => row.reauth_required)).toBe(true);
-      expect(rows.filter((row) => row.active)).toHaveLength(1);
+      expect(rows.filter((row) => row.active)).toHaveLength(0);
 
       await expect(
         TokenModel.markReauthRequired(ids[0]!, tokens[0]!.credentials),
       ).resolves.toEqual({
         marked: false,
-        keptAsLastActive: false,
+        wasLastActive: false,
         staleCredentials: false,
       });
 
@@ -278,7 +297,7 @@ describe("TokenModel.markReauthRequired", () => {
         TokenModel.markReauthRequired(inactive.id, inactive.credentials),
       ).resolves.toEqual({
         marked: false,
-        keptAsLastActive: false,
+        wasLastActive: false,
         staleCredentials: true,
       });
 

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/common/provider-dispatcher.ts

@@ -4,7 +4,10 @@
  * MVP 에서는 stream() 만. getRateLimits(), listModels() 는 future.
  */
 
-import { type ImageGenerationOptions } from "../../../application/qgrid/qgrid.types";
+import {
+  type ImageGenerationMetadata,
+  type ImageGenerationOptions,
+} from "../../../application/qgrid/qgrid.types";
 import { type JsonValue, type TokenUsageBreakdown, type UserInput } from "./provider-types";
 
 // qgrid provider 내부 표준 usage. provider 전용 cache write 세부 필드는 여기서 확장해 보존한다.
@@ -27,6 +30,7 @@ export interface ReuseThreadCoord {
 export interface GeneratedImage {
   data: string; // base64 PNG
   revisedPrompt: string | null;
+  generation?: ImageGenerationMetadata;
 }
 
 // Provider/런타임이 요청 모델 대신 다른 모델로 실제 응답을 생성한 이력.

package/bundle/src/utils/providers/openai/openai-backend-protocol.ts

@@ -1,5 +1,6 @@
 import os from "node:os";
 
+import { type ImageGenerationMetadata } from "../../../application/qgrid/qgrid.types";
 import { type OpenAIEffort } from "../common/effort";
 
 export const CHATGPT_CODEX_RESPONSES_URL =
@@ -170,7 +171,14 @@ export interface OpenAIUsage {
 export type OpenAINormalizedEvent =
   | { type: "created"; responseId?: string }
   | { type: "text-delta"; text: string }
-  | { type: "image"; id?: string; base64: string; mimeType: "image/png"; revisedPrompt?: string }
+  | {
+      type: "image";
+      id?: string;
+      base64: string;
+      mimeType: "image/png";
+      revisedPrompt?: string;
+      generation?: ImageGenerationMetadata;
+    }
   | { type: "output-item"; item: OpenAIResponseItem }
   | { type: "completed"; responseId: string; usage?: OpenAIUsage; model?: string }
   | { type: "error"; error: OpenAIProtocolError };