@cartanova/qgrid-cli 2.9.1 → 2.9.4

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/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/startup-migrations.test.ts

@@ -4,20 +4,25 @@ import path from "node:path";
 
 import { afterEach, describe, expect, it, vi } from "vitest";
 
-const { latest } = vi.hoisted(() => ({ latest: vi.fn() }));
-
-vi.mock("./application/token/token.model", () => ({
-  TokenModel: {
-    getDB: () => ({ migrate: { latest } }),
-  },
-}));
-
 import {
   createStartupMigrationSource,
   resolveStartupMigrationDirs,
   runRequiredMigrations,
+  type StartupMigrationDeps,
 } from "./startup-migrations";
 
+// 실제 TokenModel/process.exit 대신 주입한다. 전체 스위트에서 모듈 목이 새면 진짜 exit(1) 이
+// vitest worker 를 죽여 이 파일의 나머지 테스트가 조용히 pending 으로 빠지기 때문이다.
+function makeDeps() {
+  const latest = vi.fn();
+  const exitError = new Error("process.exit called");
+  const exit = vi.fn((code: number) => {
+    throw Object.assign(exitError, { code });
+  }) as unknown as StartupMigrationDeps["exit"];
+  const deps: StartupMigrationDeps = { getKnex: () => ({ migrate: { latest } }) as never, exit };
+  return { latest, exit, exitError, deps };
+}
+
 const tempRoots: string[] = [];
 
 async function makeDirs() {
@@ -114,24 +119,23 @@ describe("createStartupMigrationSource", () => {
 describe("required startup migrations", () => {
   it("knex 기본 directory 대신 migrationSource 로 latest 를 실행한다", async () => {
     const dirs = await makeDirs();
+    const { latest, exit, deps } = makeDeps();
     latest.mockResolvedValueOnce([3, ["20260901163614_alter_tokens_add1_alter1.ts"]]);
 
-    await runRequiredMigrations(dirs);
+    await runRequiredMigrations(dirs, deps);
 
     expect(latest).toHaveBeenCalledWith({ migrationSource: expect.any(Object) });
     const call = latest.mock.calls.at(-1)?.[0] as { migrationSource: unknown; directory?: string };
     expect(call.directory).toBeUndefined();
+    expect(exit).not.toHaveBeenCalled();
   });
 
   it("terminates with a failure status when migration fails", async () => {
     const dirs = await makeDirs();
-    const failure = new Error("tokens.weight migration failed");
-    const exit = vi.spyOn(process, "exit").mockImplementation(() => {
-      throw failure;
-    });
-    latest.mockRejectedValueOnce(failure);
+    const { latest, exit, exitError, deps } = makeDeps();
+    latest.mockRejectedValueOnce(new Error("tokens.weight migration failed"));
 
-    await expect(runRequiredMigrations(dirs)).rejects.toBe(failure);
+    await expect(runRequiredMigrations(dirs, deps)).rejects.toBe(exitError);
 
     expect(exit).toHaveBeenCalledWith(1);
   });

package/bundle/src/startup-migrations.ts

@@ -50,7 +50,7 @@ export function createStartupMigrationSource(
       const entries = await readdir(dirs.sourceDir);
       return entries
         .filter((name) => MIGRATION_FILE_RE.test(name) && !name.endsWith(".d.ts"))
-        .sort();
+        .toSorted();
     },
     getMigrationName(name) {
       return name;
@@ -68,12 +68,20 @@ export function createStartupMigrationSource(
   };
 }
 
+export type StartupMigrationDeps = {
+  getKnex: () => Pick<Knex, "migrate">;
+  exit: (code: number) => never;
+};
+
+// 테스트는 deps 를 주입한다. 모듈 목으로 TokenModel 을 바꾸는 방식은 전체 스위트에서 목이 새면
+// 실제 process.exit(1) 이 worker 를 죽여 남은 테스트가 조용히 pending 으로 빠진다.
 export async function runRequiredMigrations(
   dirs: StartupMigrationDirs = resolveStartupMigrationDirs(),
+  deps: StartupMigrationDeps = { getKnex: () => TokenModel.getDB("w"), exit: process.exit },
 ): Promise<void> {
   const log = getLogger(["qgrid", "startup"]);
   try {
-    const knex = TokenModel.getDB("w");
+    const knex = deps.getKnex();
     const [batch, migrations] = await knex.migrate.latest({
       migrationSource: createStartupMigrationSource(dirs),
     });
@@ -82,6 +90,6 @@ export async function runRequiredMigrations(
     }
   } catch (error) {
     log.error(`migration failed: ${(error as Error).message}`);
-    process.exit(1);
+    deps.exit(1);
   }
 }

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

@@ -25,7 +25,7 @@ const {
 }));
 
 vi.mock("@logtape/logtape", () => ({
-  getLogger: () => ({ info: loggerInfoMock, warn: loggerWarnMock }),
+  getLogger: () => ({ debug: vi.fn(), info: loggerInfoMock, warn: loggerWarnMock }),
 }));
 
 vi.mock("./claude-session", async (importActual) => {

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

@@ -402,3 +402,16 @@ describe("decorateAndSerialize (envelope, U2 P1-#3 위임분)", () => {
     expect(parsed[0]!.uuid).not.toBe(parsed[1]!.uuid);
   });
 });
+
+describe("effort 어휘 해석 (Claude Code --effort 기준)", () => {
+  it("허용값은 그대로, OpenAI 전용·옛 어휘는 조용히 qgrid 기본(low)으로 바꾼다", () => {
+    const effortOf = (effort: string) => {
+      const args = buildClaudeArgs({ model: "claude-opus-5", sessionId: "u", effort });
+      return args[args.indexOf("--effort") + 1];
+    };
+    expect(effortOf("max")).toBe("max");
+    expect(effortOf("xhigh")).toBe("xhigh");
+    expect(effortOf("ultra")).toBe("low");
+    expect(effortOf("minimal")).toBe("low");
+  });
+});

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

@@ -18,6 +18,7 @@ import { spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { mkdirSync, unlinkSync, writeFileSync } from "node:fs";
 
+import { resolveAnthropicEffort } from "../common/effort";
 import { type JsonValue, type TokenUsageBreakdown, type UserInput } from "../common/provider-types";
 import {
   ARGV_SAFE_MAX_UTF8_BYTES,
@@ -245,8 +246,9 @@ export function buildClaudeArgs(opts: {
     ...systemArgs,
     // Fable 5 는 adaptive thinking 이 필수이고, Opus 5 는 공식 기본 adaptive 동작을 보존한다.
     ...(usesAdaptiveThinking(opts.model) ? [] : ["--thinking", "disabled"]),
+    // Claude Code 어휘 밖의 effort(OpenAI 전용 ultra, 옛 none/minimal 등)는 조용히 버리고 qgrid 기본을 쓴다.
     "--effort",
-    opts.effort ?? ANTHROPIC_DEFAULT_EFFORT,
+    resolveAnthropicEffort(opts.effort) ?? ANTHROPIC_DEFAULT_EFFORT,
     "--disable-slash-commands",
     "--session-id",
     opts.sessionId,

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

@@ -0,0 +1,61 @@
+import { describe, expect, it } from "vitest";
+
+import {
+  ANTHROPIC_EFFORTS,
+  OPENAI_EFFORTS,
+  resolveAnthropicEffort,
+  resolveOpenAIEffort,
+} 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);
+    }
+    expect(resolveOpenAIEffort("gpt-5.6-terra", "max")).toBe("max");
+    expect(resolveOpenAIEffort("gpt-5.6-terra", "ultra")).toBe("ultra");
+    expect(resolveOpenAIEffort("gpt-5.6-luna", "max")).toBe("max");
+  });
+
+  it("공개 API 어휘(none/minimal)와 다른 provider 어휘, 오타는 조용히 미지정으로 바꾼다", () => {
+    expect(resolveOpenAIEffort("gpt-5.6-terra", "none")).toBeUndefined();
+    expect(resolveOpenAIEffort("gpt-5.6-terra", "minimal")).toBeUndefined();
+    expect(resolveOpenAIEffort("gpt-5.6-terra", "hgih")).toBeUndefined();
+    expect(resolveOpenAIEffort("gpt-5.6-terra", undefined)).toBeUndefined();
+  });
+
+  it("모델 상한을 넘는 값은 클램프하지 않고 미지정으로 바꾼다", () => {
+    expect(resolveOpenAIEffort("gpt-5.5", "max")).toBeUndefined();
+    expect(resolveOpenAIEffort("gpt-5.4", "ultra")).toBeUndefined();
+    expect(resolveOpenAIEffort("gpt-5.6-luna", "ultra")).toBeUndefined();
+    expect(resolveOpenAIEffort("gpt-5.3-codex-spark", "xhigh")).toBe("xhigh");
+  });
+
+  it("어휘 순서가 클램프 판정의 기준이다", () => {
+    expect([...OPENAI_EFFORTS]).toEqual(["low", "medium", "high", "xhigh", "max", "ultra"]);
+    expect([...ANTHROPIC_EFFORTS]).toEqual(["low", "medium", "high", "xhigh", "max"]);
+  });
+});
+
+describe("resolveAnthropicEffort", () => {
+  it("Claude Code --effort 허용값은 그대로 통과한다", () => {
+    for (const effort of ANTHROPIC_EFFORTS) {
+      expect(resolveAnthropicEffort(effort)).toBe(effort);
+    }
+  });
+
+  it("OpenAI 전용 값과 모르는 값은 조용히 미지정으로 바꿔 qgrid 기본(low)이 적용되게 한다", () => {
+    expect(resolveAnthropicEffort("ultra")).toBeUndefined();
+    expect(resolveAnthropicEffort("none")).toBeUndefined();
+    expect(resolveAnthropicEffort("minimal")).toBeUndefined();
+    expect(resolveAnthropicEffort(undefined)).toBeUndefined();
+  });
+});

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

@@ -0,0 +1,53 @@
+import { getLogger } from "@logtape/logtape";
+
+import { openaiModelMaxEffort } from "./model-cost";
+
+const logger = getLogger(["qgrid", "effort"]);
+
+/**
+ * provider 별 reasoning effort 어휘.
+ *
+ * SDK 가 보낸 effort 문자열을 그대로 provider 에 넘기지 않는다. provider 마다 받는 값이 다르고,
+ * 모르는 값을 받았을 때의 반응도 다르다(Codex 백엔드는 400 이 예상되고, Claude Code 는 경고만
+ * 남기고 모델 기본 effort 로 실행한다). 각 provider dispatcher 가 요청을 만들 때 여기서 판정해,
+ * 맞지 않는 값은 오류 없이 버리고 "미지정" 과 같게 취급한다.
+ */
+
+// Codex 구독 백엔드 모델 카탈로그(~/.codex/models_cache.json) 의 supported_reasoning_levels 합집합.
+// 공개 OpenAI API 의 `none`/`minimal` 은 이 경로에 없다. 모델별 상한은 model-cost.ts 의 카탈로그에 있다.
+export const OPENAI_EFFORTS = ["low", "medium", "high", "xhigh", "max", "ultra"] as const;
+export type OpenAIEffort = (typeof OPENAI_EFFORTS)[number];
+
+// Claude Code `--effort` 허용값. 모델별 상한(xhigh_effort / max_effort capability)은 Claude Code 가
+// 스스로 처리하므로 qgrid 는 provider 집합만 검사한다.
+export const ANTHROPIC_EFFORTS = ["low", "medium", "high", "xhigh", "max"] as const;
+export type AnthropicEffort = (typeof ANTHROPIC_EFFORTS)[number];
+
+// 어휘 안에 있고 상한(있다면) 이하인 값만 통과시킨다. 나머지는 debug 로그 후 미지정.
+function resolveWithin<T extends string>(
+  levels: readonly T[],
+  effort: string | undefined,
+  max: T | undefined,
+  target: string,
+): T | undefined {
+  if (effort === undefined) return undefined;
+  const rank = levels.indexOf(effort as T);
+  if (rank < 0) {
+    logger.debug(`ignoring effort "${effort}" for ${target}: not in ${levels.join("/")}`);
+    return undefined;
+  }
+  if (max !== undefined && rank > levels.indexOf(max)) {
+    logger.debug(`ignoring effort "${effort}" for ${target}: model supports up to "${max}"`);
+    return undefined;
+  }
+  return effort as T;
+}
+
+/** canonical OpenAI model(`openai/` prefix 제거 후) 기준으로 effort 를 판정한다. */
+export function resolveOpenAIEffort(model: string, effort?: string): OpenAIEffort | undefined {
+  return resolveWithin(OPENAI_EFFORTS, effort, openaiModelMaxEffort(model), `openai/${model}`);
+}
+
+export function resolveAnthropicEffort(effort?: string): AnthropicEffort | undefined {
+  return resolveWithin(ANTHROPIC_EFFORTS, effort, undefined, "anthropic");
+}

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, {