@cartanova/qgrid-cli 2.6.6 → 2.6.8

package/bundle/dist/application/setting/setting.schema.js

@@ -0,0 +1,157 @@
+//#region src/application/setting/setting.schema.ts
+/** 64 GiB 운영 호스트에서 세 자리 오입력을 막는 설정 상한. 안전을 보장하는 값은 아니다. */
+const MAX_OPENAI_ESTIMATED_RSS_GIB = 32;
+const MAX_OPENAI_MIN_HOST_AVAILABLE_GIB = 64;
+const SETTING_DEFS = [
+	{
+		key: "openai.autoscale",
+		fallback: "true",
+		group: "openai",
+		envKey: "QGRID_OPENAI_AUTOSCALE",
+		label: "OpenAI 워커 오토스케일",
+		kind: "boolean",
+		applies: "restart",
+		help: "끄면 워커 수가 최소값으로 고정됩니다"
+	},
+	{
+		key: "openai.minWorkersPerToken",
+		fallback: "1",
+		group: "openai",
+		envKey: "QGRID_OPENAI_MIN_WORKERS_PER_TOKEN",
+		label: "토큰당 최소 워커",
+		kind: "integer",
+		applies: "restart",
+		min: 1,
+		max: 20
+	},
+	{
+		key: "openai.maxWorkersPerToken",
+		fallback: "3",
+		group: "openai",
+		envKey: "QGRID_OPENAI_MAX_WORKERS_PER_TOKEN",
+		label: "토큰당 최대 워커",
+		kind: "integer",
+		applies: "restart",
+		min: 1,
+		max: 20,
+		help: "오토스케일이 꺼져 있으면 무시됩니다"
+	},
+	{
+		key: "openai.maxEstimatedRssGiB",
+		fallback: "16",
+		group: "openai",
+		envKey: "QGRID_OPENAI_MAX_ESTIMATED_RSS_GIB",
+		label: "워커 메모리 상한 (GiB)",
+		kind: "number",
+		applies: "restart",
+		min: 1,
+		max: 32,
+		help: "이 추정치를 넘기면 워커를 더 늘리지 않습니다. 올릴수록 OOM 위험이 커지며 상한은 오입력 방지용입니다"
+	},
+	{
+		key: "openai.minHostAvailableGiB",
+		fallback: "20",
+		group: "openai",
+		envKey: "QGRID_OPENAI_MIN_HOST_AVAILABLE_GIB",
+		label: "호스트 여유 메모리 하한 (GiB)",
+		kind: "number",
+		applies: "restart",
+		min: 0,
+		max: 64,
+		help: "호스트 여유가 이 값 아래면 스케일업을 멈춥니다. 확장을 끄려면 오토스케일을 끄세요"
+	},
+	{
+		key: "slack.expiryReminderMinutes",
+		fallback: "0",
+		group: "slack",
+		envKey: "SLACK_EXPIRY_REMINDER_INTERVAL_MINUTES",
+		label: "만료 알림 반복 주기 (분)",
+		kind: "integer",
+		applies: "immediate",
+		min: 0,
+		max: 1440,
+		help: "0 이면 반복 알림을 끕니다"
+	},
+	{
+		key: "slack.channelId",
+		fallback: "",
+		group: "slack",
+		envKey: "SLACK_CHANNEL_ID",
+		label: "Slack 채널 ID",
+		kind: "string",
+		applies: "immediate",
+		help: "사용자 ID(U...)를 넣으면 그 사람 DM 으로 갑니다"
+	},
+	{
+		key: "slack.userMap",
+		fallback: "",
+		group: "slack",
+		envKey: "SLACK_USER_MAP",
+		label: "Slack 사용자 매핑",
+		kind: "string",
+		applies: "immediate",
+		help: "토큰명:SlackUserId 를 쉼표로. 공용 계정은 넣지 않습니다"
+	},
+	{
+		key: "slack.botToken",
+		fallback: "",
+		group: "slack",
+		envKey: "SLACK_BOT_TOKEN",
+		label: "Slack 봇 토큰",
+		kind: "secret",
+		applies: "immediate"
+	}
+];
+function findSettingDef(key) {
+	return SETTING_DEFS.find((d) => d.key === key);
+}
+/** 저장 전 검증. 잘못된 값이 들어가면 런타임에서 조용히 기본값으로 떨어져 원인을 찾기 어렵다. */
+function validateSettingValue(def, raw) {
+	const trimmed = raw.trim();
+	if (def.kind === "boolean") {
+		if (!["true", "false"].includes(trimmed)) return {
+			ok: false,
+			error: "true 또는 false"
+		};
+		return {
+			ok: true,
+			value: trimmed
+		};
+	}
+	if (def.kind === "integer" || def.kind === "number") {
+		const parsed = Number(trimmed);
+		if (!Number.isFinite(parsed)) return {
+			ok: false,
+			error: "숫자를 입력하세요"
+		};
+		if (def.kind === "integer" && !Number.isInteger(parsed)) return {
+			ok: false,
+			error: "정수를 입력하세요"
+		};
+		if (def.min !== void 0 && parsed < def.min) return {
+			ok: false,
+			error: `${def.min} 이상이어야 합니다`
+		};
+		if (def.max !== void 0 && parsed > def.max) return {
+			ok: false,
+			error: `${def.max} 이하여야 합니다`
+		};
+		return {
+			ok: true,
+			value: String(parsed)
+		};
+	}
+	return {
+		ok: true,
+		value: trimmed
+	};
+}
+/** 화면에 그대로 내려보내면 안 되는 값. 앞뒤만 남긴다. */
+function maskSecret(value) {
+	if (value.length <= 12) return "***";
+	return `${value.slice(0, 8)}...${value.slice(-4)}`;
+}
+//#endregion
+export { MAX_OPENAI_ESTIMATED_RSS_GIB, MAX_OPENAI_MIN_HOST_AVAILABLE_GIB, SETTING_DEFS, findSettingDef, maskSecret, validateSettingValue };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"setting.schema.js","names":[],"sources":["../../../src/application/setting/setting.schema.ts"],"sourcesContent":["/**\n * 관리 가능한 런타임 설정 목록.\n *\n * 키·env 이름·타입·검증을 한 곳에 모아 API 와 UI 가 같은 정의를 본다. 여기 없는 env 는\n * 화면에서 바꿀 수 없다 — DB 접속 정보나 포트처럼 서버가 뜨기 전에 필요한 값들이다.\n */\n\nexport type SettingKind = \"boolean\" | \"integer\" | \"number\" | \"string\" | \"secret\";\n\n/** 화면에서 묶어 보여줄 단위. 9개를 평평하게 나열하면 어디를 봐야 할지 알 수 없다. */\nexport type SettingGroup = \"openai\" | \"slack\";\n\nexport type SettingDef = {\n  key: string;\n  group: SettingGroup;\n  envKey: string;\n  label: string;\n  kind: SettingKind;\n  /** 적용 시점. 워커 설정은 dispatcher 생성자에서 한 번만 읽혀 재시작이 필요하다. */\n  applies: \"immediate\" | \"restart\";\n  min?: number;\n  max?: number;\n  /**\n   * 저장값도 env 도 없을 때 실제로 적용되는 값. 화면을 비워두면 \"설정 안 됨\"으로 읽히지만\n   * 실제로는 이 값이 돌고 있다 — 소비처의 기본값과 반드시 같아야 한다.\n   */\n  fallback: string;\n  help?: string;\n};\n\n/** 64 GiB 운영 호스트에서 세 자리 오입력을 막는 설정 상한. 안전을 보장하는 값은 아니다. */\nexport const MAX_OPENAI_ESTIMATED_RSS_GIB = 32;\nexport const MAX_OPENAI_MIN_HOST_AVAILABLE_GIB = 64;\n\nexport const SETTING_DEFS: SettingDef[] = [\n  {\n    key: \"openai.autoscale\",\n    fallback: \"true\",\n    group: \"openai\",\n    envKey: \"QGRID_OPENAI_AUTOSCALE\",\n    label: \"OpenAI 워커 오토스케일\",\n    kind: \"boolean\",\n    applies: \"restart\",\n    help: \"끄면 워커 수가 최소값으로 고정됩니다\",\n  },\n  {\n    key: \"openai.minWorkersPerToken\",\n    fallback: \"1\",\n    group: \"openai\",\n    envKey: \"QGRID_OPENAI_MIN_WORKERS_PER_TOKEN\",\n    label: \"토큰당 최소 워커\",\n    kind: \"integer\",\n    applies: \"restart\",\n    min: 1,\n    max: 20,\n  },\n  {\n    key: \"openai.maxWorkersPerToken\",\n    fallback: \"3\",\n    group: \"openai\",\n    envKey: \"QGRID_OPENAI_MAX_WORKERS_PER_TOKEN\",\n    label: \"토큰당 최대 워커\",\n    kind: \"integer\",\n    applies: \"restart\",\n    min: 1,\n    max: 20,\n    help: \"오토스케일이 꺼져 있으면 무시됩니다\",\n  },\n  {\n    key: \"openai.maxEstimatedRssGiB\",\n    fallback: \"16\",\n    group: \"openai\",\n    envKey: \"QGRID_OPENAI_MAX_ESTIMATED_RSS_GIB\",\n    label: \"워커 메모리 상한 (GiB)\",\n    kind: \"number\",\n    applies: \"restart\",\n    min: 1,\n    max: MAX_OPENAI_ESTIMATED_RSS_GIB,\n    help: \"이 추정치를 넘기면 워커를 더 늘리지 않습니다. 올릴수록 OOM 위험이 커지며 상한은 오입력 방지용입니다\",\n  },\n  {\n    key: \"openai.minHostAvailableGiB\",\n    fallback: \"20\",\n    group: \"openai\",\n    envKey: \"QGRID_OPENAI_MIN_HOST_AVAILABLE_GIB\",\n    label: \"호스트 여유 메모리 하한 (GiB)\",\n    kind: \"number\",\n    applies: \"restart\",\n    min: 0,\n    max: MAX_OPENAI_MIN_HOST_AVAILABLE_GIB,\n    help: \"호스트 여유가 이 값 아래면 스케일업을 멈춥니다. 확장을 끄려면 오토스케일을 끄세요\",\n  },\n  {\n    key: \"slack.expiryReminderMinutes\",\n    fallback: \"0\",\n    group: \"slack\",\n    envKey: \"SLACK_EXPIRY_REMINDER_INTERVAL_MINUTES\",\n    label: \"만료 알림 반복 주기 (분)\",\n    kind: \"integer\",\n    applies: \"immediate\",\n    min: 0,\n    max: 1440,\n    help: \"0 이면 반복 알림을 끕니다\",\n  },\n  {\n    key: \"slack.channelId\",\n    fallback: \"\",\n    group: \"slack\",\n    envKey: \"SLACK_CHANNEL_ID\",\n    label: \"Slack 채널 ID\",\n    kind: \"string\",\n    applies: \"immediate\",\n    help: \"사용자 ID(U...)를 넣으면 그 사람 DM 으로 갑니다\",\n  },\n  {\n    key: \"slack.userMap\",\n    fallback: \"\",\n    group: \"slack\",\n    envKey: \"SLACK_USER_MAP\",\n    label: \"Slack 사용자 매핑\",\n    kind: \"string\",\n    applies: \"immediate\",\n    help: \"토큰명:SlackUserId 를 쉼표로. 공용 계정은 넣지 않습니다\",\n  },\n  {\n    key: \"slack.botToken\",\n    fallback: \"\",\n    group: \"slack\",\n    envKey: \"SLACK_BOT_TOKEN\",\n    label: \"Slack 봇 토큰\",\n    kind: \"secret\",\n    applies: \"immediate\",\n  },\n];\n\nexport function findSettingDef(key: string): SettingDef | undefined {\n  return SETTING_DEFS.find((d) => d.key === key);\n}\n\n/** 저장 전 검증. 잘못된 값이 들어가면 런타임에서 조용히 기본값으로 떨어져 원인을 찾기 어렵다. */\nexport function validateSettingValue(\n  def: SettingDef,\n  raw: string,\n): { ok: true; value: string } | { ok: false; error: string } {\n  const trimmed = raw.trim();\n\n  if (def.kind === \"boolean\") {\n    if (![\"true\", \"false\"].includes(trimmed)) return { ok: false, error: \"true 또는 false\" };\n    return { ok: true, value: trimmed };\n  }\n\n  if (def.kind === \"integer\" || def.kind === \"number\") {\n    const parsed = Number(trimmed);\n    if (!Number.isFinite(parsed)) return { ok: false, error: \"숫자를 입력하세요\" };\n    if (def.kind === \"integer\" && !Number.isInteger(parsed)) {\n      return { ok: false, error: \"정수를 입력하세요\" };\n    }\n    if (def.min !== undefined && parsed < def.min) {\n      return { ok: false, error: `${def.min} 이상이어야 합니다` };\n    }\n    if (def.max !== undefined && parsed > def.max) {\n      return { ok: false, error: `${def.max} 이하여야 합니다` };\n    }\n    return { ok: true, value: String(parsed) };\n  }\n\n  return { ok: true, value: trimmed };\n}\n\n/** 화면에 그대로 내려보내면 안 되는 값. 앞뒤만 남긴다. */\nexport function maskSecret(value: string): string {\n  if (value.length <= 12) return \"***\";\n  return `${value.slice(0, 8)}...${value.slice(-4)}`;\n}\n"],"mappings":";;AA+BA,MAAa,+BAA+B;AAC5C,MAAa,oCAAoC;AAEjD,MAAa,eAA6B;CACxC;EACE,KAAK;EACL,UAAU;EACV,OAAO;EACP,QAAQ;EACR,OAAO;EACP,MAAM;EACN,SAAS;EACT,MAAM;CACR;CACA;EACE,KAAK;EACL,UAAU;EACV,OAAO;EACP,QAAQ;EACR,OAAO;EACP,MAAM;EACN,SAAS;EACT,KAAK;EACL,KAAK;CACP;CACA;EACE,KAAK;EACL,UAAU;EACV,OAAO;EACP,QAAQ;EACR,OAAO;EACP,MAAM;EACN,SAAS;EACT,KAAK;EACL,KAAK;EACL,MAAM;CACR;CACA;EACE,KAAK;EACL,UAAU;EACV,OAAO;EACP,QAAQ;EACR,OAAO;EACP,MAAM;EACN,SAAS;EACT,KAAK;EACL,KAAA;EACA,MAAM;CACR;CACA;EACE,KAAK;EACL,UAAU;EACV,OAAO;EACP,QAAQ;EACR,OAAO;EACP,MAAM;EACN,SAAS;EACT,KAAK;EACL,KAAA;EACA,MAAM;CACR;CACA;EACE,KAAK;EACL,UAAU;EACV,OAAO;EACP,QAAQ;EACR,OAAO;EACP,MAAM;EACN,SAAS;EACT,KAAK;EACL,KAAK;EACL,MAAM;CACR;CACA;EACE,KAAK;EACL,UAAU;EACV,OAAO;EACP,QAAQ;EACR,OAAO;EACP,MAAM;EACN,SAAS;EACT,MAAM;CACR;CACA;EACE,KAAK;EACL,UAAU;EACV,OAAO;EACP,QAAQ;EACR,OAAO;EACP,MAAM;EACN,SAAS;EACT,MAAM;CACR;CACA;EACE,KAAK;EACL,UAAU;EACV,OAAO;EACP,QAAQ;EACR,OAAO;EACP,MAAM;EACN,SAAS;CACX;AACF;AAEA,SAAgB,eAAe,KAAqC;CAClE,OAAO,aAAa,MAAM,MAAM,EAAE,QAAQ,GAAG;AAC/C;;AAGA,SAAgB,qBACd,KACA,KAC4D;CAC5D,MAAM,UAAU,IAAI,KAAK;CAEzB,IAAI,IAAI,SAAS,WAAW;EAC1B,IAAI,CAAC,CAAC,QAAQ,OAAO,CAAC,CAAC,SAAS,OAAO,GAAG,OAAO;GAAE,IAAI;GAAO,OAAO;EAAgB;EACrF,OAAO;GAAE,IAAI;GAAM,OAAO;EAAQ;CACpC;CAEA,IAAI,IAAI,SAAS,aAAa,IAAI,SAAS,UAAU;EACnD,MAAM,SAAS,OAAO,OAAO;EAC7B,IAAI,CAAC,OAAO,SAAS,MAAM,GAAG,OAAO;GAAE,IAAI;GAAO,OAAO;EAAY;EACrE,IAAI,IAAI,SAAS,aAAa,CAAC,OAAO,UAAU,MAAM,GACpD,OAAO;GAAE,IAAI;GAAO,OAAO;EAAY;EAEzC,IAAI,IAAI,QAAQ,UAAa,SAAS,IAAI,KACxC,OAAO;GAAE,IAAI;GAAO,OAAO,GAAG,IAAI,IAAI;EAAY;EAEpD,IAAI,IAAI,QAAQ,UAAa,SAAS,IAAI,KACxC,OAAO;GAAE,IAAI;GAAO,OAAO,GAAG,IAAI,IAAI;EAAW;EAEnD,OAAO;GAAE,IAAI;GAAM,OAAO,OAAO,MAAM;EAAE;CAC3C;CAEA,OAAO;EAAE,IAAI;EAAM,OAAO;CAAQ;AACpC;;AAGA,SAAgB,WAAW,OAAuB;CAChD,IAAI,MAAM,UAAU,IAAI,OAAO;CAC/B,OAAO,GAAG,MAAM,MAAM,GAAG,CAAC,EAAE,KAAK,MAAM,MAAM,EAAE;AACjD"}

