@cartanova/qgrid-cli 2.7.5 → 2.7.7

package/bundle/src/application/qgrid/token-window-keepalive.test.ts

@@ -0,0 +1,244 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+import {
+  KEEPALIVE_MODEL,
+  KEEPALIVE_PROJECT_NAME,
+  POST_KEEPALIVE_USAGE_DELAY_MS,
+  rescheduleTokenWindowKeepalive,
+  startTokenWindowKeepalive,
+  stopTokenWindowKeepalive,
+  type TokenWindowKeepaliveDeps,
+} from "./token-window-keepalive";
+
+const NOW = Date.parse("2026-08-19T00:00:00.000Z");
+const FIVE_HOURS_MS = 5 * 60 * 60 * 1_000;
+
+function token(
+  id: number,
+  overrides: Partial<{
+    name: string;
+    provider: string;
+    active: boolean;
+    keepalive_enabled: boolean;
+  }> = {},
+) {
+  return {
+    id,
+    name: `anthropic/token-${id}`,
+    provider: "anthropic",
+    active: true,
+    keepalive_enabled: true,
+    ...overrides,
+  };
+}
+
+function usage(resetsAt: string | null) {
+  return {
+    provider: "anthropic",
+    fiveHour: { utilization: 0, resetsAt },
+    sevenDay: null,
+  };
+}
+
+function deps(overrides: Partial<TokenWindowKeepaliveDeps> = {}): TokenWindowKeepaliveDeps {
+  return {
+    findTokens: vi.fn(async () => [token(1)]),
+    readUsage: vi.fn(async () => usage(new Date(NOW + FIVE_HOURS_MS).toISOString())),
+    dispatch: vi.fn(async () => undefined),
+    readSetting: () => "true",
+    isRunnerEnabled: () => true,
+    now: () => Date.now(),
+    setTimer: (callback, delayMs) => setTimeout(callback, delayMs),
+    clearTimer: (handle) => clearTimeout(handle),
+    ...overrides,
+  };
+}
+
+describe("token window keepalive", () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+    vi.setSystemTime(NOW);
+  });
+
+  afterEach(() => {
+    stopTokenWindowKeepalive();
+    vi.useRealTimers();
+  });
+
+  it("resetsAt 이 없으면 지정 토큰·최저가 모델·전용 project label 로 즉시 발사한다", async () => {
+    const readUsage = vi
+      .fn()
+      .mockResolvedValueOnce(usage(null))
+      .mockResolvedValueOnce(usage(new Date(NOW + FIVE_HOURS_MS).toISOString()));
+    const dispatch = vi.fn(async () => undefined);
+
+    await startTokenWindowKeepalive(deps({ readUsage, dispatch }));
+
+    expect(dispatch).toHaveBeenCalledWith({
+      prompt: "Reply OK.",
+      model: KEEPALIVE_MODEL,
+      effort: "low",
+      projectName: KEEPALIVE_PROJECT_NAME,
+      preferredTokenId: 1,
+    });
+
+    await vi.advanceTimersByTimeAsync(POST_KEEPALIVE_USAGE_DELAY_MS);
+    expect(readUsage).toHaveBeenCalledTimes(2);
+    expect(dispatch).toHaveBeenCalledTimes(1);
+  });
+
+  it("resetsAt 이 과거면 즉시 발사한다", async () => {
+    const dispatch = vi.fn(async () => undefined);
+    await startTokenWindowKeepalive(
+      deps({
+        readUsage: vi.fn(async () => usage(new Date(NOW - 1).toISOString())),
+        dispatch,
+      }),
+    );
+
+    expect(dispatch).toHaveBeenCalledTimes(1);
+  });
+
+  it("resetsAt 이 미래면 그 시각 직후까지 발사하지 않는다", async () => {
+    const dispatch = vi.fn(async () => undefined);
+    await startTokenWindowKeepalive(
+      deps({
+        readUsage: vi.fn(async () => usage(new Date(NOW + 10_000).toISOString())),
+        dispatch,
+      }),
+    );
+
+    await vi.advanceTimersByTimeAsync(10_999);
+    expect(dispatch).not.toHaveBeenCalled();
+
+    await vi.advanceTimersByTimeAsync(1);
+    expect(dispatch).toHaveBeenCalledTimes(1);
+  });
+
+  it("비활성·비Anthropic·keepalive off 토큰은 대상에서 제외한다", async () => {
+    const readUsage = vi.fn(async () => usage(new Date(NOW + FIVE_HOURS_MS).toISOString()));
+    await startTokenWindowKeepalive(
+      deps({
+        findTokens: vi.fn(async () => [
+          token(1),
+          token(2, { provider: "openai" }),
+          token(3, { active: false }),
+          token(4, { keepalive_enabled: false }),
+        ]),
+        readUsage,
+      }),
+    );
+
+    expect(readUsage).toHaveBeenCalledTimes(1);
+    expect(readUsage).toHaveBeenCalledWith(1);
+  });
+
+  it("한 토큰의 usage 실패가 다른 토큰 예약을 막지 않는다", async () => {
+    const readUsage = vi.fn(async (tokenId: number) => {
+      if (tokenId === 1) throw new Error("usage unavailable");
+      return usage(new Date(NOW + FIVE_HOURS_MS).toISOString());
+    });
+
+    await expect(
+      startTokenWindowKeepalive(
+        deps({ findTokens: vi.fn(async () => [token(1), token(2)]), readUsage }),
+      ),
+    ).resolves.toBeUndefined();
+
+    expect(readUsage).toHaveBeenCalledTimes(2);
+    expect(vi.getTimerCount()).toBe(2);
+  });
+
+  it("발사 실패는 밖으로 전파하지 않고 5시간 안에 재시도하지 않는다", async () => {
+    const dispatch = vi.fn(async () => {
+      throw new Error("provider unavailable");
+    });
+
+    await expect(
+      startTokenWindowKeepalive(
+        deps({ readUsage: vi.fn(async () => usage(null)), dispatch }),
+      ),
+    ).resolves.toBeUndefined();
+
+    expect(dispatch).toHaveBeenCalledTimes(1);
+    await vi.advanceTimersByTimeAsync(FIVE_HOURS_MS - 1);
+    expect(dispatch).toHaveBeenCalledTimes(1);
+  });
+
+  it("발사 뒤 usage 에 아직 새 윈도우가 안 보여도 즉시 다시 발사하지 않는다", async () => {
+    const dispatch = vi.fn(async () => undefined);
+    await startTokenWindowKeepalive(
+      deps({ readUsage: vi.fn(async () => usage(null)), dispatch }),
+    );
+
+    await vi.advanceTimersByTimeAsync(POST_KEEPALIVE_USAGE_DELAY_MS);
+
+    expect(dispatch).toHaveBeenCalledTimes(1);
+    expect(vi.getTimerCount()).toBe(1);
+  });
+
+  it("발사 후 61초 대기 중 재스케줄되어도 같은 토큰을 다시 발사하지 않는다", async () => {
+    const readUsage = vi
+      .fn()
+      .mockResolvedValueOnce(usage(null))
+      .mockResolvedValueOnce(usage(new Date(NOW + FIVE_HOURS_MS).toISOString()));
+    const dispatch = vi.fn(async () => undefined);
+    const testDeps = deps({ readUsage, dispatch });
+
+    await startTokenWindowKeepalive(testDeps);
+    await rescheduleTokenWindowKeepalive(testDeps);
+
+    expect(dispatch).toHaveBeenCalledTimes(1);
+    expect(readUsage).toHaveBeenCalledTimes(1);
+
+    await vi.advanceTimersByTimeAsync(POST_KEEPALIVE_USAGE_DELAY_MS);
+    expect(dispatch).toHaveBeenCalledTimes(1);
+    expect(readUsage).toHaveBeenCalledTimes(2);
+  });
+
+  it("발사 실패 후 재스케줄되어도 5시간 안에 다시 발사하지 않는다", async () => {
+    const dispatch = vi.fn(async () => {
+      throw new Error("provider unavailable");
+    });
+    const testDeps = deps({ readUsage: vi.fn(async () => usage(null)), dispatch });
+
+    await startTokenWindowKeepalive(testDeps);
+    await rescheduleTokenWindowKeepalive(testDeps);
+    await vi.advanceTimersByTimeAsync(FIVE_HOURS_MS - 1);
+
+    expect(dispatch).toHaveBeenCalledTimes(1);
+  });
+
+  it("스위치가 꺼져 있으면 조회나 타이머를 시작하지 않는다", async () => {
+    const testDeps = deps({ readSetting: () => "false" });
+
+    await startTokenWindowKeepalive(testDeps);
+
+    expect(testDeps.findTokens).not.toHaveBeenCalled();
+    expect(testDeps.readUsage).not.toHaveBeenCalled();
+    expect(vi.getTimerCount()).toBe(0);
+  });
+
+  it("이 인스턴스가 runner로 지정되지 않으면 전역 스위치와 무관하게 시작하지 않는다", async () => {
+    const testDeps = deps({
+      isRunnerEnabled: () => false,
+      readSetting: vi.fn(() => "true"),
+    });
+
+    await startTokenWindowKeepalive(testDeps);
+
+    expect(testDeps.findTokens).not.toHaveBeenCalled();
+    expect(testDeps.readSetting).not.toHaveBeenCalled();
+    expect(vi.getTimerCount()).toBe(0);
+  });
+
+  it("실행 중 스위치를 끄고 재예약하면 기존 타이머를 정리한다", async () => {
+    const testDeps = deps();
+    await startTokenWindowKeepalive(testDeps);
+    expect(vi.getTimerCount()).toBe(1);
+
+    await rescheduleTokenWindowKeepalive({ ...testDeps, readSetting: () => "false" });
+
+    expect(vi.getTimerCount()).toBe(0);
+  });
+});

