@cartanova/qgrid-cli 2.9.2 → 2.9.4

package/bundle/dist/application/token/token.model.js

@@ -198,9 +198,8 @@ var TokenModelClass = class 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, expectedCredentials) {
 		return this.getPuri("w").transaction(async (trx) => {
@@ -211,38 +210,44 @@ var TokenModelClass = class extends BaseModelClass {
 			}).where("id", id).forUpdate().first();
 			if (!token || token.reauth_required) return {
 				marked: false,
-				keptAsLastActive: false,
+				wasLastActive: false,
 				staleCredentials: false
 			};
 			if (!isDeepStrictEqual(token.credentials, expectedCredentials)) return {
 				marked: false,
-				keptAsLastActive: false,
+				wasLastActive: false,
 				staleCredentials: true
 			};
 			await trx.knex.raw("SELECT pg_advisory_xact_lock(?, hashtext(?))", [TOKEN_AUTH_DEATH_LOCK_CLASS_ID, token.provider]);
-			const marked = (await trx.knex.raw(`UPDATE tokens
+			const marked = (await trx.knex.raw(`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])).rows[0];
+         RETURNING (SELECT was_last_active FROM previous) AS was_last_active`, [id, id])).rows[0];
 			if (!marked) return {
 				marked: false,
-				keptAsLastActive: 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,
+				wasLastActive: marked.was_last_active,
 				staleCredentials: false
 			};
 		});
 	}
+	/** Repair rows retained by the former last-active exception before pool reconciliation. */
+	async deactivateExpiredTokens() {
+		await this.getPuri("w").table("tokens").where("reauth_required", true).where("active", true).update({ active: false });
+	}
 	async reorder(ids) {
 		await this.getPuri("w").transaction(async (trx) => {
 			for (let i = 0; i < ids.length; i++) await trx.table("tokens").where("id", ids[i]).update({ ord: i });
@@ -298,4 +303,4 @@ const TokenModel = new TokenModelClass();
 //#endregion
 export { TokenModel };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"token.model.js","names":[],"sources":["../../../src/application/token/token.model.ts"],"sourcesContent":["import { isDeepStrictEqual } from \"node:util\";\n\nimport { getLogger } from \"@logtape/logtape\";\nimport {\n  api,\n  asArray,\n  BadRequestException,\n  BaseModelClass,\n  exhaustive,\n  type ListResult,\n  NotFoundException,\n} from \"sonamu\";\n\nimport { SD } from \"../../i18n/sd.generated\";\nimport { type TokenSubsetKey, type TokenSubsetMapping } from \"../sonamu.generated\";\nimport { tokenLoaderQueries, tokenSubsetQueries } from \"../sonamu.generated.sso\";\nimport { type TokenCredentials, type TokenListParams, type TokenSaveParams } from \"./token.types\";\n\nconst logger = getLogger([\"qgrid\", \"token\"]);\n\nconst DEFAULT_QUOTA_THRESHOLD = 80;\nconst DEFAULT_WEIGHT = 1;\nconst TOKEN_AUTH_DEATH_LOCK_CLASS_ID = 719;\n\nexport type TokenUpdateFields = {\n  name?: string;\n  quota_threshold?: number | null;\n  weight?: number;\n  keepalive_enabled?: boolean;\n};\n\nfunction applyCreateDefaults(sp: TokenSaveParams): TokenSaveParams {\n  if (sp.id !== undefined) return sp;\n  return {\n    ...sp,\n    ...(sp.quota_threshold === undefined ? { quota_threshold: DEFAULT_QUOTA_THRESHOLD } : {}),\n    ...(sp.weight === undefined ? { weight: DEFAULT_WEIGHT } : {}),\n  };\n}\n\nclass TokenModelClass extends BaseModelClass<\n  TokenSubsetKey,\n  TokenSubsetMapping,\n  typeof tokenSubsetQueries,\n  typeof tokenLoaderQueries\n> {\n  constructor() {\n    super(\"Token\", tokenSubsetQueries, tokenLoaderQueries);\n  }\n\n  @api({ httpMethod: \"GET\", clients: [\"axios\", \"tanstack-query\"], resourceName: \"Token\" })\n  async findById<T extends TokenSubsetKey>(subset: T, id: number): Promise<TokenSubsetMapping[T]> {\n    const { rows } = await this.findMany(subset, { id, num: 1, page: 1 });\n    if (!rows[0]) {\n      throw new NotFoundException(SD(\"error.entityNotFound\")(\"Token\", id));\n    }\n    return rows[0];\n  }\n\n  async findOne<T extends TokenSubsetKey>(\n    subset: T,\n    listParams: TokenListParams,\n  ): Promise<TokenSubsetMapping[T] | null> {\n    const { rows } = await this.findMany(subset, { ...listParams, num: 1, page: 1 });\n    return rows[0] ?? null;\n  }\n\n  @api({ httpMethod: \"GET\", clients: [\"axios\", \"tanstack-query\"], resourceName: \"Tokens\" })\n  async findMany<T extends TokenSubsetKey, LP extends TokenListParams>(\n    subset: T,\n    rawParams?: LP,\n  ): Promise<ListResult<LP, TokenSubsetMapping[T]>> {\n    const params = {\n      num: 24,\n      page: 1,\n      search: \"id\" as const,\n      orderBy: \"ord-asc\" as const,\n      ...rawParams,\n    } satisfies TokenListParams;\n\n    const { qb, onSubset: _ } = this.getSubsetQueries(subset);\n\n    if (params.id) {\n      qb.whereIn(\"tokens.id\", asArray(params.id));\n    }\n\n    if (params.search && params.keyword && params.keyword.length > 0) {\n      if (params.search === \"id\") {\n        qb.where(\"tokens.id\", Number(params.keyword));\n      } else if (params.search === \"name\") {\n        qb.where(\"tokens.name\", \"like\", `%${params.keyword}%`);\n      } else {\n        throw new BadRequestException(SD(\"error.unknownSearchField\")(params.search));\n      }\n    }\n\n    if (params.orderBy) {\n      if (params.orderBy === \"id-desc\") {\n        qb.orderBy(\"tokens.id\", \"desc\");\n      } else if (params.orderBy === \"ord-asc\") {\n        qb.orderBy(\"tokens.ord\", \"asc\");\n        qb.orderBy(\"tokens.id\", \"asc\");\n      } else {\n        exhaustive(params.orderBy);\n      }\n    }\n\n    const enhancers = this.createEnhancers({\n      A: (row) => ({ ...row }),\n    });\n\n    return this.executeSubsetQuery({ subset, qb, params, enhancers, debug: false });\n  }\n\n  async findByAccountIdentifier<T extends TokenSubsetKey>(\n    subset: T,\n    provider: string,\n    accountId: string,\n  ): Promise<TokenSubsetMapping[T][]> {\n    const { qb } = this.getSubsetQueries(subset);\n    qb.where(\"tokens.provider\", provider);\n    const jsonKey = provider === \"anthropic\" ? \"accountUuid\" : \"accountId\";\n    qb.whereRaw(`tokens.credentials->>'${jsonKey}' = ?`, [accountId]);\n    const enhancers = this.createEnhancers({ A: (row) => ({ ...row }) });\n    const result = await this.executeSubsetQuery({\n      subset,\n      qb,\n      params: { num: 100, page: 1 },\n      enhancers,\n      debug: false,\n    });\n    return result.rows;\n  }\n\n  async findActiveByProvider<T extends TokenSubsetKey>(\n    subset: T,\n    provider: string,\n  ): Promise<TokenSubsetMapping[T][]> {\n    const { qb } = this.getSubsetQueries(subset);\n    qb.where(\"tokens.active\", true);\n    qb.where(\"tokens.provider\", provider);\n    const enhancers = this.createEnhancers({ A: (row) => ({ ...row }) });\n    const result = await this.executeSubsetQuery({\n      subset,\n      qb,\n      params: { num: 100, page: 1 },\n      enhancers,\n      debug: false,\n    });\n    return result.rows;\n  }\n\n  async findActiveByProviderAndName<T extends TokenSubsetKey>(\n    subset: T,\n    provider: string,\n    name: string,\n  ): Promise<TokenSubsetMapping[T] | undefined> {\n    const { qb } = this.getSubsetQueries(subset);\n    qb.where(\"tokens.active\", true);\n    qb.where(\"tokens.provider\", provider);\n    qb.where(\"tokens.name\", name);\n    const enhancers = this.createEnhancers({ A: (row) => ({ ...row }) });\n    const result = await this.executeSubsetQuery({\n      subset,\n      qb,\n      params: { num: 1, page: 1 },\n      enhancers,\n      debug: false,\n    });\n    return result.rows[0];\n  }\n\n  /** 실제 인증 만료가 확인돼 재로그인이 필요한 토큰들. 수동 비활성화는 제외한다. */\n  async findReauthRequired<T extends TokenSubsetKey>(subset: T): Promise<TokenSubsetMapping[T][]> {\n    const { qb } = this.getSubsetQueries(subset);\n    qb.where(\"tokens.reauth_required\", true);\n    qb.orderBy(\"tokens.name\", \"asc\");\n    const enhancers = this.createEnhancers({ A: (row) => ({ ...row }) });\n    const result = await this.executeSubsetQuery({\n      subset,\n      qb,\n      params: { num: 100, page: 1 },\n      enhancers,\n      debug: false,\n    });\n    return result.rows;\n  }\n\n  async findActive<T extends TokenSubsetKey>(subset: T): Promise<TokenSubsetMapping[T][]> {\n    const { qb } = this.getSubsetQueries(subset);\n    qb.where(\"tokens.active\", true);\n    const enhancers = this.createEnhancers({ A: (row) => ({ ...row }) });\n    const result = await this.executeSubsetQuery({\n      subset,\n      qb,\n      params: { num: 100, page: 1 },\n      enhancers,\n      debug: false,\n    });\n    return result.rows;\n  }\n\n  async save(spa: TokenSaveParams[]): Promise<number[]> {\n    const wdb = this.getPuri(\"w\");\n    spa.forEach((sp) => {\n      wdb.ubRegister(\"tokens\", applyCreateDefaults(sp));\n    });\n    return wdb.transaction(async (trx) => {\n      return trx.ubUpsert(\"tokens\");\n    });\n  }\n\n  async updateFields(id: number, fields: TokenUpdateFields): Promise<number> {\n    const wdb = this.getPuri(\"w\");\n    return wdb.transaction((trx) => trx.table(\"tokens\").where(\"id\", id).update(fields));\n  }\n\n  async toggleActive(id: number): Promise<{ active: boolean; reauthRequired: boolean } | null> {\n    const wdb = this.getPuri(\"w\");\n    return wdb.transaction(async (trx) => {\n      const token = await trx\n        .from(\"tokens\")\n        .select({ active: \"active\", reauth_required: \"reauth_required\" })\n        .where(\"id\", id)\n        .forUpdate()\n        .first();\n      if (!token) return null;\n      if (!token.active && token.reauth_required) {\n        return { active: false, reauthRequired: true };\n      }\n\n      const active = !token.active;\n      await trx.from(\"tokens\").where(\"id\", id).update({ active });\n      return { active, reauthRequired: false };\n    });\n  }\n\n  /**\n   * 같은 계정의 기존 토큰을 지우고 새로 저장한다(로그인·재로그인 공통 경로).\n   *\n   * provider 응답에 계정 식별자가 없으면 dedup 자체가 불가능하므로 경고만 남기고\n   * 중복 제거 없이 저장한다(죽은 row 가 남는다).\n   */\n  async replaceByAccount(\n    provider: string,\n    accountId: string | undefined,\n    saveParams: TokenSaveParams,\n  ): Promise<void> {\n    let keepaliveEnabled = saveParams.keepalive_enabled;\n    if (accountId) {\n      const oldEntries = await this.findByAccountIdentifier(\"A\", provider, accountId);\n      if (keepaliveEnabled === undefined && oldEntries.length > 0) {\n        keepaliveEnabled = oldEntries.some((entry) => entry.keepalive_enabled);\n      }\n      if (oldEntries.length > 0) await this.del(oldEntries.map((o) => o.id));\n    } else {\n      logger.warn(\n        `${provider} login without account identifier: dedup skipped for ${saveParams.name ?? \"unnamed\"}`,\n      );\n    }\n\n    await this.save([\n      keepaliveEnabled === undefined\n        ? saveParams\n        : { ...saveParams, keepalive_enabled: keepaliveEnabled },\n    ]);\n  }\n\n  /**\n   * 인증 사망을 한 번만 기록하고, 다른 활성 토큰이 있으면 라우팅에서도 제외한다.\n   * 마지막 활성 토큰은 systemic 장애 안전판 때문에 active 상태를 유지하되 재로그인\n   * 필요 상태는 기록한다. `marked`가 공유 DB 인스턴스들의 알림 발송 게이트다.\n   */\n  async markReauthRequired(\n    id: number,\n    expectedCredentials: TokenCredentials,\n  ): Promise<{ marked: boolean; keptAsLastActive: boolean; staleCredentials: boolean }> {\n    const wdb = this.getPuri(\"w\");\n    return wdb.transaction(async (trx) => {\n      const token = await trx\n        .from(\"tokens\")\n        .select({\n          provider: \"provider\",\n          credentials: \"credentials\",\n          reauth_required: \"reauth_required\",\n        })\n        .where(\"id\", id)\n        .forUpdate()\n        .first();\n      if (!token || token.reauth_required) {\n        return { marked: false, keptAsLastActive: false, staleCredentials: false };\n      }\n      if (!isDeepStrictEqual(token.credentials, expectedCredentials)) {\n        return { marked: false, keptAsLastActive: false, staleCredentials: true };\n      }\n\n      await trx.knex.raw(\"SELECT pg_advisory_xact_lock(?, hashtext(?))\", [\n        TOKEN_AUTH_DEATH_LOCK_CLASS_ID,\n        token.provider,\n      ]);\n      const updated = await trx.knex.raw<{ rows: { active: boolean }[] }>(\n        `UPDATE tokens\n         SET reauth_required = true,\n             active = CASE\n               WHEN active AND (SELECT count(*) FROM tokens peer\n                 WHERE peer.provider = tokens.provider AND peer.active) > 1\n               THEN false\n               ELSE active\n             END\n         WHERE id = ? AND reauth_required = false\n         RETURNING active`,\n        [id],\n      );\n      const marked = updated.rows[0];\n      if (!marked) return { marked: false, keptAsLastActive: false, staleCredentials: false };\n\n      if (marked.active) {\n        logger.error(\n          `refusing to auto-deactivate token ${id}: last active provider token — ` +\n            `systemic refresh failure suspected, keeping the pool non-empty`,\n        );\n      }\n      return { marked: true, keptAsLastActive: marked.active, staleCredentials: false };\n    });\n  }\n\n  @api({ httpMethod: \"POST\", clients: [\"axios\", \"tanstack-mutation\"] })\n  async reorder(ids: number[]): Promise<{ done: boolean }> {\n    const wdb = this.getPuri(\"w\");\n    await wdb.transaction(async (trx) => {\n      for (let i = 0; i < ids.length; i++) {\n        await trx.table(\"tokens\").where(\"id\", ids[i]!).update({ ord: i });\n      }\n    });\n    return { done: true };\n  }\n\n  @api({ httpMethod: \"POST\", clients: [\"axios\", \"tanstack-mutation\"] })\n  async del(ids: number[]): Promise<number> {\n    const wdb = this.getPuri(\"w\");\n    await wdb.transaction(async (trx) => {\n      return trx.table(\"tokens\").whereIn(\"tokens.id\", ids).delete();\n    });\n    return ids.length;\n  }\n}\n\nexport const TokenModel = new TokenModelClass();\n"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"token.model.js","names":[],"sources":["../../../src/application/token/token.model.ts"],"sourcesContent":["import { isDeepStrictEqual } from \"node:util\";\n\nimport { getLogger } from \"@logtape/logtape\";\nimport {\n  api,\n  asArray,\n  BadRequestException,\n  BaseModelClass,\n  exhaustive,\n  type ListResult,\n  NotFoundException,\n} from \"sonamu\";\n\nimport { SD } from \"../../i18n/sd.generated\";\nimport { type TokenSubsetKey, type TokenSubsetMapping } from \"../sonamu.generated\";\nimport { tokenLoaderQueries, tokenSubsetQueries } from \"../sonamu.generated.sso\";\nimport { type TokenCredentials, type TokenListParams, type TokenSaveParams } from \"./token.types\";\n\nconst logger = getLogger([\"qgrid\", \"token\"]);\n\nconst DEFAULT_QUOTA_THRESHOLD = 80;\nconst DEFAULT_WEIGHT = 1;\nconst TOKEN_AUTH_DEATH_LOCK_CLASS_ID = 719;\n\nexport type TokenUpdateFields = {\n  name?: string;\n  quota_threshold?: number | null;\n  weight?: number;\n  keepalive_enabled?: boolean;\n};\n\nfunction applyCreateDefaults(sp: TokenSaveParams): TokenSaveParams {\n  if (sp.id !== undefined) return sp;\n  return {\n    ...sp,\n    ...(sp.quota_threshold === undefined ? { quota_threshold: DEFAULT_QUOTA_THRESHOLD } : {}),\n    ...(sp.weight === undefined ? { weight: DEFAULT_WEIGHT } : {}),\n  };\n}\n\nclass TokenModelClass extends BaseModelClass<\n  TokenSubsetKey,\n  TokenSubsetMapping,\n  typeof tokenSubsetQueries,\n  typeof tokenLoaderQueries\n> {\n  constructor() {\n    super(\"Token\", tokenSubsetQueries, tokenLoaderQueries);\n  }\n\n  @api({ httpMethod: \"GET\", clients: [\"axios\", \"tanstack-query\"], resourceName: \"Token\" })\n  async findById<T extends TokenSubsetKey>(subset: T, id: number): Promise<TokenSubsetMapping[T]> {\n    const { rows } = await this.findMany(subset, { id, num: 1, page: 1 });\n    if (!rows[0]) {\n      throw new NotFoundException(SD(\"error.entityNotFound\")(\"Token\", id));\n    }\n    return rows[0];\n  }\n\n  async findOne<T extends TokenSubsetKey>(\n    subset: T,\n    listParams: TokenListParams,\n  ): Promise<TokenSubsetMapping[T] | null> {\n    const { rows } = await this.findMany(subset, { ...listParams, num: 1, page: 1 });\n    return rows[0] ?? null;\n  }\n\n  @api({ httpMethod: \"GET\", clients: [\"axios\", \"tanstack-query\"], resourceName: \"Tokens\" })\n  async findMany<T extends TokenSubsetKey, LP extends TokenListParams>(\n    subset: T,\n    rawParams?: LP,\n  ): Promise<ListResult<LP, TokenSubsetMapping[T]>> {\n    const params = {\n      num: 24,\n      page: 1,\n      search: \"id\" as const,\n      orderBy: \"ord-asc\" as const,\n      ...rawParams,\n    } satisfies TokenListParams;\n\n    const { qb, onSubset: _ } = this.getSubsetQueries(subset);\n\n    if (params.id) {\n      qb.whereIn(\"tokens.id\", asArray(params.id));\n    }\n\n    if (params.search && params.keyword && params.keyword.length > 0) {\n      if (params.search === \"id\") {\n        qb.where(\"tokens.id\", Number(params.keyword));\n      } else if (params.search === \"name\") {\n        qb.where(\"tokens.name\", \"like\", `%${params.keyword}%`);\n      } else {\n        throw new BadRequestException(SD(\"error.unknownSearchField\")(params.search));\n      }\n    }\n\n    if (params.orderBy) {\n      if (params.orderBy === \"id-desc\") {\n        qb.orderBy(\"tokens.id\", \"desc\");\n      } else if (params.orderBy === \"ord-asc\") {\n        qb.orderBy(\"tokens.ord\", \"asc\");\n        qb.orderBy(\"tokens.id\", \"asc\");\n      } else {\n        exhaustive(params.orderBy);\n      }\n    }\n\n    const enhancers = this.createEnhancers({\n      A: (row) => ({ ...row }),\n    });\n\n    return this.executeSubsetQuery({ subset, qb, params, enhancers, debug: false });\n  }\n\n  async findByAccountIdentifier<T extends TokenSubsetKey>(\n    subset: T,\n    provider: string,\n    accountId: string,\n  ): Promise<TokenSubsetMapping[T][]> {\n    const { qb } = this.getSubsetQueries(subset);\n    qb.where(\"tokens.provider\", provider);\n    const jsonKey = provider === \"anthropic\" ? \"accountUuid\" : \"accountId\";\n    qb.whereRaw(`tokens.credentials->>'${jsonKey}' = ?`, [accountId]);\n    const enhancers = this.createEnhancers({ A: (row) => ({ ...row }) });\n    const result = await this.executeSubsetQuery({\n      subset,\n      qb,\n      params: { num: 100, page: 1 },\n      enhancers,\n      debug: false,\n    });\n    return result.rows;\n  }\n\n  async findActiveByProvider<T extends TokenSubsetKey>(\n    subset: T,\n    provider: string,\n  ): Promise<TokenSubsetMapping[T][]> {\n    const { qb } = this.getSubsetQueries(subset);\n    qb.where(\"tokens.active\", true);\n    qb.where(\"tokens.provider\", provider);\n    const enhancers = this.createEnhancers({ A: (row) => ({ ...row }) });\n    const result = await this.executeSubsetQuery({\n      subset,\n      qb,\n      params: { num: 100, page: 1 },\n      enhancers,\n      debug: false,\n    });\n    return result.rows;\n  }\n\n  async findActiveByProviderAndName<T extends TokenSubsetKey>(\n    subset: T,\n    provider: string,\n    name: string,\n  ): Promise<TokenSubsetMapping[T] | undefined> {\n    const { qb } = this.getSubsetQueries(subset);\n    qb.where(\"tokens.active\", true);\n    qb.where(\"tokens.provider\", provider);\n    qb.where(\"tokens.name\", name);\n    const enhancers = this.createEnhancers({ A: (row) => ({ ...row }) });\n    const result = await this.executeSubsetQuery({\n      subset,\n      qb,\n      params: { num: 1, page: 1 },\n      enhancers,\n      debug: false,\n    });\n    return result.rows[0];\n  }\n\n  /** 실제 인증 만료가 확인돼 재로그인이 필요한 토큰들. 수동 비활성화는 제외한다. */\n  async findReauthRequired<T extends TokenSubsetKey>(subset: T): Promise<TokenSubsetMapping[T][]> {\n    const { qb } = this.getSubsetQueries(subset);\n    qb.where(\"tokens.reauth_required\", true);\n    qb.orderBy(\"tokens.name\", \"asc\");\n    const enhancers = this.createEnhancers({ A: (row) => ({ ...row }) });\n    const result = await this.executeSubsetQuery({\n      subset,\n      qb,\n      params: { num: 100, page: 1 },\n      enhancers,\n      debug: false,\n    });\n    return result.rows;\n  }\n\n  async findActive<T extends TokenSubsetKey>(subset: T): Promise<TokenSubsetMapping[T][]> {\n    const { qb } = this.getSubsetQueries(subset);\n    qb.where(\"tokens.active\", true);\n    const enhancers = this.createEnhancers({ A: (row) => ({ ...row }) });\n    const result = await this.executeSubsetQuery({\n      subset,\n      qb,\n      params: { num: 100, page: 1 },\n      enhancers,\n      debug: false,\n    });\n    return result.rows;\n  }\n\n  async save(spa: TokenSaveParams[]): Promise<number[]> {\n    const wdb = this.getPuri(\"w\");\n    spa.forEach((sp) => {\n      wdb.ubRegister(\"tokens\", applyCreateDefaults(sp));\n    });\n    return wdb.transaction(async (trx) => {\n      return trx.ubUpsert(\"tokens\");\n    });\n  }\n\n  async updateFields(id: number, fields: TokenUpdateFields): Promise<number> {\n    const wdb = this.getPuri(\"w\");\n    return wdb.transaction((trx) => trx.table(\"tokens\").where(\"id\", id).update(fields));\n  }\n\n  async toggleActive(id: number): Promise<{ active: boolean; reauthRequired: boolean } | null> {\n    const wdb = this.getPuri(\"w\");\n    return wdb.transaction(async (trx) => {\n      const token = await trx\n        .from(\"tokens\")\n        .select({ active: \"active\", reauth_required: \"reauth_required\" })\n        .where(\"id\", id)\n        .forUpdate()\n        .first();\n      if (!token) return null;\n      if (!token.active && token.reauth_required) {\n        return { active: false, reauthRequired: true };\n      }\n\n      const active = !token.active;\n      await trx.from(\"tokens\").where(\"id\", id).update({ active });\n      return { active, reauthRequired: false };\n    });\n  }\n\n  /**\n   * 같은 계정의 기존 토큰을 지우고 새로 저장한다(로그인·재로그인 공통 경로).\n   *\n   * provider 응답에 계정 식별자가 없으면 dedup 자체가 불가능하므로 경고만 남기고\n   * 중복 제거 없이 저장한다(죽은 row 가 남는다).\n   */\n  async replaceByAccount(\n    provider: string,\n    accountId: string | undefined,\n    saveParams: TokenSaveParams,\n  ): Promise<void> {\n    let keepaliveEnabled = saveParams.keepalive_enabled;\n    if (accountId) {\n      const oldEntries = await this.findByAccountIdentifier(\"A\", provider, accountId);\n      if (keepaliveEnabled === undefined && oldEntries.length > 0) {\n        keepaliveEnabled = oldEntries.some((entry) => entry.keepalive_enabled);\n      }\n      if (oldEntries.length > 0) await this.del(oldEntries.map((o) => o.id));\n    } else {\n      logger.warn(\n        `${provider} login without account identifier: dedup skipped for ${saveParams.name ?? \"unnamed\"}`,\n      );\n    }\n\n    await this.save([\n      keepaliveEnabled === undefined\n        ? saveParams\n        : { ...saveParams, keepalive_enabled: keepaliveEnabled },\n    ]);\n  }\n\n  /**\n   * Record confirmed expiry and remove the token from routing atomically.\n   * The last active token is also deactivated; its notification is urgent.\n   */\n  async markReauthRequired(\n    id: number,\n    expectedCredentials: TokenCredentials,\n  ): Promise<{ marked: boolean; wasLastActive: boolean; staleCredentials: boolean }> {\n    const wdb = this.getPuri(\"w\");\n    return wdb.transaction(async (trx) => {\n      const token = await trx\n        .from(\"tokens\")\n        .select({\n          provider: \"provider\",\n          credentials: \"credentials\",\n          reauth_required: \"reauth_required\",\n        })\n        .where(\"id\", id)\n        .forUpdate()\n        .first();\n      if (!token || token.reauth_required) {\n        return { marked: false, wasLastActive: false, staleCredentials: false };\n      }\n      if (!isDeepStrictEqual(token.credentials, expectedCredentials)) {\n        return { marked: false, wasLastActive: false, staleCredentials: true };\n      }\n\n      await trx.knex.raw(\"SELECT pg_advisory_xact_lock(?, hashtext(?))\", [\n        TOKEN_AUTH_DEATH_LOCK_CLASS_ID,\n        token.provider,\n      ]);\n      const updated = await trx.knex.raw<{ rows: { was_last_active: boolean }[] }>(\n        `WITH previous AS (\n           SELECT active AND NOT EXISTS (\n             SELECT 1 FROM tokens peer\n             WHERE peer.provider = tokens.provider AND peer.active\n               AND NOT peer.reauth_required AND peer.id <> tokens.id\n           ) AS was_last_active FROM tokens WHERE id = ?\n         )\n         UPDATE tokens\n         SET reauth_required = true,\n             active = false\n         WHERE id = ? AND reauth_required = false\n         RETURNING (SELECT was_last_active FROM previous) AS was_last_active`,\n        [id, id],\n      );\n      const marked = updated.rows[0];\n      if (!marked) return { marked: false, wasLastActive: false, staleCredentials: false };\n\n      if (marked.was_last_active) {\n        logger.error(`deactivated expired token ${id}: no usable provider tokens remain`);\n      }\n      return { marked: true, wasLastActive: marked.was_last_active, staleCredentials: false };\n    });\n  }\n\n  /** Repair rows retained by the former last-active exception before pool reconciliation. */\n  async deactivateExpiredTokens(): Promise<void> {\n    await this.getPuri(\"w\")\n      .table(\"tokens\")\n      .where(\"reauth_required\", true)\n      .where(\"active\", true)\n      .update({ active: false });\n  }\n\n  @api({ httpMethod: \"POST\", clients: [\"axios\", \"tanstack-mutation\"] })\n  async reorder(ids: number[]): Promise<{ done: boolean }> {\n    const wdb = this.getPuri(\"w\");\n    await wdb.transaction(async (trx) => {\n      for (let i = 0; i < ids.length; i++) {\n        await trx.table(\"tokens\").where(\"id\", ids[i]!).update({ ord: i });\n      }\n    });\n    return { done: true };\n  }\n\n  @api({ httpMethod: \"POST\", clients: [\"axios\", \"tanstack-mutation\"] })\n  async del(ids: number[]): Promise<number> {\n    const wdb = this.getPuri(\"w\");\n    await wdb.transaction(async (trx) => {\n      return trx.table(\"tokens\").whereIn(\"tokens.id\", ids).delete();\n    });\n    return ids.length;\n  }\n}\n\nexport const TokenModel = new TokenModelClass();\n"],"mappings":"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"}

package/bundle/dist/utils/providers/common/model-cost.js

@@ -6,28 +6,36 @@ const LONG_CONTEXT_272K = {
 	outputMultiplier: 1.5
 };
 const OPENAI_COSTS = {
+	"gpt-6-astra": {
+		maxEffort: "ultra",
+		inputTokens: 10,
+		outputTokens: 50,
+		cachedInputTokens: 1,
+		cacheCreationInputTokens: 12.5,
+		longContext: LONG_CONTEXT_272K
+	},
 	"gpt-5.6-sol": {
 		maxEffort: "ultra",
-		inputTokens: 5,
-		outputTokens: 30,
-		cachedInputTokens: .5,
-		cacheCreationInputTokens: 6.25,
+		inputTokens: 4,
+		outputTokens: 20,
+		cachedInputTokens: .4,
+		cacheCreationInputTokens: 5,
 		longContext: LONG_CONTEXT_272K
 	},
 	"gpt-5.6-terra": {
 		maxEffort: "ultra",
-		inputTokens: 2.5,
-		outputTokens: 15,
-		cachedInputTokens: .25,
-		cacheCreationInputTokens: 3.125,
+		inputTokens: 2,
+		outputTokens: 12,
+		cachedInputTokens: .2,
+		cacheCreationInputTokens: 2.5,
 		longContext: LONG_CONTEXT_272K
 	},
 	"gpt-5.6-luna": {
 		maxEffort: "max",
-		inputTokens: 1,
-		outputTokens: 6,
-		cachedInputTokens: .1,
-		cacheCreationInputTokens: 1.25,
+		inputTokens: .2,
+		outputTokens: 1.2,
+		cachedInputTokens: .02,
+		cacheCreationInputTokens: .25,
 		longContext: LONG_CONTEXT_272K
 	},
 	"gpt-5.5": {
@@ -125,4 +133,4 @@ function calculateCostUsd(model, usage) {
 //#endregion
 export { calculateCostUsd, getModelCosts, openaiModelMaxEffort };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"model-cost.js","names":[],"sources":["../../../../src/utils/providers/common/model-cost.ts"],"sourcesContent":["/**\n * 모델별 토큰 가격 테이블 + cost 계산.\n *\n * claude code 와 동일 패턴: 클라이언트에서 가격 테이블로 직접 계산.\n * 가격 단위: USD per 1M tokens.\n *\n * OpenAI 모델 목록은 OpenAI 모델 문서와 현재 지원 목록을 기준으로 관리한다.\n *\n * @see https://platform.openai.com/docs/pricing\n * @see https://platform.claude.com/docs/en/about-claude/pricing\n */\n\nimport { type OpenAIEffort } from \"./effort\";\n\nexport interface ModelCosts {\n  inputTokens: number;\n  outputTokens: number;\n  cachedInputTokens: number;\n  /** TTL breakdown 이 없는 usage 에 적용할 cache write fallback 단가. */\n  cacheCreationInputTokens?: number;\n  cacheCreationInputTokens5m?: number;\n  cacheCreationInputTokens1h?: number;\n  /**\n   * long-context 할증. 전체 입력 토큰(input_tokens, cache_read 포함)이 threshold 초과 시\n   * 초과분만이 아니라 요청 전체(full session)에 배율 적용.\n   */\n  longContext?: {\n    threshold: number;\n    inputMultiplier: number;\n    cachedInputMultiplier: number;\n    outputMultiplier: number;\n  };\n}\n\n// ── OpenAI ─────────────────────────────────────────────────────────\n//\n// 가격 출처: https://developers.openai.com/api/docs/models (2026-07-18 확인)\n// 신모델 출시마다 단가가 바뀌므로(5.2→5.4→5.5) 모델 추가 시 반드시 공식 페이지 재확인해야함\n\n// GPT-5.4에서 처음 도입된 long-context 할증 (5.2/5.3-codex는 해당 없음, 5.4-mini/nano는 공식 표에서 long-context 단가 없음)\n// 272K 초과 시 input 2x / cached 2x / output 1.5x — 초과분만이 아닌 세션 전체에 적용됨\n// @see https://developers.openai.com/api/docs/models/gpt-5.5 (\"prompts with >272K input tokens\")\nconst LONG_CONTEXT_272K: NonNullable<ModelCosts[\"longContext\"]> = {\n  threshold: 272_000,\n  inputMultiplier: 2,\n  cachedInputMultiplier: 2,\n  outputMultiplier: 1.5,\n};\n\n// OpenAI 모델 카탈로그. 단가와 함께 Codex 백엔드가 모델별로 받는 최대 reasoning effort 를 한 곳에 둔다.\n// maxEffort 출처: ~/.codex/models_cache.json 의 supported_reasoning_levels (2026-09-02 확인).\n// 미기재 모델은 xhigh 까지만 받는다.\ntype OpenAIModelSpec = ModelCosts & { maxEffort?: OpenAIEffort };\n\nconst OPENAI_COSTS: Record<string, OpenAIModelSpec> = {\n  // GPT-5.6 Sol, Terra, Luna. cache write 단가는 외부 logger/manual usage 입력을 위해\n  // 유지한다. 현재 OpenAI 응답 usage 에 cache write 토큰 필드가 없으면 비용은 0으로 계산된다.\n  // @see https://developers.openai.com/api/docs/models/gpt-5.6-sol\n  // @see https://developers.openai.com/api/docs/models/gpt-5.6-terra\n  // @see https://developers.openai.com/api/docs/models/gpt-5.6-luna\n  \"gpt-5.6-sol\": {\n    maxEffort: \"ultra\",\n    inputTokens: 5,\n    outputTokens: 30,\n    cachedInputTokens: 0.5,\n    cacheCreationInputTokens: 6.25,\n    longContext: LONG_CONTEXT_272K,\n  },\n  \"gpt-5.6-terra\": {\n    maxEffort: \"ultra\",\n    inputTokens: 2.5,\n    outputTokens: 15,\n    cachedInputTokens: 0.25,\n    cacheCreationInputTokens: 3.125,\n    longContext: LONG_CONTEXT_272K,\n  },\n  \"gpt-5.6-luna\": {\n    maxEffort: \"max\",\n    inputTokens: 1,\n    outputTokens: 6,\n    cachedInputTokens: 0.1,\n    cacheCreationInputTokens: 1.25,\n    longContext: LONG_CONTEXT_272K,\n  },\n  // https://openai.com/index/introducing-gpt-5-5/ (2026-04 출시)\n  \"gpt-5.5\": {\n    inputTokens: 5,\n    outputTokens: 30,\n    cachedInputTokens: 0.5,\n    longContext: LONG_CONTEXT_272K,\n  },\n  // 아래 gpt-5.4 / gpt-5.4-mini / gpt-5.3-codex / gpt-5.2 는 qgrid 가 쓰는 ChatGPT 구독 Codex 경로에서\n  // 더 이상 제공되지 않는다(5.4 계열은 2026-08-31 retired, 대체 gpt-5.6-terra / gpt-5.6-luna).\n  // 과거 request log 재산정(cost_source 없는 legacy 행)에 필요하므로 단가 행은 유지한다.\n  // https://openai.com/index/introducing-gpt-5-4/ (2026-03 출시)\n  \"gpt-5.4\": {\n    inputTokens: 2.5,\n    outputTokens: 15,\n    cachedInputTokens: 0.25,\n    longContext: LONG_CONTEXT_272K,\n  },\n  \"gpt-5.4-mini\": { inputTokens: 0.75, outputTokens: 4.5, cachedInputTokens: 0.075 },\n  // gpt-5.2와 동일 단가 (cached = input의 10%)\n  \"gpt-5.3-codex\": { inputTokens: 1.75, outputTokens: 14, cachedInputTokens: 0.175 },\n  // https://openai.com/index/introducing-gpt-5-2/ (cached input 90% 할인 명시)\n  \"gpt-5.2\": { inputTokens: 1.75, outputTokens: 14, cachedInputTokens: 0.175 },\n};\n\n// ── Anthropic ───────────────────────────────────────────────────────\n\nfunction anthropicCosts(\n  inputTokens: number,\n  outputTokens: number,\n  overrides: Pick<Partial<ModelCosts>, \"cachedInputTokens\"> = {},\n): ModelCosts {\n  return {\n    inputTokens,\n    outputTokens,\n    // 표준 cache read 는 base input 의 0.1x. Fable 5.1 처럼 공식 특례 단가가 있으면 override 한다.\n    cachedInputTokens: overrides.cachedInputTokens ?? inputTokens / 10,\n    // Claude Code subscription OAuth 는 1h TTL 을 자동 선택한다. 구버전처럼 응답에\n    // TTL breakdown 이 없을 때만 이 1h 단가를 fallback 으로 사용한다.\n    cacheCreationInputTokens: inputTokens * 2,\n    cacheCreationInputTokens5m: inputTokens * 1.25,\n    cacheCreationInputTokens1h: inputTokens * 2,\n  };\n}\n\n// 가격 출처: https://platform.claude.com/docs/en/about-claude/pricing (2026-09-02 확인)\nconst ANTHROPIC_COSTS: Record<string, ModelCosts> = {\n  // Fable 5.1 (2026-09-01 출시): input/output 은 Fable 5 와 같고 cache read 만 0.025x($0.25) 특례.\n  // @see https://platform.claude.com/docs/en/models/fable-5-1/overview\n  \"claude-fable-5-1\": anthropicCosts(10, 50, { cachedInputTokens: 0.25 }),\n  \"claude-fable-5\": anthropicCosts(10, 50),\n  sonnet: anthropicCosts(3, 15),\n  \"claude-3-5-haiku\": anthropicCosts(0.8, 4),\n  \"claude-haiku-4-5\": anthropicCosts(1, 5),\n  \"claude-3-5-sonnet\": anthropicCosts(3, 15),\n  \"claude-3-7-sonnet\": anthropicCosts(3, 15),\n  \"claude-sonnet-4\": anthropicCosts(3, 15),\n  \"claude-sonnet-4-5\": anthropicCosts(3, 15),\n  \"claude-sonnet-4-6\": anthropicCosts(3, 15),\n  \"claude-sonnet-4-7\": anthropicCosts(3, 15),\n  \"claude-opus-4\": anthropicCosts(15, 75),\n  \"claude-opus-4-1\": anthropicCosts(15, 75),\n  \"claude-opus-4-5\": anthropicCosts(5, 25),\n  \"claude-opus-4-6\": anthropicCosts(5, 25),\n  \"claude-opus-4-7\": anthropicCosts(5, 25),\n  \"claude-opus-4-8\": anthropicCosts(5, 25),\n  \"claude-opus-5\": anthropicCosts(5, 25),\n  // Sonnet 5 의 introductory $2/$10 이 정식 단가로 확정됐다. 2026-09-01 에 예정됐던 $3/$15 인상은\n  // 취소됐으므로 날짜 분기 없이 고정 단가로 계산한다.\n  \"claude-sonnet-5\": anthropicCosts(2, 10),\n};\n\n// gpt-5.3-codex-spark 는 research preview 로 공식 token 단가가 아직 final 이 아니다.\n// 지원 타입은 유지하되, 공식 단가가 공개될 때까지 아래 generic estimate 로 계산한다.\n// @see https://help.openai.com/en/articles/20001106-codex-rate-card\nconst DEFAULT_COSTS: ModelCosts = { inputTokens: 3, outputTokens: 15, cachedInputTokens: 0.3 };\n\n/** Codex 백엔드가 이 모델에 허용하는 최대 effort. 카탈로그에 없는 모델은 xhigh 까지다. */\nexport function openaiModelMaxEffort(model: string): OpenAIEffort {\n  return OPENAI_COSTS[model]?.maxEffort ?? \"xhigh\";\n}\n\nexport function getModelCosts(model: string): ModelCosts {\n  const normalizedModel = (model.split(\"/\").pop() ?? model).replace(/\\[1m\\]$/i, \"\");\n  return OPENAI_COSTS[normalizedModel] ?? ANTHROPIC_COSTS[normalizedModel] ?? DEFAULT_COSTS;\n}\n\nexport function calculateCostUsd(\n  model: string,\n  usage: {\n    inputTokens: number;\n    outputTokens: number;\n    cachedInputTokens?: number;\n    cacheCreationInputTokens?: number;\n    cacheCreationInputTokens5m?: number;\n    cacheCreationInputTokens1h?: number;\n  },\n): number {\n  const costs = getModelCosts(model);\n  const cachedInput = usage.cachedInputTokens ?? 0;\n  const cacheCreationInput5m = Math.max(usage.cacheCreationInputTokens5m ?? 0, 0);\n  const cacheCreationInput1h = Math.max(usage.cacheCreationInputTokens1h ?? 0, 0);\n  const cacheCreationInput = Math.max(\n    usage.cacheCreationInputTokens ?? 0,\n    cacheCreationInput5m + cacheCreationInput1h,\n  );\n  const classifiedCacheCreationInput5m = Math.min(cacheCreationInput5m, cacheCreationInput);\n  const classifiedCacheCreationInput1h = Math.min(\n    cacheCreationInput1h,\n    cacheCreationInput - classifiedCacheCreationInput5m,\n  );\n  const unclassifiedCacheCreationInput =\n    cacheCreationInput - classifiedCacheCreationInput5m - classifiedCacheCreationInput1h;\n  const nonCachedInput = Math.max(usage.inputTokens - cachedInput - cacheCreationInput, 0);\n\n  // long-context 할증: 전체 입력(input_tokens, cache 포함)이 threshold 초과 시 요청 전체에 배율 적용\n  const lc = costs.longContext;\n  const isLongContext = lc !== undefined && usage.inputTokens > lc.threshold;\n  const inputRate = costs.inputTokens * (isLongContext ? lc.inputMultiplier : 1);\n  const cachedRate = costs.cachedInputTokens * (isLongContext ? lc.cachedInputMultiplier : 1);\n  const cacheCreationFallbackRate =\n    (costs.cacheCreationInputTokens ?? costs.inputTokens) *\n    (isLongContext ? lc.inputMultiplier : 1);\n  const cacheCreation5mRate =\n    (costs.cacheCreationInputTokens5m ?? costs.cacheCreationInputTokens ?? costs.inputTokens) *\n    (isLongContext ? lc.inputMultiplier : 1);\n  const cacheCreation1hRate =\n    (costs.cacheCreationInputTokens1h ?? costs.cacheCreationInputTokens ?? costs.inputTokens) *\n    (isLongContext ? lc.inputMultiplier : 1);\n  const outputRate = costs.outputTokens * (isLongContext ? lc.outputMultiplier : 1);\n\n  return (\n    (nonCachedInput / 1_000_000) * inputRate +\n    (usage.outputTokens / 1_000_000) * outputRate +\n    (cachedInput / 1_000_000) * cachedRate +\n    (unclassifiedCacheCreationInput / 1_000_000) * cacheCreationFallbackRate +\n    (classifiedCacheCreationInput5m / 1_000_000) * cacheCreation5mRate +\n    (classifiedCacheCreationInput1h / 1_000_000) * cacheCreation1hRate\n  );\n}\n"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"model-cost.js","names":[],"sources":["../../../../src/utils/providers/common/model-cost.ts"],"sourcesContent":["/**\n * 모델별 토큰 가격 테이블 + cost 계산.\n *\n * claude code 와 동일 패턴: 클라이언트에서 가격 테이블로 직접 계산.\n * 가격 단위: USD per 1M tokens.\n *\n * OpenAI 모델 목록은 OpenAI 모델 문서와 현재 지원 목록을 기준으로 관리한다.\n *\n * @see https://platform.openai.com/docs/pricing\n * @see https://platform.claude.com/docs/en/about-claude/pricing\n */\n\nimport { type OpenAIEffort } from \"./effort\";\n\nexport interface ModelCosts {\n  inputTokens: number;\n  outputTokens: number;\n  cachedInputTokens: number;\n  /** TTL breakdown 이 없는 usage 에 적용할 cache write fallback 단가. */\n  cacheCreationInputTokens?: number;\n  cacheCreationInputTokens5m?: number;\n  cacheCreationInputTokens1h?: number;\n  /**\n   * long-context 할증. 전체 입력 토큰(input_tokens, cache_read 포함)이 threshold 초과 시\n   * 초과분만이 아니라 요청 전체(full session)에 배율 적용.\n   */\n  longContext?: {\n    threshold: number;\n    inputMultiplier: number;\n    cachedInputMultiplier: number;\n    outputMultiplier: number;\n  };\n}\n\n// ── OpenAI ─────────────────────────────────────────────────────────\n//\n// Standard pricing verified 2026-09-07: https://developers.openai.com/api/docs/pricing\n// 신모델 출시마다 단가가 바뀌므로(5.2→5.4→5.5) 모델 추가 시 반드시 공식 페이지 재확인해야함\n\n// GPT-5.4에서 처음 도입된 long-context 할증 (5.2/5.3-codex는 해당 없음, 5.4-mini/nano는 공식 표에서 long-context 단가 없음)\n// 272K 초과 시 input 2x / cached 2x / output 1.5x — 초과분만이 아닌 세션 전체에 적용됨\n// @see https://developers.openai.com/api/docs/models/gpt-5.5 (\"prompts with >272K input tokens\")\nconst LONG_CONTEXT_272K: NonNullable<ModelCosts[\"longContext\"]> = {\n  threshold: 272_000,\n  inputMultiplier: 2,\n  cachedInputMultiplier: 2,\n  outputMultiplier: 1.5,\n};\n\n// OpenAI 모델 카탈로그. 단가와 함께 Codex 백엔드가 모델별로 받는 최대 reasoning effort 를 한 곳에 둔다.\n// maxEffort 출처: ~/.codex/models_cache.json 의 supported_reasoning_levels (2026-09-07 확인).\n// 미기재 모델은 xhigh 까지만 받는다.\ntype OpenAIModelSpec = ModelCosts & { maxEffort?: OpenAIEffort };\n\nconst OPENAI_COSTS: Record<string, OpenAIModelSpec> = {\n  // GPT-6 Astra: Standard API-equivalent pricing, verified 2026-09-07.\n  // Codex subscription catalog supports ultra; the public API lists only through max.\n  // @see https://developers.openai.com/api/docs/models/gpt-6-astra\n  // @see https://developers.openai.com/api/docs/pricing\n  \"gpt-6-astra\": {\n    maxEffort: \"ultra\",\n    inputTokens: 10,\n    outputTokens: 50,\n    cachedInputTokens: 1,\n    cacheCreationInputTokens: 12.5,\n    longContext: LONG_CONTEXT_272K,\n  },\n  // GPT-5.6 Sol, Terra, Luna. cache write 단가는 외부 logger/manual usage 입력을 위해\n  // 유지한다. 현재 OpenAI 응답 usage 에 cache write 토큰 필드가 없으면 비용은 0으로 계산된다.\n  // @see https://developers.openai.com/api/docs/models/gpt-5.6-sol\n  // @see https://developers.openai.com/api/docs/models/gpt-5.6-terra\n  // @see https://developers.openai.com/api/docs/models/gpt-5.6-luna\n  // Sol promotional rates are available at least through 2026-11-21.\n  // No confirmed end date/replacement rate: recheck official pricing instead of auto-reverting.\n  \"gpt-5.6-sol\": {\n    maxEffort: \"ultra\",\n    inputTokens: 4,\n    outputTokens: 20,\n    cachedInputTokens: 0.4,\n    cacheCreationInputTokens: 5,\n    longContext: LONG_CONTEXT_272K,\n  },\n  \"gpt-5.6-terra\": {\n    maxEffort: \"ultra\",\n    inputTokens: 2,\n    outputTokens: 12,\n    cachedInputTokens: 0.2,\n    cacheCreationInputTokens: 2.5,\n    longContext: LONG_CONTEXT_272K,\n  },\n  \"gpt-5.6-luna\": {\n    maxEffort: \"max\",\n    inputTokens: 0.2,\n    outputTokens: 1.2,\n    cachedInputTokens: 0.02,\n    cacheCreationInputTokens: 0.25,\n    longContext: LONG_CONTEXT_272K,\n  },\n  // https://openai.com/index/introducing-gpt-5-5/ (2026-04 출시)\n  \"gpt-5.5\": {\n    inputTokens: 5,\n    outputTokens: 30,\n    cachedInputTokens: 0.5,\n    longContext: LONG_CONTEXT_272K,\n  },\n  // 아래 gpt-5.4 / gpt-5.4-mini / gpt-5.3-codex / gpt-5.2 는 qgrid 가 쓰는 ChatGPT 구독 Codex 경로에서\n  // 더 이상 제공되지 않는다(5.4 계열은 2026-08-31 retired, 대체 gpt-5.6-terra / gpt-5.6-luna).\n  // 과거 request log 재산정(cost_source 없는 legacy 행)에 필요하므로 단가 행은 유지한다.\n  // https://openai.com/index/introducing-gpt-5-4/ (2026-03 출시)\n  \"gpt-5.4\": {\n    inputTokens: 2.5,\n    outputTokens: 15,\n    cachedInputTokens: 0.25,\n    longContext: LONG_CONTEXT_272K,\n  },\n  \"gpt-5.4-mini\": { inputTokens: 0.75, outputTokens: 4.5, cachedInputTokens: 0.075 },\n  // gpt-5.2와 동일 단가 (cached = input의 10%)\n  \"gpt-5.3-codex\": { inputTokens: 1.75, outputTokens: 14, cachedInputTokens: 0.175 },\n  // https://openai.com/index/introducing-gpt-5-2/ (cached input 90% 할인 명시)\n  \"gpt-5.2\": { inputTokens: 1.75, outputTokens: 14, cachedInputTokens: 0.175 },\n};\n\n// ── Anthropic ───────────────────────────────────────────────────────\n\nfunction anthropicCosts(\n  inputTokens: number,\n  outputTokens: number,\n  overrides: Pick<Partial<ModelCosts>, \"cachedInputTokens\"> = {},\n): ModelCosts {\n  return {\n    inputTokens,\n    outputTokens,\n    // 표준 cache read 는 base input 의 0.1x. Fable 5.1 처럼 공식 특례 단가가 있으면 override 한다.\n    cachedInputTokens: overrides.cachedInputTokens ?? inputTokens / 10,\n    // Claude Code subscription OAuth 는 1h TTL 을 자동 선택한다. 구버전처럼 응답에\n    // TTL breakdown 이 없을 때만 이 1h 단가를 fallback 으로 사용한다.\n    cacheCreationInputTokens: inputTokens * 2,\n    cacheCreationInputTokens5m: inputTokens * 1.25,\n    cacheCreationInputTokens1h: inputTokens * 2,\n  };\n}\n\n// 가격 출처: https://platform.claude.com/docs/en/about-claude/pricing (2026-09-02 확인)\nconst ANTHROPIC_COSTS: Record<string, ModelCosts> = {\n  // Fable 5.1 (2026-09-01 출시): input/output 은 Fable 5 와 같고 cache read 만 0.025x($0.25) 특례.\n  // @see https://platform.claude.com/docs/en/models/fable-5-1/overview\n  \"claude-fable-5-1\": anthropicCosts(10, 50, { cachedInputTokens: 0.25 }),\n  \"claude-fable-5\": anthropicCosts(10, 50),\n  sonnet: anthropicCosts(3, 15),\n  \"claude-3-5-haiku\": anthropicCosts(0.8, 4),\n  \"claude-haiku-4-5\": anthropicCosts(1, 5),\n  \"claude-3-5-sonnet\": anthropicCosts(3, 15),\n  \"claude-3-7-sonnet\": anthropicCosts(3, 15),\n  \"claude-sonnet-4\": anthropicCosts(3, 15),\n  \"claude-sonnet-4-5\": anthropicCosts(3, 15),\n  \"claude-sonnet-4-6\": anthropicCosts(3, 15),\n  \"claude-sonnet-4-7\": anthropicCosts(3, 15),\n  \"claude-opus-4\": anthropicCosts(15, 75),\n  \"claude-opus-4-1\": anthropicCosts(15, 75),\n  \"claude-opus-4-5\": anthropicCosts(5, 25),\n  \"claude-opus-4-6\": anthropicCosts(5, 25),\n  \"claude-opus-4-7\": anthropicCosts(5, 25),\n  \"claude-opus-4-8\": anthropicCosts(5, 25),\n  \"claude-opus-5\": anthropicCosts(5, 25),\n  // Sonnet 5 의 introductory $2/$10 이 정식 단가로 확정됐다. 2026-09-01 에 예정됐던 $3/$15 인상은\n  // 취소됐으므로 날짜 분기 없이 고정 단가로 계산한다.\n  \"claude-sonnet-5\": anthropicCosts(2, 10),\n};\n\n// gpt-5.3-codex-spark 는 research preview 로 공식 token 단가가 아직 final 이 아니다.\n// 지원 타입은 유지하되, 공식 단가가 공개될 때까지 아래 generic estimate 로 계산한다.\n// @see https://help.openai.com/en/articles/20001106-codex-rate-card\nconst DEFAULT_COSTS: ModelCosts = { inputTokens: 3, outputTokens: 15, cachedInputTokens: 0.3 };\n\n/** Codex 백엔드가 이 모델에 허용하는 최대 effort. 카탈로그에 없는 모델은 xhigh 까지다. */\nexport function openaiModelMaxEffort(model: string): OpenAIEffort {\n  return OPENAI_COSTS[model]?.maxEffort ?? \"xhigh\";\n}\n\nexport function getModelCosts(model: string): ModelCosts {\n  const normalizedModel = (model.split(\"/\").pop() ?? model).replace(/\\[1m\\]$/i, \"\");\n  return OPENAI_COSTS[normalizedModel] ?? ANTHROPIC_COSTS[normalizedModel] ?? DEFAULT_COSTS;\n}\n\nexport function calculateCostUsd(\n  model: string,\n  usage: {\n    inputTokens: number;\n    outputTokens: number;\n    cachedInputTokens?: number;\n    cacheCreationInputTokens?: number;\n    cacheCreationInputTokens5m?: number;\n    cacheCreationInputTokens1h?: number;\n  },\n): number {\n  const costs = getModelCosts(model);\n  const cachedInput = usage.cachedInputTokens ?? 0;\n  const cacheCreationInput5m = Math.max(usage.cacheCreationInputTokens5m ?? 0, 0);\n  const cacheCreationInput1h = Math.max(usage.cacheCreationInputTokens1h ?? 0, 0);\n  const cacheCreationInput = Math.max(\n    usage.cacheCreationInputTokens ?? 0,\n    cacheCreationInput5m + cacheCreationInput1h,\n  );\n  const classifiedCacheCreationInput5m = Math.min(cacheCreationInput5m, cacheCreationInput);\n  const classifiedCacheCreationInput1h = Math.min(\n    cacheCreationInput1h,\n    cacheCreationInput - classifiedCacheCreationInput5m,\n  );\n  const unclassifiedCacheCreationInput =\n    cacheCreationInput - classifiedCacheCreationInput5m - classifiedCacheCreationInput1h;\n  const nonCachedInput = Math.max(usage.inputTokens - cachedInput - cacheCreationInput, 0);\n\n  // long-context 할증: 전체 입력(input_tokens, cache 포함)이 threshold 초과 시 요청 전체에 배율 적용\n  const lc = costs.longContext;\n  const isLongContext = lc !== undefined && usage.inputTokens > lc.threshold;\n  const inputRate = costs.inputTokens * (isLongContext ? lc.inputMultiplier : 1);\n  const cachedRate = costs.cachedInputTokens * (isLongContext ? lc.cachedInputMultiplier : 1);\n  const cacheCreationFallbackRate =\n    (costs.cacheCreationInputTokens ?? costs.inputTokens) *\n    (isLongContext ? lc.inputMultiplier : 1);\n  const cacheCreation5mRate =\n    (costs.cacheCreationInputTokens5m ?? costs.cacheCreationInputTokens ?? costs.inputTokens) *\n    (isLongContext ? lc.inputMultiplier : 1);\n  const cacheCreation1hRate =\n    (costs.cacheCreationInputTokens1h ?? costs.cacheCreationInputTokens ?? costs.inputTokens) *\n    (isLongContext ? lc.inputMultiplier : 1);\n  const outputRate = costs.outputTokens * (isLongContext ? lc.outputMultiplier : 1);\n\n  return (\n    (nonCachedInput / 1_000_000) * inputRate +\n    (usage.outputTokens / 1_000_000) * outputRate +\n    (cachedInput / 1_000_000) * cachedRate +\n    (unclassifiedCacheCreationInput / 1_000_000) * cacheCreationFallbackRate +\n    (classifiedCacheCreationInput5m / 1_000_000) * cacheCreation5mRate +\n    (classifiedCacheCreationInput1h / 1_000_000) * cacheCreation1hRate\n  );\n}\n"],"mappings":"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"}

package/bundle/src/application/qgrid/qgrid.frame.test.ts

@@ -1336,6 +1336,26 @@ describe("QgridFrame.usage", () => {
     getRateLimitsByTokenIdMock.mockReset();
   });
 
+  it("does not fetch usage for confirmed expired tokens", async () => {
+    findManyMock.mockResolvedValueOnce({
+      rows: [{ ...tokenEntry, provider: "openai", active: false, reauth_required: true }],
+    });
+    await expect(QgridFrame.usage(1)).resolves.toEqual({ error: "re-login required" });
+    expect(getRateLimitsByTokenIdMock).not.toHaveBeenCalled();
+  });
+
+  it("does not label transient refresh failures as expired sessions", async () => {
+    findManyMock.mockResolvedValueOnce({
+      rows: [{ ...tokenEntry, provider: "anthropic", credentials: {
+        accessToken: "access", refreshToken: "refresh", expiresAt: 0, accountUuid: "account",
+      } }],
+    });
+    vi.spyOn(QgridFrame, "refreshToken").mockRejectedValueOnce(new Error("network timeout"));
+    await expect(QgridFrame.usage(1)).resolves.toEqual({
+      error: "Token refresh failed; usage is unavailable",
+    });
+  });
+
   it("returns empty usage for inactive OpenAI tokens without asking for workers", async () => {
     findManyMock.mockResolvedValueOnce({
       rows: [

package/bundle/src/application/qgrid/qgrid.frame.ts

@@ -716,6 +716,7 @@ class QgridFrameClass extends BaseFrameClass {
       : allTokens.findLast((e) => e.active && e.provider === "anthropic");
 
     if (!entry) return { error: "NOT_FOUND" };
+    if (entry.reauth_required) return { error: "re-login required" };
 
     if (entry.provider === "openai") {
       if (!entry.active) {
@@ -759,7 +760,7 @@ class QgridFrameClass extends BaseFrameClass {
         accessToken = await this.refreshToken(entry);
       } catch (e) {
         oauthLogger.warn(`refresh failed for ${entry.name}: ${(e as Error).message}`);
-        return { error: "re-login required" };
+        return { error: "Token refresh failed; usage is unavailable" };
       }
     }
 
@@ -772,7 +773,7 @@ class QgridFrameClass extends BaseFrameClass {
         return convertAnthropicUsage(retried);
       } catch (e) {
         oauthLogger.warn(`refresh failed for ${entry.name}: ${(e as Error).message}`);
-        return { error: "re-login required" };
+        return { error: "Token refresh failed; usage is unavailable" };
       }
     }
     if (raw.error) return { error: raw.error };

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/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,
       });