package/bundle/dist/application/setting/setting.store.js

@@ -0,0 +1,66 @@
+import { SettingModel } from "./setting.model.js";
+import { getLogger } from "@logtape/logtape";
+//#region src/application/setting/setting.store.ts
+/**
+* 런타임 설정 조회 캐시.
+*
+* 값의 출처는 DB(`settings`) → env 순이다. env 를 남겨두는 이유는 전환 때문이다 — dev0 는
+* `ecosystem.config.json` 으로 값을 주입하는데, DB 만 보게 만들면 배포 직후 설정이 전부
+* 기본값으로 떨어진다.
+*
+* 설정은 요청 경로(워커 스케일링, 알림 전송)에서 읽히므로 매번 DB 를 때리지 않고 메모리에
+* 둔다. `immediate` 변경도 현재 API 프로세스에만 즉시 반영된다. 인스턴스가 여러 개면 다른
+* 인스턴스의 캐시는 갱신되지 않으며, 이 범위에서는 프로세스 간 전파를 두지 않는다.
+*/
+const logger = getLogger(["qgrid", "setting"]);
+/** 로드 전에는 null 이라 전부 env 로 떨어진다. */
+let cache = null;
+let settingChangeHandler = null;
+/**
+* 런타임 소비자는 상위 조립 계층에서 하나만 등록한다. handler 는 동기 작업만 해야 하며,
+* 실패해도 이미 성공한 DB 저장을 실패로 바꾸지 않는다.
+*/
+function setSettingChangeHandler(handler) {
+	settingChangeHandler = handler;
+}
+function notifySettingChanged(key) {
+	try {
+		settingChangeHandler?.(key);
+	} catch (e) {
+		const message = e instanceof Error ? e.message : String(e);
+		logger.warn(`setting change handler failed for ${key}: ${message}`);
+	}
+}
+async function loadSettings(persistence = SettingModel) {
+	try {
+		cache = await persistence.findAllAsMap();
+		logger.info(`settings loaded: ${cache.size} stored`);
+	} catch (e) {
+		cache = /* @__PURE__ */ new Map();
+		logger.warn(`settings load failed, using env only: ${e.message}`);
+	}
+}
+/** DB → env 순. 둘 다 없으면 undefined 라 호출부의 기본값으로 떨어진다. */
+function getSetting(key, envKey) {
+	return cache?.get(key) ?? process.env[envKey];
+}
+/** 저장된 값인지 — 화면에서 출처를 구분해 보여준다. */
+function isStored(key) {
+	return cache?.has(key) ?? false;
+}
+async function saveSetting(key, value, persistence = SettingModel) {
+	await persistence.setByKey(key, value);
+	cache ??= /* @__PURE__ */ new Map();
+	cache.set(key, value);
+	notifySettingChanged(key);
+}
+/** 저장값을 지워 env 기본값으로 되돌린다. */
+async function resetSetting(key, persistence = SettingModel) {
+	await persistence.clearByKey(key);
+	cache?.delete(key);
+	notifySettingChanged(key);
+}
+//#endregion
+export { getSetting, isStored, loadSettings, resetSetting, saveSetting, setSettingChangeHandler };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/bundle/dist/application/setting/setting.types.js