package/bundle/src/application/qgrid/token-window-keepalive.ts

@@ -0,0 +1,237 @@
+import { getLogger } from "@logtape/logtape";
+
+import { TOKEN_WINDOW_KEEPALIVE_RUNNER_ENV_KEY } from "../setting/setting.constant";
+import { getSetting } from "../setting/setting.store";
+import { TokenModel } from "../token/token.model";
+import { type InternalQueryInput } from "./qgrid.dispatcher";
+import { QgridFrame } from "./qgrid.frame";
+import { type UsageResponse } from "./qgrid.types";
+
+const logger = getLogger(["qgrid", "token-window-keepalive"]);
+
+const FIVE_HOURS_MS = 5 * 60 * 60 * 1_000;
+const RESET_GRACE_MS = 1_000;
+
+// usage API 성공 응답은 1분 캐시된다. keepalive 직후 즉시 재조회하면 이전 윈도우를
+// 다시 보므로 캐시가 지난 뒤 한 번 확인하고, 그때도 새 윈도우가 없으면 다음 5h까지 기다린다.
+export const POST_KEEPALIVE_USAGE_DELAY_MS = 61_000;
+export const KEEPALIVE_MODEL = "anthropic/claude-haiku-4-5";
+export const KEEPALIVE_PROJECT_NAME = "qgrid-token-window-keepalive";
+export const KEEPALIVE_SETTING_KEY = "qgrid.tokenWindowKeepaliveEnabled";
+export const KEEPALIVE_ENV_KEY = TOKEN_WINDOW_KEEPALIVE_RUNNER_ENV_KEY;
+
+type KeepaliveToken = {
+  id: number;
+  name: string;
+  provider: string;
+  active: boolean;
+  keepalive_enabled: boolean;
+};
+
+type TimerHandle = ReturnType<typeof setTimeout>;
+
+export type TokenWindowKeepaliveDeps = {
+  findTokens: () => Promise<KeepaliveToken[]>;
+  readUsage: (tokenId: number) => Promise<UsageResponse>;
+  dispatch: (input: InternalQueryInput) => Promise<unknown>;
+  readSetting: typeof getSetting;
+  isRunnerEnabled: () => boolean;
+  now: () => number;
+  setTimer: (callback: () => void, delayMs: number) => TimerHandle;
+  clearTimer: (handle: TimerHandle) => void;
+};
+
+const defaultDeps: TokenWindowKeepaliveDeps = {
+  findTokens: () => TokenModel.findActiveByProvider("A", "anthropic"),
+  readUsage: (tokenId) => QgridFrame.usage(tokenId),
+  dispatch: (input) => QgridFrame.query(input),
+  readSetting: getSetting,
+  isRunnerEnabled: () => process.env[KEEPALIVE_ENV_KEY] === "true",
+  now: () => Date.now(),
+  setTimer: (callback, delayMs) => setTimeout(callback, delayMs),
+  clearTimer: (handle) => clearTimeout(handle),
+};
+
+const timers = new Map<number, { handle: TimerHandle; clear: (handle: TimerHandle) => void }>();
+const fireGuards = new Map<number, { untilMs: number; allowFireAtExpiry: boolean }>();
+let generation = 0;
+
+function clearTokenTimer(tokenId: number): void {
+  const timer = timers.get(tokenId);
+  if (!timer) return;
+  timer.clear(timer.handle);
+  timers.delete(tokenId);
+}
+
+function scheduleToken(
+  token: KeepaliveToken,
+  deps: TokenWindowKeepaliveDeps,
+  expectedGeneration: number,
+  delayMs: number,
+  allowFire: boolean,
+): void {
+  if (generation !== expectedGeneration) return;
+  clearTokenTimer(token.id);
+  const handle = deps.setTimer(
+    () => {
+      timers.delete(token.id);
+      if (generation !== expectedGeneration) return;
+      void inspectToken(token, deps, expectedGeneration, allowFire).catch((error) => {
+        logger.warn(`keepalive cycle failed for ${token.name}: ${(error as Error).message}`);
+        scheduleFallback(token, deps, expectedGeneration);
+      });
+    },
+    Math.max(0, delayMs),
+  );
+  timers.set(token.id, { handle, clear: deps.clearTimer });
+}
+
+function deferToken(
+  token: KeepaliveToken,
+  deps: TokenWindowKeepaliveDeps,
+  expectedGeneration: number,
+  delayMs: number,
+  allowFireAtExpiry: boolean,
+): void {
+  const untilMs = deps.now() + delayMs;
+  fireGuards.set(token.id, { untilMs, allowFireAtExpiry });
+  scheduleToken(token, deps, expectedGeneration, delayMs, allowFireAtExpiry);
+}
+
+function scheduleFallback(
+  token: KeepaliveToken,
+  deps: TokenWindowKeepaliveDeps,
+  expectedGeneration: number,
+): void {
+  deferToken(token, deps, expectedGeneration, FIVE_HOURS_MS, true);
+}
+
+async function inspectToken(
+  token: KeepaliveToken,
+  deps: TokenWindowKeepaliveDeps,
+  expectedGeneration: number,
+  allowFire: boolean,
+): Promise<void> {
+  const now = deps.now();
+  const guard = fireGuards.get(token.id);
+  if (guard && guard.untilMs > now) {
+    scheduleToken(token, deps, expectedGeneration, guard.untilMs - now, guard.allowFireAtExpiry);
+    return;
+  }
+  if (guard) fireGuards.delete(token.id);
+
+  let usage: UsageResponse;
+  try {
+    usage = await deps.readUsage(token.id);
+  } catch (error) {
+    logger.warn(`usage lookup failed for ${token.name}: ${(error as Error).message}`);
+    scheduleFallback(token, deps, expectedGeneration);
+    return;
+  }
+  if (generation !== expectedGeneration) return;
+
+  if (usage.error) {
+    logger.warn(`usage lookup failed for ${token.name}: ${usage.error}`);
+    scheduleFallback(token, deps, expectedGeneration);
+    return;
+  }
+
+  const resetsAt = usage.fiveHour?.resetsAt;
+  if (resetsAt) {
+    const resetMs = Date.parse(resetsAt);
+    if (!Number.isFinite(resetMs)) {
+      logger.warn(`invalid five-hour reset for ${token.name}: ${resetsAt}`);
+      scheduleFallback(token, deps, expectedGeneration);
+      return;
+    }
+    const inspectedAt = deps.now();
+    if (resetMs > inspectedAt) {
+      fireGuards.delete(token.id);
+      scheduleToken(token, deps, expectedGeneration, resetMs - inspectedAt + RESET_GRACE_MS, true);
+      return;
+    }
+  }
+
+  // 발사 직후 확인에서는 캐시된 null/과거 reset을 봐도 다시 발사하지 않는다.
+  if (!allowFire) {
+    scheduleFallback(token, deps, expectedGeneration);
+    return;
+  }
+
+  deferToken(token, deps, expectedGeneration, POST_KEEPALIVE_USAGE_DELAY_MS, false);
+  try {
+    await deps.dispatch({
+      prompt: "Reply OK.",
+      model: KEEPALIVE_MODEL,
+      effort: "low",
+      projectName: KEEPALIVE_PROJECT_NAME,
+      preferredTokenId: token.id,
+    });
+    logger.info(`keepalive sent for ${token.name}`);
+  } catch (error) {
+    logger.warn(`keepalive failed for ${token.name}: ${(error as Error).message}`);
+    scheduleFallback(token, deps, expectedGeneration);
+    return;
+  }
+
+  const postFireGuard = fireGuards.get(token.id);
+  if (postFireGuard) {
+    scheduleToken(
+      token,
+      deps,
+      expectedGeneration,
+      Math.max(0, postFireGuard.untilMs - deps.now()),
+      postFireGuard.allowFireAtExpiry,
+    );
+  }
+}
+
+function clearScheduledTimers(): void {
+  generation++;
+  for (const tokenId of timers.keys()) clearTokenTimer(tokenId);
+}
+
+export async function startTokenWindowKeepalive(
+  deps: TokenWindowKeepaliveDeps = defaultDeps,
+): Promise<void> {
+  clearScheduledTimers();
+  if (!deps.isRunnerEnabled()) {
+    logger.info("token window keepalive runner disabled for this instance");
+    return;
+  }
+  if (deps.readSetting(KEEPALIVE_SETTING_KEY) === "false") {
+    logger.info("token window keepalive disabled");
+    return;
+  }
+  const expectedGeneration = generation;
+
+  let tokens: KeepaliveToken[];
+  try {
+    tokens = await deps.findTokens();
+  } catch (error) {
+    logger.warn(`token discovery failed: ${(error as Error).message}`);
+    return;
+  }
+  if (generation !== expectedGeneration) return;
+
+  const targets = tokens.filter(
+    (token) => token.active && token.provider === "anthropic" && token.keepalive_enabled,
+  );
+  const targetIds = new Set(targets.map((token) => token.id));
+  for (const tokenId of fireGuards.keys()) {
+    if (!targetIds.has(tokenId)) fireGuards.delete(tokenId);
+  }
+  logger.info(`token window keepalive scheduling ${targets.length} token(s)`);
+  await Promise.all(targets.map((token) => inspectToken(token, deps, expectedGeneration, true)));
+}
+
+export function rescheduleTokenWindowKeepalive(
+  deps: TokenWindowKeepaliveDeps = defaultDeps,
+): Promise<void> {
+  return startTokenWindowKeepalive(deps);
+}
+
+export function stopTokenWindowKeepalive(): void {
+  clearScheduledTimers();
+  fireGuards.clear();
+}

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

@@ -73,6 +73,16 @@ describe("maskSecret", () => {
 });
 
 describe("SETTING_DEFS", () => {
+  it("token window keepalive 비상 스위치를 즉시 적용 설정으로 등록한다", () => {
+    expect(findSettingDef("qgrid.tokenWindowKeepaliveEnabled")).toMatchObject({
+      group: "qgrid",
+      kind: "boolean",
+      applies: "immediate",
+      fallback: "true",
+    });
+    expect(findSettingDef("qgrid.tokenWindowKeepaliveEnabled")?.envKey).toBeUndefined();
+  });
+
   it("키가 중복되지 않는다", () => {
     const keys = SETTING_DEFS.map((d) => d.key);
     expect(new Set(keys).size).toBe(keys.length);
@@ -80,7 +90,7 @@ describe("SETTING_DEFS", () => {
 
   it("env 키도 중복되지 않는다", () => {
     // 겹치면 한 env 를 두 설정이 서로 덮어쓴다.
-    const envKeys = SETTING_DEFS.map((d) => d.envKey);
+    const envKeys = SETTING_DEFS.flatMap((d) => (d.envKey ? [d.envKey] : []));
     expect(new Set(envKeys).size).toBe(envKeys.length);
   });
 

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

@@ -17,12 +17,12 @@ export type SettingKind = "boolean" | "integer" | "number" | "string" | "secret"
  * Slack 은 "언제 보낼까"(slack)와 "어디로 보낼까"(slackConnection)를 나눈다 — 앞은 운영
  * 중 자주 만지고 뒤는 한 번 맞추면 끝이라 수명이 다르다.
  */
-export type SettingGroup = "slack" | "slackConnection";
+export type SettingGroup = "qgrid" | "slack" | "slackConnection";
 
 export type SettingDef = {
   key: string;
   group: SettingGroup;
-  envKey: string;
+  envKey?: string;
   label: string;
   kind: SettingKind;
   /** 적용 시점. 부팅 시 한 번만 읽히는 값은 재시작이 필요하다. */
@@ -39,7 +39,22 @@ export type SettingDef = {
   help?: string;
 };
 
+/**
+ * keepalive 스케줄러를 실제로 소유할 인스턴스만 켠다. Settings DB 값과 일부러 분리한다 —
+ * 같은 DB를 보는 개발자 로컬 인스턴스가 전역 설정을 읽고 함께 발사하면 중복 요청이 된다.
+ */
+export const TOKEN_WINDOW_KEEPALIVE_RUNNER_ENV_KEY = "QGRID_TOKEN_WINDOW_KEEPALIVE_ENABLED";
+
 export const SETTING_DEFS: SettingDef[] = [
+  {
+    key: "qgrid.tokenWindowKeepaliveEnabled",
+    fallback: "true",
+    group: "qgrid",
+    label: "토큰 윈도우 keepalive",
+    kind: "boolean",
+    applies: "immediate",
+    help: "끄면 이 서버에서 선택한 Anthropic 토큰의 5시간 윈도우 자동 유지 요청을 중단합니다",
+  },
   {
     key: "slack.enabled",
     fallback: "true",

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

@@ -16,7 +16,13 @@ import { detectSupervisor } from "../../utils/process-supervisor";
 import { armServerRestartExit, beginServerRestart } from "../../utils/server-restart";
 import { type SettingSubsetKey, type SettingSubsetMapping } from "../sonamu.generated";
 import { settingSubsetQueries, settingLoaderQueries } from "../sonamu.generated.sso";
-import { findSettingDef, maskSecret, SETTING_DEFS, validateSettingValue } from "./setting.constant";
+import {
+  findSettingDef,
+  maskSecret,
+  SETTING_DEFS,
+  TOKEN_WINDOW_KEEPALIVE_RUNNER_ENV_KEY,
+  validateSettingValue,
+} from "./setting.constant";
 import {
   getSetting,
   isStored,
@@ -252,7 +258,12 @@ class SettingModelClass extends BaseModelClass<
       };
     });
 
-    return { settings, runtime: this.runtimeInfo(), supervisor: detectSupervisor() };
+    return {
+      settings,
+      runtime: this.runtimeInfo(),
+      supervisor: detectSupervisor(),
+      keepaliveRunnerEnabled: process.env[TOKEN_WINDOW_KEEPALIVE_RUNNER_ENV_KEY] === "true",
+    };
   }
 
   private runtimeInfo(): RuntimeInfoItem[] {

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

@@ -54,8 +54,8 @@ export async function loadSettings(persistence: SettingPersistence = SettingMode
 }
 
 /** DB → env 순. 둘 다 없으면 undefined 라 호출부의 기본값으로 떨어진다. */
-export function getSetting(key: string, envKey: string): string | undefined {
-  return cache?.get(key) ?? process.env[envKey];
+export function getSetting(key: string, envKey?: string): string | undefined {
+  return cache?.get(key) ?? (envKey ? process.env[envKey] : undefined);
 }
 
 /** 저장된 값인지 — 화면에서 출처를 구분해 보여준다. */

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

@@ -61,5 +61,7 @@ export const SettingsResponse = z.object({
   runtime: RuntimeInfoItem.array(),
   /** null 이면 재시작 버튼을 쓸 수 없다 — 종료해도 되살릴 주체가 없다. */
   supervisor: SupervisorKind.nullable(),
+  /** 이 인스턴스가 keepalive 스케줄러를 소유하도록 명시적으로 허용됐는지. */
+  keepaliveRunnerEnabled: z.boolean(),
 });
 export type SettingsResponse = z.infer<typeof SettingsResponse>;

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

@@ -329,6 +329,7 @@ Content-Type: application/json
     "serviceTier": "fast",
     "history": "HISTORY",
     "projectName": "PROJECTNAME",
+    "tokenName": "TOKENNAME",
     "cacheAffinityKey": "CACHEAFFINITYKEY",
     "logger": false,
     "runContext": {
@@ -390,6 +391,7 @@ Content-Type: application/json
     "serviceTier": "fast",
     "history": "HISTORY",
     "projectName": "PROJECTNAME",
+    "tokenName": "TOKENNAME",
     "cacheAffinityKey": "CACHEAFFINITYKEY",
     "logger": false,
     "runContext": {
@@ -564,7 +566,8 @@ Content-Type: application/json
   "id": 0,
   "name": "NAME",
   "quotaThreshold": null,
-  "weight": 0
+  "weight": 0,
+  "keepaliveEnabled": false
 }
 
 ###

package/bundle/src/application/sonamu.generated.sso.ts

@@ -213,6 +213,7 @@ export const tokenSubsetQueries = {
       ord: "tokens.ord",
       quota_threshold: "tokens.quota_threshold",
       weight: "tokens.weight",
+      keepalive_enabled: "tokens.keepalive_enabled",
     });
   },
 };

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

@@ -299,6 +299,7 @@ export const TokenBaseSchema = z.object({
   ord: z.int(),
   quota_threshold: z.int().nullable(),
   weight: z.int(),
+  keepalive_enabled: z.boolean(),
 });
 export type TokenBaseSchema = z.infer<typeof TokenBaseSchema> & {
   readonly __hasDefault__: readonly [
@@ -307,6 +308,7 @@ export type TokenBaseSchema = z.infer<typeof TokenBaseSchema> & {
     "ord",
     "quota_threshold",
     "weight",
+    "keepalive_enabled",
     "id",
   ];
 };
@@ -558,6 +560,7 @@ export const TokenSubsetA = z.object({
   ord: z.int(),
   quota_threshold: z.int().nullable(),
   weight: z.int(),
+  keepalive_enabled: z.boolean(),
 });
 export type TokenSubsetA = z.infer<typeof TokenSubsetA>;
 export type TokenSubsetMapping = {

package/bundle/src/application/token/token.entity.json

@@ -26,9 +26,22 @@
       "type": "integer",
       "desc": "가중 라운드로빈 라우팅 가중치 (1..100)",
       "dbDefault": "1"
+    },
+    {
+      "name": "keepalive_enabled",
+      "type": "boolean",
+      "desc": "Anthropic 5시간 토큰 윈도우 keepalive 사용 여부",
+      "dbDefault": "false"
+    }
+  ],
+  "indexes": [
+    {
+      "type": "unique",
+      "name": "tokens_provider_name_unique",
+      "columns": [{ "name": "provider" }, { "name": "name" }],
+      "using": "btree"
     }
   ],
-  "indexes": [],
   "subsets": {
     "A": [
       "id",
@@ -39,7 +52,8 @@
       "active",
       "ord",
       "quota_threshold",
-      "weight"
+      "weight",
+      "keepalive_enabled"
     ]
   },
   "enums": {