@@ -0,0 +1,48 @@
+import { SettingBaseListParams, SettingBaseSchema } from "../sonamu.generated.js";
+import { z } from "zod";
+//#region src/application/setting/setting.types.ts
+const SettingListParams = SettingBaseListParams;
+const SettingSaveParams = SettingBaseSchema.partial({
+	id: true,
+	created_at: true
+});
+const SettingKind = z.enum([
+	"boolean",
+	"integer",
+	"number",
+	"string",
+	"secret"
+]);
+const SettingApplies = z.enum(["immediate", "restart"]);
+const SettingSource = z.enum([
+	"db",
+	"env",
+	"default"
+]);
+const SettingItem = z.object({
+	key: z.string(),
+	group: z.string(),
+	label: z.string(),
+	kind: SettingKind,
+	applies: SettingApplies,
+	/** 현재 적용 중인 값. 눈 토글을 지원하기 위해 secret 도 원본으로 내려간다. */
+	value: z.string(),
+	/** 이 값이 어디서 왔는지. 화면에서 출처를 보여줘야 "왜 안 바뀌지"가 없다. */
+	source: SettingSource,
+	min: z.number().nullable(),
+	max: z.number().nullable(),
+	help: z.string().nullable()
+});
+/** 화면에서 바꿀 수 없는 기동 시점 값들 — 어떤 환경에 붙어 있는지 확인용. */
+const RuntimeInfoItem = z.object({
+	label: z.string(),
+	value: z.string()
+});
+const SettingsResponse = z.object({
+	settings: SettingItem.array(),
+	runtime: RuntimeInfoItem.array()
+});
+//#endregion
+export { RuntimeInfoItem, SettingApplies, SettingItem, SettingKind, SettingListParams, SettingSaveParams, SettingSource, SettingsResponse };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/bundle/dist/application/sonamu.generated.js

@@ -104,6 +104,10 @@ const RequestLogStepOrderBy = z.enum(["id-asc"]).describe("RequestLogStepOrderBy
 const RequestLogStepOrderByLabel = { "id-asc": "ID순" };
 const RequestLogStepSearchField = z.enum(["id"]).describe("RequestLogStepSearchField");
 const RequestLogStepSearchFieldLabel = { id: "ID" };
+const SettingOrderBy = z.enum(["key-asc"]).describe("SettingOrderBy");
+const SettingOrderByLabel = { "key-asc": "키순" };
+const SettingSearchField = z.enum(["key"]).describe("SettingSearchField");
+const SettingSearchFieldLabel = { key: "키" };
 const TokenOrderBy = z.enum(["id-desc", "ord-asc"]).describe("TokenOrderBy");
 const TokenOrderByLabel = {
 	"id-desc": "ID최신순",
@@ -175,6 +179,13 @@ const RequestLogStepBaseSchema = z.object({
 	tool_duration_ms: z.int().nullable(),
 	error: z.string().nullable()
 });
+const SettingBaseSchema = z.object({
+	id: z.int(),
+	created_at: z.date(),
+	key: z.string().max(100),
+	value: z.string(),
+	updated_at: z.date().nullable()
+});
 const TokenBaseSchema = z.object({
 	id: z.int(),
 	created_at: z.date(),
@@ -210,6 +221,17 @@ const RequestLogStepBaseListParams = z.object({
 	sonamuFilter: z.custom(),
 	request_log_id: z.int()
 }).partial();
+const SettingBaseListParams = z.object({
+	num: z.number().int().nonnegative(),
+	page: z.number().int().min(1),
+	search: SettingSearchField,
+	keyword: z.string(),
+	orderBy: SettingOrderBy,
+	queryMode: SonamuQueryMode,
+	id: zArrayable(z.number().int().positive()),
+	sonamuFilter: z.custom(),
+	key: z.string().max(100)
+}).partial();
 const TokenBaseListParams = z.object({
 	num: z.number().int().nonnegative(),
 	page: z.number().int().min(1),
@@ -358,6 +380,14 @@ const RequestLogStepSubsetKey = z.enum([
 	"T",
 	"I"
 ]);
+const SettingSubsetA = z.object({
+	id: z.int(),
+	created_at: z.date(),
+	key: z.string().max(100),
+	value: z.string(),
+	updated_at: z.date().nullable()
+});
+const SettingSubsetKey = z.enum(["A"]);
 const TokenSubsetA = z.object({
 	id: z.int(),
 	created_at: z.date(),
@@ -371,6 +401,6 @@ const TokenSubsetA = z.object({
 });
 const TokenSubsetKey = z.enum(["A"]);
 //#endregion
-export { RequestLogBaseListParams, RequestLogBaseSchema, RequestLogOrderBy, RequestLogOrderByLabel, RequestLogSearchField, RequestLogSearchFieldLabel, RequestLogStatus, RequestLogStatusLabel, RequestLogStepBaseListParams, RequestLogStepBaseSchema, RequestLogStepOrderBy, RequestLogStepOrderByLabel, RequestLogStepSearchField, RequestLogStepSearchFieldLabel, RequestLogStepSubsetA, RequestLogStepSubsetI, RequestLogStepSubsetKey, RequestLogStepSubsetT, RequestLogStepType, RequestLogStepTypeLabel, RequestLogSubsetA, RequestLogSubsetC, RequestLogSubsetKey, RequestLogSubsetP, TokenBaseListParams, TokenBaseSchema, TokenOrderBy, TokenOrderByLabel, TokenSearchField, TokenSearchFieldLabel, TokenSubsetA, TokenSubsetKey };
+export { RequestLogBaseListParams, RequestLogBaseSchema, RequestLogOrderBy, RequestLogOrderByLabel, RequestLogSearchField, RequestLogSearchFieldLabel, RequestLogStatus, RequestLogStatusLabel, RequestLogStepBaseListParams, RequestLogStepBaseSchema, RequestLogStepOrderBy, RequestLogStepOrderByLabel, RequestLogStepSearchField, RequestLogStepSearchFieldLabel, RequestLogStepSubsetA, RequestLogStepSubsetI, RequestLogStepSubsetKey, RequestLogStepSubsetT, RequestLogStepType, RequestLogStepTypeLabel, RequestLogSubsetA, RequestLogSubsetC, RequestLogSubsetKey, RequestLogSubsetP, SettingBaseListParams, SettingBaseSchema, SettingOrderBy, SettingOrderByLabel, SettingSearchField, SettingSearchFieldLabel, SettingSubsetA, SettingSubsetKey, TokenBaseListParams, TokenBaseSchema, TokenOrderBy, TokenOrderByLabel, TokenSearchField, TokenSearchFieldLabel, TokenSubsetA, TokenSubsetKey };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"sonamu.generated.js","names":[],"sources":["../../src/application/sonamu.generated.ts"],"sourcesContent":["/**\n * @generated\n * 직접 수정하지 마세요.\n */\n\n/* oxlint-disable */\n\nimport { zArrayable, SonamuQueryMode, ApplySonamuFilter } from \"sonamu\";\nimport { z } from \"zod\";\n\n// CustomScalar: HistoryItems\nconst HistoryItems = z.array(\n  z.object({\n    type: z.string(),\n    role: z.string().optional(),\n    content: z.unknown().optional(),\n    name: z.string().optional(),\n    arguments: z.string().optional(),\n    call_id: z.string().optional(),\n    output: z.string().optional(),\n  }),\n);\ntype HistoryItems = z.infer<typeof HistoryItems>;\n\n// CustomScalar: TokenCredentials\nconst TokenCredentials = z.union([\n  z.object({\n    accessToken: z.string(),\n    refreshToken: z.string(),\n    expiresAt: z.number(),\n    accountUuid: z.string(),\n  }),\n  z.object({\n    accessToken: z.string(),\n    refreshToken: z.string(),\n    idToken: z.string().optional(),\n    accessTokenExpiresAt: z.number(),\n    idTokenExpiresAt: z.number().optional(),\n    accountId: z.string(),\n    planType: z.string().optional(),\n  }),\n]);\ntype TokenCredentials = z.infer<typeof TokenCredentials>;\n\n// CustomScalar: ToolDefinitions\nconst ToolDefinitions = z.array(\n  z.object({\n    name: z.string(),\n    description: z.string().optional(),\n    inputSchema: z.unknown(),\n  }),\n);\ntype ToolDefinitions = z.infer<typeof ToolDefinitions>;\n\n// Enums: RequestLog\nexport const RequestLogOrderBy = z\n  .enum([\n    \"id-desc\",\n    \"id-asc\",\n    \"created_at-desc\",\n    \"created_at-asc\",\n    \"ttft_ms-desc\",\n    \"ttft_ms-asc\",\n    \"duration_ms-desc\",\n    \"duration_ms-asc\",\n    \"input_tokens-desc\",\n    \"input_tokens-asc\",\n    \"output_tokens-desc\",\n    \"output_tokens-asc\",\n    \"cache_read_tokens-desc\",\n    \"cache_read_tokens-asc\",\n    \"cache_creation_tokens-desc\",\n    \"cache_creation_tokens-asc\",\n    \"cost_usd-desc\",\n    \"cost_usd-asc\",\n  ])\n  .describe(\"RequestLogOrderBy\");\nexport type RequestLogOrderBy = z.infer<typeof RequestLogOrderBy>;\nexport const RequestLogOrderByLabel = {\n  \"id-desc\": \"ID최신순\",\n  \"id-asc\": \"ID오래된순\",\n  \"created_at-desc\": \"등록일시최신순\",\n  \"created_at-asc\": \"등록일시오래된순\",\n  \"ttft_ms-desc\": \"TTFT긴순\",\n  \"ttft_ms-asc\": \"TTFT짧은순\",\n  \"duration_ms-desc\": \"소요시간긴순\",\n  \"duration_ms-asc\": \"소요시간짧은순\",\n  \"input_tokens-desc\": \"입력토큰많은순\",\n  \"input_tokens-asc\": \"입력토큰적은순\",\n  \"output_tokens-desc\": \"출력토큰많은순\",\n  \"output_tokens-asc\": \"출력토큰적은순\",\n  \"cache_read_tokens-desc\": \"캐시읽기많은순\",\n  \"cache_read_tokens-asc\": \"캐시읽기적은순\",\n  \"cache_creation_tokens-desc\": \"캐시생성많은순\",\n  \"cache_creation_tokens-asc\": \"캐시생성적은순\",\n  \"cost_usd-desc\": \"비용높은순\",\n  \"cost_usd-asc\": \"비용낮은순\",\n};\nexport const RequestLogSearchField = z\n  .enum([\"id\", \"token_name\", \"user_prompt\"])\n  .describe(\"RequestLogSearchField\");\nexport type RequestLogSearchField = z.infer<typeof RequestLogSearchField>;\nexport const RequestLogSearchFieldLabel = {\n  id: \"ID\",\n  token_name: \"토큰이름\",\n  user_prompt: \"사용자 프롬프트\",\n};\nexport const RequestLogStatus = z\n  .enum([\"running\", \"succeeded\", \"error\", \"aborted\"])\n  .describe(\"RequestLogStatus\");\nexport type RequestLogStatus = z.infer<typeof RequestLogStatus>;\nexport const RequestLogStatusLabel = {\n  running: \"실행 중\",\n  succeeded: \"성공\",\n  error: \"에러\",\n  aborted: \"중단\",\n};\n\n// Enums: RequestLogStep\nexport const RequestLogStepType = z.enum([\"generate\", \"tool_call\"]).describe(\"RequestLogStepType\");\nexport type RequestLogStepType = z.infer<typeof RequestLogStepType>;\nexport const RequestLogStepTypeLabel = { generate: \"LLM 생성\", tool_call: \"Tool 호출\" };\nexport const RequestLogStepOrderBy = z.enum([\"id-asc\"]).describe(\"RequestLogStepOrderBy\");\nexport type RequestLogStepOrderBy = z.infer<typeof RequestLogStepOrderBy>;\nexport const RequestLogStepOrderByLabel = { \"id-asc\": \"ID순\" };\nexport const RequestLogStepSearchField = z.enum([\"id\"]).describe(\"RequestLogStepSearchField\");\nexport type RequestLogStepSearchField = z.infer<typeof RequestLogStepSearchField>;\nexport const RequestLogStepSearchFieldLabel = { id: \"ID\" };\n\n// Enums: Token\nexport const TokenOrderBy = z.enum([\"id-desc\", \"ord-asc\"]).describe(\"TokenOrderBy\");\nexport type TokenOrderBy = z.infer<typeof TokenOrderBy>;\nexport const TokenOrderByLabel = { \"id-desc\": \"ID최신순\", \"ord-asc\": \"순서순\" };\nexport const TokenSearchField = z.enum([\"id\", \"name\"]).describe(\"TokenSearchField\");\nexport type TokenSearchField = z.infer<typeof TokenSearchField>;\nexport const TokenSearchFieldLabel = { id: \"ID\", name: \"이름\" };\n\n// BaseSchema: RequestLog\nexport const RequestLogBaseSchema = z.object({\n  id: z.int(),\n  created_at: z.date(),\n  token_name: z.string().max(100).nullable(),\n  project_name: z.string().max(50).nullable(),\n  model_name: z.string().max(255).nullable(),\n  requested_model_name: z.string().max(255).nullable(),\n  fallback_count: z.int().nullable(),\n  user_prompt: z.string().nullable(),\n  system_prompt: z.string().nullable(),\n  response: z.string(),\n  input_tokens: z.int(),\n  output_tokens: z.int(),\n  cache_read_tokens: z.int(),\n  cache_creation_tokens: z.int(),\n  cache_creation_5m_tokens: z.int().nullable(),\n  cache_creation_1h_tokens: z.int().nullable(),\n  duration_ms: z.int(),\n  ttft_ms: z.int(),\n  cost_usd: z.int().nullable(),\n  cost_source: z.string().max(20).nullable(),\n  image_cost_usd: z.int().nullable(),\n  image_cost_method: z.string().max(100).nullable(),\n  effort: z.string().max(10).nullable(),\n  history: HistoryItems.nullable(),\n  tools: ToolDefinitions.nullable(),\n  status: RequestLogStatus,\n  error_message: z.string().nullable(),\n  tool_call_count: z.int(),\n  is_image_generation: z.boolean(),\n});\nexport type RequestLogBaseSchema = z.infer<typeof RequestLogBaseSchema> & {\n  readonly __hasDefault__: readonly [\n    \"created_at\",\n    \"token_name\",\n    \"project_name\",\n    \"model_name\",\n    \"requested_model_name\",\n    \"fallback_count\",\n    \"user_prompt\",\n    \"system_prompt\",\n    \"response\",\n    \"input_tokens\",\n    \"output_tokens\",\n    \"cache_read_tokens\",\n    \"cache_creation_tokens\",\n    \"cache_creation_5m_tokens\",\n    \"cache_creation_1h_tokens\",\n    \"duration_ms\",\n    \"ttft_ms\",\n    \"cost_usd\",\n    \"cost_source\",\n    \"image_cost_usd\",\n    \"image_cost_method\",\n    \"effort\",\n    \"history\",\n    \"tools\",\n    \"status\",\n    \"error_message\",\n    \"tool_call_count\",\n    \"is_image_generation\",\n    \"id\",\n  ];\n};\n\n// BaseSchema: RequestLogStep\nexport const RequestLogStepBaseSchema = z.object({\n  id: z.int(),\n  created_at: z.date(),\n  request_log_id: z.int(),\n  step_index: z.int(),\n  type: RequestLogStepType,\n  model_name: z.string().max(255).nullable(),\n  requested_model_name: z.string().max(255).nullable(),\n  fallback_count: z.int().nullable(),\n  input_tokens: z.int().nullable(),\n  output_tokens: z.int().nullable(),\n  cache_read_tokens: z.int().nullable(),\n  cache_creation_tokens: z.int().nullable(),\n  cache_creation_5m_tokens: z.int().nullable(),\n  cache_creation_1h_tokens: z.int().nullable(),\n  cost_usd: z.int().nullable(),\n  cost_source: z.string().max(20).nullable(),\n  duration_ms: z.int().nullable(),\n  ttft_ms: z.int().nullable(),\n  finish_reason: z.string().max(20).nullable(),\n  reasoning_text: z.string().nullable(),\n  reasoning_tokens: z.int().nullable(),\n  tool_call_index: z.int().nullable(),\n  tool_call_id: z.string().max(100).nullable(),\n  tool_name: z.string().max(100).nullable(),\n  tool_args: z.string().nullable(),\n  tool_result: z.string().nullable(),\n  tool_duration_ms: z.int().nullable(),\n  error: z.string().nullable(),\n});\nexport type RequestLogStepBaseSchema = z.infer<typeof RequestLogStepBaseSchema> & {\n  readonly __hasDefault__: readonly [\n    \"created_at\",\n    \"model_name\",\n    \"requested_model_name\",\n    \"fallback_count\",\n    \"input_tokens\",\n    \"output_tokens\",\n    \"cache_read_tokens\",\n    \"cache_creation_tokens\",\n    \"cache_creation_5m_tokens\",\n    \"cache_creation_1h_tokens\",\n    \"cost_usd\",\n    \"cost_source\",\n    \"duration_ms\",\n    \"ttft_ms\",\n    \"finish_reason\",\n    \"reasoning_text\",\n    \"reasoning_tokens\",\n    \"tool_call_index\",\n    \"tool_call_id\",\n    \"tool_name\",\n    \"tool_args\",\n    \"tool_result\",\n    \"tool_duration_ms\",\n    \"error\",\n    \"id\",\n  ];\n};\n\n// BaseSchema: Token\nexport const TokenBaseSchema = z.object({\n  id: z.int(),\n  created_at: z.date(),\n  provider: z.string().max(20),\n  credentials: TokenCredentials,\n  name: z.string(),\n  active: z.boolean(),\n  ord: z.int(),\n  quota_threshold: z.int().nullable(),\n  weight: z.int(),\n});\nexport type TokenBaseSchema = z.infer<typeof TokenBaseSchema> & {\n  readonly __hasDefault__: readonly [\n    \"created_at\",\n    \"active\",\n    \"ord\",\n    \"quota_threshold\",\n    \"weight\",\n    \"id\",\n  ];\n};\n\n// BaseListParams: RequestLog\nexport const RequestLogBaseListParams = z\n  .object({\n    num: z.number().int().nonnegative(),\n    page: z.number().int().min(1),\n    search: RequestLogSearchField,\n    keyword: z.string(),\n    orderBy: RequestLogOrderBy,\n    queryMode: SonamuQueryMode,\n    id: zArrayable(z.number().int().positive()),\n    sonamuFilter: z.custom<ApplySonamuFilter<RequestLogBaseSchema, never, never>>(),\n    token_name: z.string().max(100).nullable(),\n    project_name: z.string().max(50).nullable(),\n    model_name: z.string().max(255).nullable(),\n  })\n  .partial();\nexport type RequestLogBaseListParams = z.infer<typeof RequestLogBaseListParams>;\n\n// BaseListParams: RequestLogStep\nexport const RequestLogStepBaseListParams = z\n  .object({\n    num: z.number().int().nonnegative(),\n    page: z.number().int().min(1),\n    search: RequestLogStepSearchField,\n    keyword: z.string(),\n    orderBy: RequestLogStepOrderBy,\n    queryMode: SonamuQueryMode,\n    id: zArrayable(z.number().int().positive()),\n    sonamuFilter: z.custom<ApplySonamuFilter<RequestLogStepBaseSchema, never, never>>(),\n    request_log_id: z.int(),\n  })\n  .partial();\nexport type RequestLogStepBaseListParams = z.infer<typeof RequestLogStepBaseListParams>;\n\n// BaseListParams: Token\nexport const TokenBaseListParams = z\n  .object({\n    num: z.number().int().nonnegative(),\n    page: z.number().int().min(1),\n    search: TokenSearchField,\n    keyword: z.string(),\n    orderBy: TokenOrderBy,\n    queryMode: SonamuQueryMode,\n    id: zArrayable(z.number().int().positive()),\n    sonamuFilter: z.custom<ApplySonamuFilter<TokenBaseSchema, never, never>>(),\n  })\n  .partial();\nexport type TokenBaseListParams = z.infer<typeof TokenBaseListParams>;\n\n// Subsets: RequestLog\nexport const RequestLogSubsetA = z.object({\n  id: z.int(),\n  created_at: z.date(),\n  token_name: z.string().max(100).nullable(),\n  project_name: z.string().max(50).nullable(),\n  model_name: z.string().max(255).nullable(),\n  requested_model_name: z.string().max(255).nullable(),\n  fallback_count: z.int().nullable(),\n  user_prompt: z.string().nullable(),\n  system_prompt: z.string().nullable(),\n  response: z.string(),\n  input_tokens: z.int(),\n  output_tokens: z.int(),\n  cache_read_tokens: z.int(),\n  cache_creation_tokens: z.int(),\n  cache_creation_5m_tokens: z.int().nullable(),\n  cache_creation_1h_tokens: z.int().nullable(),\n  duration_ms: z.int(),\n  ttft_ms: z.int(),\n  cost_usd: z.int().nullable(),\n  cost_source: z.string().max(20).nullable(),\n  image_cost_usd: z.int().nullable(),\n  image_cost_method: z.string().max(100).nullable(),\n  effort: z.string().max(10).nullable(),\n  history: HistoryItems.nullable(),\n  tools: ToolDefinitions.nullable(),\n  status: RequestLogStatus,\n  error_message: z.string().nullable(),\n  tool_call_count: z.int(),\n  is_image_generation: z.boolean(),\n});\nexport type RequestLogSubsetA = z.infer<typeof RequestLogSubsetA>;\nexport const RequestLogSubsetP = z.object({\n  id: z.int(),\n  created_at: z.date(),\n  token_name: z.string().max(100).nullable(),\n  project_name: z.string().max(50).nullable(),\n  model_name: z.string().max(255).nullable(),\n  requested_model_name: z.string().max(255).nullable(),\n  fallback_count: z.int().nullable(),\n  input_tokens: z.int(),\n  output_tokens: z.int(),\n  cache_read_tokens: z.int(),\n  cache_creation_tokens: z.int(),\n  cache_creation_5m_tokens: z.int().nullable(),\n  cache_creation_1h_tokens: z.int().nullable(),\n  duration_ms: z.int(),\n  ttft_ms: z.int(),\n  cost_usd: z.int().nullable(),\n  cost_source: z.string().max(20).nullable(),\n  image_cost_usd: z.int().nullable(),\n  image_cost_method: z.string().max(100).nullable(),\n  effort: z.string().max(10).nullable(),\n  status: RequestLogStatus,\n  tool_call_count: z.int(),\n  is_image_generation: z.boolean(),\n});\nexport type RequestLogSubsetP = z.infer<typeof RequestLogSubsetP>;\nexport const RequestLogSubsetC = z.object({\n  id: z.int(),\n  token_name: z.string().max(100).nullable(),\n  model_name: z.string().max(255).nullable(),\n  input_tokens: z.int(),\n  output_tokens: z.int(),\n  cache_read_tokens: z.int(),\n  cache_creation_tokens: z.int(),\n  cache_creation_5m_tokens: z.int().nullable(),\n  cache_creation_1h_tokens: z.int().nullable(),\n  cost_usd: z.int().nullable(),\n  cost_source: z.string().max(20).nullable(),\n});\nexport type RequestLogSubsetC = z.infer<typeof RequestLogSubsetC>;\nexport type RequestLogSubsetMapping = {\n  A: RequestLogSubsetA;\n  P: RequestLogSubsetP;\n  C: RequestLogSubsetC;\n};\nexport const RequestLogSubsetKey = z.enum([\"A\", \"P\", \"C\"]);\nexport type RequestLogSubsetKey = z.infer<typeof RequestLogSubsetKey>;\n\n// Subsets: RequestLogStep\nexport const RequestLogStepSubsetA = z.object({\n  id: z.int(),\n  created_at: z.date(),\n  step_index: z.int(),\n  type: RequestLogStepType,\n  model_name: z.string().max(255).nullable(),\n  requested_model_name: z.string().max(255).nullable(),\n  fallback_count: z.int().nullable(),\n  input_tokens: z.int().nullable(),\n  output_tokens: z.int().nullable(),\n  cache_read_tokens: z.int().nullable(),\n  cache_creation_tokens: z.int().nullable(),\n  cache_creation_5m_tokens: z.int().nullable(),\n  cache_creation_1h_tokens: z.int().nullable(),\n  cost_usd: z.int().nullable(),\n  cost_source: z.string().max(20).nullable(),\n  duration_ms: z.int().nullable(),\n  ttft_ms: z.int().nullable(),\n  finish_reason: z.string().max(20).nullable(),\n  reasoning_text: z.string().nullable(),\n  reasoning_tokens: z.int().nullable(),\n  tool_call_index: z.int().nullable(),\n  tool_call_id: z.string().max(100).nullable(),\n  tool_name: z.string().max(100).nullable(),\n  tool_args: z.string().nullable(),\n  tool_result: z.string().nullable(),\n  tool_duration_ms: z.int().nullable(),\n  error: z.string().nullable(),\n});\nexport type RequestLogStepSubsetA = z.infer<typeof RequestLogStepSubsetA>;\nexport const RequestLogStepSubsetT = z.object({\n  id: z.int(),\n  created_at: z.date(),\n  step_index: z.int(),\n  type: RequestLogStepType,\n  model_name: z.string().max(255).nullable(),\n  requested_model_name: z.string().max(255).nullable(),\n  fallback_count: z.int().nullable(),\n  input_tokens: z.int().nullable(),\n  output_tokens: z.int().nullable(),\n  cache_read_tokens: z.int().nullable(),\n  cache_creation_tokens: z.int().nullable(),\n  cache_creation_5m_tokens: z.int().nullable(),\n  cache_creation_1h_tokens: z.int().nullable(),\n  cost_usd: z.int().nullable(),\n  cost_source: z.string().max(20).nullable(),\n  duration_ms: z.int().nullable(),\n  ttft_ms: z.int().nullable(),\n  finish_reason: z.string().max(20).nullable(),\n  reasoning_tokens: z.int().nullable(),\n  tool_call_index: z.int().nullable(),\n  tool_call_id: z.string().max(100).nullable(),\n  tool_name: z.string().max(100).nullable(),\n  tool_duration_ms: z.int().nullable(),\n  error: z.string().nullable(),\n});\nexport type RequestLogStepSubsetT = z.infer<typeof RequestLogStepSubsetT>;\nexport const RequestLogStepSubsetI = z.object({\n  id: z.int(),\n  tool_args: z.string().nullable(),\n});\nexport type RequestLogStepSubsetI = z.infer<typeof RequestLogStepSubsetI>;\nexport type RequestLogStepSubsetMapping = {\n  A: RequestLogStepSubsetA;\n  T: RequestLogStepSubsetT;\n  I: RequestLogStepSubsetI;\n};\nexport const RequestLogStepSubsetKey = z.enum([\"A\", \"T\", \"I\"]);\nexport type RequestLogStepSubsetKey = z.infer<typeof RequestLogStepSubsetKey>;\n\n// Subsets: Token\nexport const TokenSubsetA = z.object({\n  id: z.int(),\n  created_at: z.date(),\n  provider: z.string().max(20),\n  credentials: TokenCredentials,\n  name: z.string(),\n  active: z.boolean(),\n  ord: z.int(),\n  quota_threshold: z.int().nullable(),\n  weight: z.int(),\n});\nexport type TokenSubsetA = z.infer<typeof TokenSubsetA>;\nexport type TokenSubsetMapping = {\n  A: TokenSubsetA;\n};\nexport const TokenSubsetKey = z.enum([\"A\"]);\nexport type TokenSubsetKey = z.infer<typeof TokenSubsetKey>;\n"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"sonamu.generated.js","names":[],"sources":["../../src/application/sonamu.generated.ts"],"sourcesContent":["/**\n * @generated\n * 직접 수정하지 마세요.\n */\n\n/* oxlint-disable */\n\nimport { zArrayable, SonamuQueryMode, ApplySonamuFilter } from \"sonamu\";\nimport { z } from \"zod\";\n\n// CustomScalar: HistoryItems\nconst HistoryItems = z.array(\n  z.object({\n    type: z.string(),\n    role: z.string().optional(),\n    content: z.unknown().optional(),\n    name: z.string().optional(),\n    arguments: z.string().optional(),\n    call_id: z.string().optional(),\n    output: z.string().optional(),\n  }),\n);\ntype HistoryItems = z.infer<typeof HistoryItems>;\n\n// CustomScalar: TokenCredentials\nconst TokenCredentials = z.union([\n  z.object({\n    accessToken: z.string(),\n    refreshToken: z.string(),\n    expiresAt: z.number(),\n    accountUuid: z.string(),\n  }),\n  z.object({\n    accessToken: z.string(),\n    refreshToken: z.string(),\n    idToken: z.string().optional(),\n    accessTokenExpiresAt: z.number(),\n    idTokenExpiresAt: z.number().optional(),\n    accountId: z.string(),\n    planType: z.string().optional(),\n  }),\n]);\ntype TokenCredentials = z.infer<typeof TokenCredentials>;\n\n// CustomScalar: ToolDefinitions\nconst ToolDefinitions = z.array(\n  z.object({\n    name: z.string(),\n    description: z.string().optional(),\n    inputSchema: z.unknown(),\n  }),\n);\ntype ToolDefinitions = z.infer<typeof ToolDefinitions>;\n\n// Enums: RequestLog\nexport const RequestLogOrderBy = z\n  .enum([\n    \"id-desc\",\n    \"id-asc\",\n    \"created_at-desc\",\n    \"created_at-asc\",\n    \"ttft_ms-desc\",\n    \"ttft_ms-asc\",\n    \"duration_ms-desc\",\n    \"duration_ms-asc\",\n    \"input_tokens-desc\",\n    \"input_tokens-asc\",\n    \"output_tokens-desc\",\n    \"output_tokens-asc\",\n    \"cache_read_tokens-desc\",\n    \"cache_read_tokens-asc\",\n    \"cache_creation_tokens-desc\",\n    \"cache_creation_tokens-asc\",\n    \"cost_usd-desc\",\n    \"cost_usd-asc\",\n  ])\n  .describe(\"RequestLogOrderBy\");\nexport type RequestLogOrderBy = z.infer<typeof RequestLogOrderBy>;\nexport const RequestLogOrderByLabel = {\n  \"id-desc\": \"ID최신순\",\n  \"id-asc\": \"ID오래된순\",\n  \"created_at-desc\": \"등록일시최신순\",\n  \"created_at-asc\": \"등록일시오래된순\",\n  \"ttft_ms-desc\": \"TTFT긴순\",\n  \"ttft_ms-asc\": \"TTFT짧은순\",\n  \"duration_ms-desc\": \"소요시간긴순\",\n  \"duration_ms-asc\": \"소요시간짧은순\",\n  \"input_tokens-desc\": \"입력토큰많은순\",\n  \"input_tokens-asc\": \"입력토큰적은순\",\n  \"output_tokens-desc\": \"출력토큰많은순\",\n  \"output_tokens-asc\": \"출력토큰적은순\",\n  \"cache_read_tokens-desc\": \"캐시읽기많은순\",\n  \"cache_read_tokens-asc\": \"캐시읽기적은순\",\n  \"cache_creation_tokens-desc\": \"캐시생성많은순\",\n  \"cache_creation_tokens-asc\": \"캐시생성적은순\",\n  \"cost_usd-desc\": \"비용높은순\",\n  \"cost_usd-asc\": \"비용낮은순\",\n};\nexport const RequestLogSearchField = z\n  .enum([\"id\", \"token_name\", \"user_prompt\"])\n  .describe(\"RequestLogSearchField\");\nexport type RequestLogSearchField = z.infer<typeof RequestLogSearchField>;\nexport const RequestLogSearchFieldLabel = {\n  id: \"ID\",\n  token_name: \"토큰이름\",\n  user_prompt: \"사용자 프롬프트\",\n};\nexport const RequestLogStatus = z\n  .enum([\"running\", \"succeeded\", \"error\", \"aborted\"])\n  .describe(\"RequestLogStatus\");\nexport type RequestLogStatus = z.infer<typeof RequestLogStatus>;\nexport const RequestLogStatusLabel = {\n  running: \"실행 중\",\n  succeeded: \"성공\",\n  error: \"에러\",\n  aborted: \"중단\",\n};\n\n// Enums: RequestLogStep\nexport const RequestLogStepType = z.enum([\"generate\", \"tool_call\"]).describe(\"RequestLogStepType\");\nexport type RequestLogStepType = z.infer<typeof RequestLogStepType>;\nexport const RequestLogStepTypeLabel = { generate: \"LLM 생성\", tool_call: \"Tool 호출\" };\nexport const RequestLogStepOrderBy = z.enum([\"id-asc\"]).describe(\"RequestLogStepOrderBy\");\nexport type RequestLogStepOrderBy = z.infer<typeof RequestLogStepOrderBy>;\nexport const RequestLogStepOrderByLabel = { \"id-asc\": \"ID순\" };\nexport const RequestLogStepSearchField = z.enum([\"id\"]).describe(\"RequestLogStepSearchField\");\nexport type RequestLogStepSearchField = z.infer<typeof RequestLogStepSearchField>;\nexport const RequestLogStepSearchFieldLabel = { id: \"ID\" };\n\n// Enums: Setting\nexport const SettingOrderBy = z.enum([\"key-asc\"]).describe(\"SettingOrderBy\");\nexport type SettingOrderBy = z.infer<typeof SettingOrderBy>;\nexport const SettingOrderByLabel = { \"key-asc\": \"키순\" };\nexport const SettingSearchField = z.enum([\"key\"]).describe(\"SettingSearchField\");\nexport type SettingSearchField = z.infer<typeof SettingSearchField>;\nexport const SettingSearchFieldLabel = { key: \"키\" };\n\n// Enums: Token\nexport const TokenOrderBy = z.enum([\"id-desc\", \"ord-asc\"]).describe(\"TokenOrderBy\");\nexport type TokenOrderBy = z.infer<typeof TokenOrderBy>;\nexport const TokenOrderByLabel = { \"id-desc\": \"ID최신순\", \"ord-asc\": \"순서순\" };\nexport const TokenSearchField = z.enum([\"id\", \"name\"]).describe(\"TokenSearchField\");\nexport type TokenSearchField = z.infer<typeof TokenSearchField>;\nexport const TokenSearchFieldLabel = { id: \"ID\", name: \"이름\" };\n\n// BaseSchema: RequestLog\nexport const RequestLogBaseSchema = z.object({\n  id: z.int(),\n  created_at: z.date(),\n  token_name: z.string().max(100).nullable(),\n  project_name: z.string().max(50).nullable(),\n  model_name: z.string().max(255).nullable(),\n  requested_model_name: z.string().max(255).nullable(),\n  fallback_count: z.int().nullable(),\n  user_prompt: z.string().nullable(),\n  system_prompt: z.string().nullable(),\n  response: z.string(),\n  input_tokens: z.int(),\n  output_tokens: z.int(),\n  cache_read_tokens: z.int(),\n  cache_creation_tokens: z.int(),\n  cache_creation_5m_tokens: z.int().nullable(),\n  cache_creation_1h_tokens: z.int().nullable(),\n  duration_ms: z.int(),\n  ttft_ms: z.int(),\n  cost_usd: z.int().nullable(),\n  cost_source: z.string().max(20).nullable(),\n  image_cost_usd: z.int().nullable(),\n  image_cost_method: z.string().max(100).nullable(),\n  effort: z.string().max(10).nullable(),\n  history: HistoryItems.nullable(),\n  tools: ToolDefinitions.nullable(),\n  status: RequestLogStatus,\n  error_message: z.string().nullable(),\n  tool_call_count: z.int(),\n  is_image_generation: z.boolean(),\n});\nexport type RequestLogBaseSchema = z.infer<typeof RequestLogBaseSchema> & {\n  readonly __hasDefault__: readonly [\n    \"created_at\",\n    \"token_name\",\n    \"project_name\",\n    \"model_name\",\n    \"requested_model_name\",\n    \"fallback_count\",\n    \"user_prompt\",\n    \"system_prompt\",\n    \"response\",\n    \"input_tokens\",\n    \"output_tokens\",\n    \"cache_read_tokens\",\n    \"cache_creation_tokens\",\n    \"cache_creation_5m_tokens\",\n    \"cache_creation_1h_tokens\",\n    \"duration_ms\",\n    \"ttft_ms\",\n    \"cost_usd\",\n    \"cost_source\",\n    \"image_cost_usd\",\n    \"image_cost_method\",\n    \"effort\",\n    \"history\",\n    \"tools\",\n    \"status\",\n    \"error_message\",\n    \"tool_call_count\",\n    \"is_image_generation\",\n    \"id\",\n  ];\n};\n\n// BaseSchema: RequestLogStep\nexport const RequestLogStepBaseSchema = z.object({\n  id: z.int(),\n  created_at: z.date(),\n  request_log_id: z.int(),\n  step_index: z.int(),\n  type: RequestLogStepType,\n  model_name: z.string().max(255).nullable(),\n  requested_model_name: z.string().max(255).nullable(),\n  fallback_count: z.int().nullable(),\n  input_tokens: z.int().nullable(),\n  output_tokens: z.int().nullable(),\n  cache_read_tokens: z.int().nullable(),\n  cache_creation_tokens: z.int().nullable(),\n  cache_creation_5m_tokens: z.int().nullable(),\n  cache_creation_1h_tokens: z.int().nullable(),\n  cost_usd: z.int().nullable(),\n  cost_source: z.string().max(20).nullable(),\n  duration_ms: z.int().nullable(),\n  ttft_ms: z.int().nullable(),\n  finish_reason: z.string().max(20).nullable(),\n  reasoning_text: z.string().nullable(),\n  reasoning_tokens: z.int().nullable(),\n  tool_call_index: z.int().nullable(),\n  tool_call_id: z.string().max(100).nullable(),\n  tool_name: z.string().max(100).nullable(),\n  tool_args: z.string().nullable(),\n  tool_result: z.string().nullable(),\n  tool_duration_ms: z.int().nullable(),\n  error: z.string().nullable(),\n});\nexport type RequestLogStepBaseSchema = z.infer<typeof RequestLogStepBaseSchema> & {\n  readonly __hasDefault__: readonly [\n    \"created_at\",\n    \"model_name\",\n    \"requested_model_name\",\n    \"fallback_count\",\n    \"input_tokens\",\n    \"output_tokens\",\n    \"cache_read_tokens\",\n    \"cache_creation_tokens\",\n    \"cache_creation_5m_tokens\",\n    \"cache_creation_1h_tokens\",\n    \"cost_usd\",\n    \"cost_source\",\n    \"duration_ms\",\n    \"ttft_ms\",\n    \"finish_reason\",\n    \"reasoning_text\",\n    \"reasoning_tokens\",\n    \"tool_call_index\",\n    \"tool_call_id\",\n    \"tool_name\",\n    \"tool_args\",\n    \"tool_result\",\n    \"tool_duration_ms\",\n    \"error\",\n    \"id\",\n  ];\n};\n\n// BaseSchema: Setting\nexport const SettingBaseSchema = z.object({\n  id: z.int(),\n  created_at: z.date(),\n  key: z.string().max(100),\n  value: z.string(),\n  updated_at: z.date().nullable(),\n});\nexport type SettingBaseSchema = z.infer<typeof SettingBaseSchema> & {\n  readonly __hasDefault__: readonly [\"created_at\", \"updated_at\", \"id\"];\n};\n\n// BaseSchema: Token\nexport const TokenBaseSchema = z.object({\n  id: z.int(),\n  created_at: z.date(),\n  provider: z.string().max(20),\n  credentials: TokenCredentials,\n  name: z.string(),\n  active: z.boolean(),\n  ord: z.int(),\n  quota_threshold: z.int().nullable(),\n  weight: z.int(),\n});\nexport type TokenBaseSchema = z.infer<typeof TokenBaseSchema> & {\n  readonly __hasDefault__: readonly [\n    \"created_at\",\n    \"active\",\n    \"ord\",\n    \"quota_threshold\",\n    \"weight\",\n    \"id\",\n  ];\n};\n\n// BaseListParams: RequestLog\nexport const RequestLogBaseListParams = z\n  .object({\n    num: z.number().int().nonnegative(),\n    page: z.number().int().min(1),\n    search: RequestLogSearchField,\n    keyword: z.string(),\n    orderBy: RequestLogOrderBy,\n    queryMode: SonamuQueryMode,\n    id: zArrayable(z.number().int().positive()),\n    sonamuFilter: z.custom<ApplySonamuFilter<RequestLogBaseSchema, never, never>>(),\n    token_name: z.string().max(100).nullable(),\n    project_name: z.string().max(50).nullable(),\n    model_name: z.string().max(255).nullable(),\n  })\n  .partial();\nexport type RequestLogBaseListParams = z.infer<typeof RequestLogBaseListParams>;\n\n// BaseListParams: RequestLogStep\nexport const RequestLogStepBaseListParams = z\n  .object({\n    num: z.number().int().nonnegative(),\n    page: z.number().int().min(1),\n    search: RequestLogStepSearchField,\n    keyword: z.string(),\n    orderBy: RequestLogStepOrderBy,\n    queryMode: SonamuQueryMode,\n    id: zArrayable(z.number().int().positive()),\n    sonamuFilter: z.custom<ApplySonamuFilter<RequestLogStepBaseSchema, never, never>>(),\n    request_log_id: z.int(),\n  })\n  .partial();\nexport type RequestLogStepBaseListParams = z.infer<typeof RequestLogStepBaseListParams>;\n\n// BaseListParams: Setting\nexport const SettingBaseListParams = z\n  .object({\n    num: z.number().int().nonnegative(),\n    page: z.number().int().min(1),\n    search: SettingSearchField,\n    keyword: z.string(),\n    orderBy: SettingOrderBy,\n    queryMode: SonamuQueryMode,\n    id: zArrayable(z.number().int().positive()),\n    sonamuFilter: z.custom<ApplySonamuFilter<SettingBaseSchema, never, never>>(),\n    key: z.string().max(100),\n  })\n  .partial();\nexport type SettingBaseListParams = z.infer<typeof SettingBaseListParams>;\n\n// BaseListParams: Token\nexport const TokenBaseListParams = z\n  .object({\n    num: z.number().int().nonnegative(),\n    page: z.number().int().min(1),\n    search: TokenSearchField,\n    keyword: z.string(),\n    orderBy: TokenOrderBy,\n    queryMode: SonamuQueryMode,\n    id: zArrayable(z.number().int().positive()),\n    sonamuFilter: z.custom<ApplySonamuFilter<TokenBaseSchema, never, never>>(),\n  })\n  .partial();\nexport type TokenBaseListParams = z.infer<typeof TokenBaseListParams>;\n\n// Subsets: RequestLog\nexport const RequestLogSubsetA = z.object({\n  id: z.int(),\n  created_at: z.date(),\n  token_name: z.string().max(100).nullable(),\n  project_name: z.string().max(50).nullable(),\n  model_name: z.string().max(255).nullable(),\n  requested_model_name: z.string().max(255).nullable(),\n  fallback_count: z.int().nullable(),\n  user_prompt: z.string().nullable(),\n  system_prompt: z.string().nullable(),\n  response: z.string(),\n  input_tokens: z.int(),\n  output_tokens: z.int(),\n  cache_read_tokens: z.int(),\n  cache_creation_tokens: z.int(),\n  cache_creation_5m_tokens: z.int().nullable(),\n  cache_creation_1h_tokens: z.int().nullable(),\n  duration_ms: z.int(),\n  ttft_ms: z.int(),\n  cost_usd: z.int().nullable(),\n  cost_source: z.string().max(20).nullable(),\n  image_cost_usd: z.int().nullable(),\n  image_cost_method: z.string().max(100).nullable(),\n  effort: z.string().max(10).nullable(),\n  history: HistoryItems.nullable(),\n  tools: ToolDefinitions.nullable(),\n  status: RequestLogStatus,\n  error_message: z.string().nullable(),\n  tool_call_count: z.int(),\n  is_image_generation: z.boolean(),\n});\nexport type RequestLogSubsetA = z.infer<typeof RequestLogSubsetA>;\nexport const RequestLogSubsetP = z.object({\n  id: z.int(),\n  created_at: z.date(),\n  token_name: z.string().max(100).nullable(),\n  project_name: z.string().max(50).nullable(),\n  model_name: z.string().max(255).nullable(),\n  requested_model_name: z.string().max(255).nullable(),\n  fallback_count: z.int().nullable(),\n  input_tokens: z.int(),\n  output_tokens: z.int(),\n  cache_read_tokens: z.int(),\n  cache_creation_tokens: z.int(),\n  cache_creation_5m_tokens: z.int().nullable(),\n  cache_creation_1h_tokens: z.int().nullable(),\n  duration_ms: z.int(),\n  ttft_ms: z.int(),\n  cost_usd: z.int().nullable(),\n  cost_source: z.string().max(20).nullable(),\n  image_cost_usd: z.int().nullable(),\n  image_cost_method: z.string().max(100).nullable(),\n  effort: z.string().max(10).nullable(),\n  status: RequestLogStatus,\n  tool_call_count: z.int(),\n  is_image_generation: z.boolean(),\n});\nexport type RequestLogSubsetP = z.infer<typeof RequestLogSubsetP>;\nexport const RequestLogSubsetC = z.object({\n  id: z.int(),\n  token_name: z.string().max(100).nullable(),\n  model_name: z.string().max(255).nullable(),\n  input_tokens: z.int(),\n  output_tokens: z.int(),\n  cache_read_tokens: z.int(),\n  cache_creation_tokens: z.int(),\n  cache_creation_5m_tokens: z.int().nullable(),\n  cache_creation_1h_tokens: z.int().nullable(),\n  cost_usd: z.int().nullable(),\n  cost_source: z.string().max(20).nullable(),\n});\nexport type RequestLogSubsetC = z.infer<typeof RequestLogSubsetC>;\nexport type RequestLogSubsetMapping = {\n  A: RequestLogSubsetA;\n  P: RequestLogSubsetP;\n  C: RequestLogSubsetC;\n};\nexport const RequestLogSubsetKey = z.enum([\"A\", \"P\", \"C\"]);\nexport type RequestLogSubsetKey = z.infer<typeof RequestLogSubsetKey>;\n\n// Subsets: RequestLogStep\nexport const RequestLogStepSubsetA = z.object({\n  id: z.int(),\n  created_at: z.date(),\n  step_index: z.int(),\n  type: RequestLogStepType,\n  model_name: z.string().max(255).nullable(),\n  requested_model_name: z.string().max(255).nullable(),\n  fallback_count: z.int().nullable(),\n  input_tokens: z.int().nullable(),\n  output_tokens: z.int().nullable(),\n  cache_read_tokens: z.int().nullable(),\n  cache_creation_tokens: z.int().nullable(),\n  cache_creation_5m_tokens: z.int().nullable(),\n  cache_creation_1h_tokens: z.int().nullable(),\n  cost_usd: z.int().nullable(),\n  cost_source: z.string().max(20).nullable(),\n  duration_ms: z.int().nullable(),\n  ttft_ms: z.int().nullable(),\n  finish_reason: z.string().max(20).nullable(),\n  reasoning_text: z.string().nullable(),\n  reasoning_tokens: z.int().nullable(),\n  tool_call_index: z.int().nullable(),\n  tool_call_id: z.string().max(100).nullable(),\n  tool_name: z.string().max(100).nullable(),\n  tool_args: z.string().nullable(),\n  tool_result: z.string().nullable(),\n  tool_duration_ms: z.int().nullable(),\n  error: z.string().nullable(),\n});\nexport type RequestLogStepSubsetA = z.infer<typeof RequestLogStepSubsetA>;\nexport const RequestLogStepSubsetT = z.object({\n  id: z.int(),\n  created_at: z.date(),\n  step_index: z.int(),\n  type: RequestLogStepType,\n  model_name: z.string().max(255).nullable(),\n  requested_model_name: z.string().max(255).nullable(),\n  fallback_count: z.int().nullable(),\n  input_tokens: z.int().nullable(),\n  output_tokens: z.int().nullable(),\n  cache_read_tokens: z.int().nullable(),\n  cache_creation_tokens: z.int().nullable(),\n  cache_creation_5m_tokens: z.int().nullable(),\n  cache_creation_1h_tokens: z.int().nullable(),\n  cost_usd: z.int().nullable(),\n  cost_source: z.string().max(20).nullable(),\n  duration_ms: z.int().nullable(),\n  ttft_ms: z.int().nullable(),\n  finish_reason: z.string().max(20).nullable(),\n  reasoning_tokens: z.int().nullable(),\n  tool_call_index: z.int().nullable(),\n  tool_call_id: z.string().max(100).nullable(),\n  tool_name: z.string().max(100).nullable(),\n  tool_duration_ms: z.int().nullable(),\n  error: z.string().nullable(),\n});\nexport type RequestLogStepSubsetT = z.infer<typeof RequestLogStepSubsetT>;\nexport const RequestLogStepSubsetI = z.object({\n  id: z.int(),\n  tool_args: z.string().nullable(),\n});\nexport type RequestLogStepSubsetI = z.infer<typeof RequestLogStepSubsetI>;\nexport type RequestLogStepSubsetMapping = {\n  A: RequestLogStepSubsetA;\n  T: RequestLogStepSubsetT;\n  I: RequestLogStepSubsetI;\n};\nexport const RequestLogStepSubsetKey = z.enum([\"A\", \"T\", \"I\"]);\nexport type RequestLogStepSubsetKey = z.infer<typeof RequestLogStepSubsetKey>;\n\n// Subsets: Setting\nexport const SettingSubsetA = z.object({\n  id: z.int(),\n  created_at: z.date(),\n  key: z.string().max(100),\n  value: z.string(),\n  updated_at: z.date().nullable(),\n});\nexport type SettingSubsetA = z.infer<typeof SettingSubsetA>;\nexport type SettingSubsetMapping = {\n  A: SettingSubsetA;\n};\nexport const SettingSubsetKey = z.enum([\"A\"]);\nexport type SettingSubsetKey = z.infer<typeof SettingSubsetKey>;\n\n// Subsets: Token\nexport const TokenSubsetA = z.object({\n  id: z.int(),\n  created_at: z.date(),\n  provider: z.string().max(20),\n  credentials: TokenCredentials,\n  name: z.string(),\n  active: z.boolean(),\n  ord: z.int(),\n  quota_threshold: z.int().nullable(),\n  weight: z.int(),\n});\nexport type TokenSubsetA = z.infer<typeof TokenSubsetA>;\nexport type TokenSubsetMapping = {\n  A: TokenSubsetA;\n};\nexport const TokenSubsetKey = z.enum([\"A\"]);\nexport type TokenSubsetKey = z.infer<typeof TokenSubsetKey>;\n"],"mappings":"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"}