@cartanova/qgrid-cli 2.4.3 → 2.4.4

package/bundle/dist/sonamu.config.js

@@ -1,6 +1,5 @@
 import "./_virtual/_rolldown/runtime.js";
 import { QgridDispatcher } from "./application/qgrid/qgrid.dispatcher.js";
-import { TokenModel } from "./application/token/token.model.js";
 import { QgridFrame } from "./application/qgrid/qgrid.frame.js";
 import { TokenSubscriber } from "./application/qgrid/token-subscriber.js";
 import { ensureTokensTrigger } from "./application/qgrid/token-trigger-setup.js";
@@ -144,14 +143,6 @@ var sonamu_config_default = defineConfig({
 		lifecycle: {
 			onStart: async () => {
 				const log = getLogger(["qgrid", "startup"]);
-				try {
-					const knex = TokenModel.getDB("w");
-					const migrationsDir = path.join(import.meta.dirname, "../src/migrations");
-					const [batch, migrations] = await knex.migrate.latest({ directory: migrationsDir });
-					if (migrations.length > 0) log.info(`migration: ${migrations.length} applied (batch ${batch})`);
-				} catch (e) {
-					log.warn(`migration skipped: ${e.message}`);
-				}
 				let triggerReady = true;
 				try {
 					await ensureTokensTrigger(connConfig);
@@ -204,4 +195,4 @@ var sonamu_config_default = defineConfig({
 //#endregion
 export { sonamu_config_default as default };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"sonamu.config.js","names":["cacheDrivers"],"sources":["../src/sonamu.config.ts"],"sourcesContent":["import path from \"path\";\n\nimport { getConsoleSink } from \"@logtape/logtape\";\nimport { getLogger } from \"@logtape/logtape\";\nimport { getPrettyFormatter } from \"@logtape/pretty\";\nimport dotenv from \"dotenv\";\nimport { CachePresets, defineConfig } from \"sonamu\";\nimport { drivers as cacheDrivers, store } from \"sonamu/cache\";\n\nimport { QgridDispatcher } from \"./application/qgrid/qgrid.dispatcher\";\nimport { QgridFrame } from \"./application/qgrid/qgrid.frame\";\nimport { TokenSubscriber } from \"./application/qgrid/token-subscriber\";\nimport { ensureTokensTrigger } from \"./application/qgrid/token-trigger-setup\";\nimport { TokenModel } from \"./application/token/token.model\";\nimport { AnthropicDispatcher } from \"./utils/providers/anthropic/anthropic-dispatcher\";\nimport { OpenAIDispatcher } from \"./utils/providers/openai/openai-dispatcher\";\n\ndotenv.config({ path: path.join(import.meta.dirname, \"../.env\") });\n\nconst host = process.env.HOST ?? \"localhost\";\nconst port = Number(process.env.PORT ?? 44900);\n\nconst connConfig = {\n  host: process.env.QGRID_DB_HOST ?? \"localhost\",\n  port: Number(process.env.QGRID_DB_PORT ?? 5432),\n  user: process.env.QGRID_DB_USER ?? \"postgres\",\n  password: process.env.QGRID_DB_PASSWORD ?? \"postgres\",\n  database: process.env.QGRID_DB_NAME ?? \"qgrid\",\n};\n\nexport default defineConfig({\n  projectName: process.env.PROJECT_NAME ?? \"Qgrid\",\n  database: {\n    name: \"qgrid\",\n    defaultOptions: {\n      connection: {\n        ...connConfig,\n        keepAlive: true,\n        keepAliveInitialDelayMillis: 10000,\n      },\n    },\n    environments: {\n      fixture: {\n        connection: {\n          ...connConfig,\n          database: process.env.QGRID_DB_NAME,\n        },\n      },\n      test: {\n        connection: {\n          ...connConfig,\n          database: process.env.QGRID_DB_NAME,\n        },\n      },\n    },\n  },\n  api: {\n    dir: \"api\",\n    timezone: \"Asia/Seoul\",\n    route: {\n      prefix: \"/api\",\n    },\n  },\n  i18n: {\n    defaultLocale: \"ko\",\n    supportedLocales: [\"ko\", \"en\"],\n  },\n  sync: {\n    targets: [\"web\"],\n  },\n  test: {\n    parallel: true,\n    maxWorkers: 4,\n    devRunner: { enabled: true },\n  },\n  logging: {\n    sinks: {\n      console: getConsoleSink({\n        formatter: getPrettyFormatter({\n          timestamp: \"time\",\n          categoryWidth: 20,\n          categoryTruncate: \"middle\",\n        }),\n      }),\n    },\n    loggers: [\n      // qgrid 로그 (요청 분배, oauth/usage API)\n      { category: [\"qgrid\"], sinks: [\"console\"], lowestLevel: \"info\" },\n      // sonamu 로그는 warning 이상만\n      { category: [\"sonamu\"], sinks: [\"console\"], lowestLevel: \"warning\" },\n      // fastify 로그 차단\n      { category: [\"fastify\"], sinks: [], lowestLevel: \"fatal\" },\n    ],\n  },\n  server: {\n    listen: { port, host },\n    fastify: {\n      bodyLimit: 10 * 1024 * 1024,\n    },\n    plugins: {\n      formbody: true,\n      qs: true,\n      sse: true,\n      multipart: { limits: { fileSize: 1024 * 1024 * 30 } },\n      static: {\n        root: path.join(import.meta.dirname, \"/../\", \"public\"),\n        prefix: \"/api/public\",\n      },\n      custom: (server) => {\n        // OAuth 콜백 — Anthropic이 /callback으로 리다이렉트\n        server.get(\"/callback\", async (request, reply) => {\n          const { code, state } = request.query as { code?: string; state?: string };\n          if (!code || !state) {\n            return reply.redirect(\"/?oauth=error&reason=missing_params\");\n          }\n          try {\n            return QgridFrame.handleOAuthCallback(code, state, reply);\n          } catch (e) {\n            return reply.redirect(\n              `/?oauth=error&reason=${encodeURIComponent((e as Error).message)}`,\n            );\n          }\n        });\n\n        // OpenAI OAuth 는 codex app-server 가 자체 callback 서버를 올림\n        // handleOpenAICallback 불필요 — oauthCompleteOpenAI API 로 완료 확인\n      },\n    },\n    apiConfig: {\n      contextProvider: (defaultContext, request) => {\n        return {\n          ...defaultContext,\n          ip: request.ip,\n          body: request.body,\n        };\n      },\n      guardHandler: () => {},\n      cacheControlHandler: (req) => {\n        switch (req.type) {\n          case \"assets\":\n            // Hash 포함된 파일: 영구 캐시\n            if (req.path.match(/-[a-f0-9]+\\./)) {\n              return CachePresets.immutable;\n            }\n            return CachePresets.longLived;\n\n          case \"api\":\n            // GET 요청만 캐싱 고려\n            if (req.method === \"GET\") {\n              // 특정 경로는 짧은 캐시\n              if (req.path.startsWith(\"/api/static-data\")) {\n                return CachePresets.shortLived;\n              }\n              if (req.path.startsWith(\"/api/terms\")) {\n                return CachePresets.mediumLived;\n              }\n            }\n            // 기본: 캐시 없음\n            return CachePresets.noCache;\n\n          case \"ssr\":\n            // SSR 페이지: 10초 캐시\n            return CachePresets.ssr;\n\n          case \"csr\":\n            // CSR fallback (index.html): 1분 캐시\n            return CachePresets.shortLived;\n        }\n        return CachePresets.noCache;\n      },\n    },\n    cache: {\n      default: \"main\",\n      stores: {\n        main: store().useL1Layer(cacheDrivers.memory({ maxSize: \"50mb\" })),\n      },\n      ttl: \"5m\",\n      prefix: \"\",\n    },\n    lifecycle: {\n      onStart: async () => {\n        const log = getLogger([\"qgrid\", \"startup\"]);\n\n        try {\n          const knex = TokenModel.getDB(\"w\");\n          const migrationsDir = path.join(import.meta.dirname, \"../src/migrations\");\n          const [batch, migrations] = await knex.migrate.latest({ directory: migrationsDir });\n          if (migrations.length > 0) {\n            log.info(`migration: ${migrations.length} applied (batch ${batch})`);\n          }\n        } catch (e) {\n          log.warn(`migration skipped: ${(e as Error).message}`);\n        }\n\n        let triggerReady = true;\n        try {\n          await ensureTokensTrigger(connConfig);\n        } catch (e) {\n          triggerReady = false;\n          log.warn(`trigger setup failed: ${(e as Error).message}`);\n        }\n\n        const subscriber = new TokenSubscriber(connConfig, QgridDispatcher);\n        QgridDispatcher.subscriber = subscriber;\n\n        const started = await subscriber.start();\n\n        try {\n          const openaiDispatcher = new OpenAIDispatcher();\n          await openaiDispatcher.start();\n          QgridDispatcher.openaiDispatcher = openaiDispatcher;\n        } catch (e) {\n          log.warn(`openai dispatcher failed: ${(e as Error).message}`);\n        }\n\n        try {\n          const anthropicDispatcher = new AnthropicDispatcher();\n          await anthropicDispatcher.start();\n          QgridDispatcher.anthropicDispatcher = anthropicDispatcher;\n        } catch (e) {\n          log.warn(`anthropic dispatcher failed: ${(e as Error).message}`);\n        }\n\n        const anthropicCount = QgridDispatcher.anthropicDispatcher?.tokenCount ?? 0;\n        const openaiReady = QgridDispatcher.openaiDispatcher?.readyWorkerCount ?? 0;\n        const openaiTotal = QgridDispatcher.openaiDispatcher?.workerCount ?? 0;\n\n        log.info(`listening on http://${host}:${port}`);\n        log.info(`anthropic: ${anthropicCount} tokens ready`);\n        log.info(`openai: ${openaiReady}/${openaiTotal} tokens ready`);\n        log.info(\n          `subscriber: ${started ? \"LISTEN active\" : \"degraded\"}${triggerReady ? \"\" : \", trigger failed\"}`,\n        );\n      },\n      onShutdown: async () => {\n        const log = getLogger([\"qgrid\", \"startup\"]);\n        if (QgridDispatcher.openaiDispatcher) {\n          await QgridDispatcher.openaiDispatcher.stop();\n        }\n        if (QgridDispatcher.anthropicDispatcher) {\n          await QgridDispatcher.anthropicDispatcher.stop();\n        }\n        if (QgridDispatcher.subscriber) {\n          await QgridDispatcher.subscriber.stop();\n        }\n        log.info(\"graceful shutdown\");\n      },\n      onError: (error, _request, reply) => {\n        getLogger([\"qgrid\"]).error(`${error}`);\n        reply.status(500).send({\n          name: error.name,\n          message: error.message,\n        });\n      },\n    },\n  },\n});\n"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"sonamu.config.js","names":["cacheDrivers"],"sources":["../src/sonamu.config.ts"],"sourcesContent":["import path from \"path\";\n\nimport { getConsoleSink } from \"@logtape/logtape\";\nimport { getLogger } from \"@logtape/logtape\";\nimport { getPrettyFormatter } from \"@logtape/pretty\";\nimport dotenv from \"dotenv\";\nimport { CachePresets, defineConfig } from \"sonamu\";\nimport { drivers as cacheDrivers, store } from \"sonamu/cache\";\n\nimport { QgridDispatcher } from \"./application/qgrid/qgrid.dispatcher\";\nimport { QgridFrame } from \"./application/qgrid/qgrid.frame\";\nimport { TokenSubscriber } from \"./application/qgrid/token-subscriber\";\nimport { ensureTokensTrigger } from \"./application/qgrid/token-trigger-setup\";\nimport { AnthropicDispatcher } from \"./utils/providers/anthropic/anthropic-dispatcher\";\nimport { OpenAIDispatcher } from \"./utils/providers/openai/openai-dispatcher\";\n\ndotenv.config({ path: path.join(import.meta.dirname, \"../.env\") });\n\nconst host = process.env.HOST ?? \"localhost\";\nconst port = Number(process.env.PORT ?? 44900);\n\nconst connConfig = {\n  host: process.env.QGRID_DB_HOST ?? \"localhost\",\n  port: Number(process.env.QGRID_DB_PORT ?? 5432),\n  user: process.env.QGRID_DB_USER ?? \"postgres\",\n  password: process.env.QGRID_DB_PASSWORD ?? \"postgres\",\n  database: process.env.QGRID_DB_NAME ?? \"qgrid\",\n};\n\nexport default defineConfig({\n  projectName: process.env.PROJECT_NAME ?? \"Qgrid\",\n  database: {\n    name: \"qgrid\",\n    defaultOptions: {\n      connection: {\n        ...connConfig,\n        keepAlive: true,\n        keepAliveInitialDelayMillis: 10000,\n      },\n    },\n    environments: {\n      fixture: {\n        connection: {\n          ...connConfig,\n          database: process.env.QGRID_DB_NAME,\n        },\n      },\n      test: {\n        connection: {\n          ...connConfig,\n          database: process.env.QGRID_DB_NAME,\n        },\n      },\n    },\n  },\n  api: {\n    dir: \"api\",\n    timezone: \"Asia/Seoul\",\n    route: {\n      prefix: \"/api\",\n    },\n  },\n  i18n: {\n    defaultLocale: \"ko\",\n    supportedLocales: [\"ko\", \"en\"],\n  },\n  sync: {\n    targets: [\"web\"],\n  },\n  test: {\n    parallel: true,\n    maxWorkers: 4,\n    devRunner: { enabled: true },\n  },\n  logging: {\n    sinks: {\n      console: getConsoleSink({\n        formatter: getPrettyFormatter({\n          timestamp: \"time\",\n          categoryWidth: 20,\n          categoryTruncate: \"middle\",\n        }),\n      }),\n    },\n    loggers: [\n      // qgrid 로그 (요청 분배, oauth/usage API)\n      { category: [\"qgrid\"], sinks: [\"console\"], lowestLevel: \"info\" },\n      // sonamu 로그는 warning 이상만\n      { category: [\"sonamu\"], sinks: [\"console\"], lowestLevel: \"warning\" },\n      // fastify 로그 차단\n      { category: [\"fastify\"], sinks: [], lowestLevel: \"fatal\" },\n    ],\n  },\n  server: {\n    listen: { port, host },\n    fastify: {\n      bodyLimit: 10 * 1024 * 1024,\n    },\n    plugins: {\n      formbody: true,\n      qs: true,\n      sse: true,\n      multipart: { limits: { fileSize: 1024 * 1024 * 30 } },\n      static: {\n        root: path.join(import.meta.dirname, \"/../\", \"public\"),\n        prefix: \"/api/public\",\n      },\n      custom: (server) => {\n        // OAuth 콜백 — Anthropic이 /callback으로 리다이렉트\n        server.get(\"/callback\", async (request, reply) => {\n          const { code, state } = request.query as { code?: string; state?: string };\n          if (!code || !state) {\n            return reply.redirect(\"/?oauth=error&reason=missing_params\");\n          }\n          try {\n            return QgridFrame.handleOAuthCallback(code, state, reply);\n          } catch (e) {\n            return reply.redirect(\n              `/?oauth=error&reason=${encodeURIComponent((e as Error).message)}`,\n            );\n          }\n        });\n\n        // OpenAI OAuth 는 codex app-server 가 자체 callback 서버를 올림\n        // handleOpenAICallback 불필요 — oauthCompleteOpenAI API 로 완료 확인\n      },\n    },\n    apiConfig: {\n      contextProvider: (defaultContext, request) => {\n        return {\n          ...defaultContext,\n          ip: request.ip,\n          body: request.body,\n        };\n      },\n      guardHandler: () => {},\n      cacheControlHandler: (req) => {\n        switch (req.type) {\n          case \"assets\":\n            // Hash 포함된 파일: 영구 캐시\n            if (req.path.match(/-[a-f0-9]+\\./)) {\n              return CachePresets.immutable;\n            }\n            return CachePresets.longLived;\n\n          case \"api\":\n            // GET 요청만 캐싱 고려\n            if (req.method === \"GET\") {\n              // 특정 경로는 짧은 캐시\n              if (req.path.startsWith(\"/api/static-data\")) {\n                return CachePresets.shortLived;\n              }\n              if (req.path.startsWith(\"/api/terms\")) {\n                return CachePresets.mediumLived;\n              }\n            }\n            // 기본: 캐시 없음\n            return CachePresets.noCache;\n\n          case \"ssr\":\n            // SSR 페이지: 10초 캐시\n            return CachePresets.ssr;\n\n          case \"csr\":\n            // CSR fallback (index.html): 1분 캐시\n            return CachePresets.shortLived;\n        }\n        return CachePresets.noCache;\n      },\n    },\n    cache: {\n      default: \"main\",\n      stores: {\n        main: store().useL1Layer(cacheDrivers.memory({ maxSize: \"50mb\" })),\n      },\n      ttl: \"5m\",\n      prefix: \"\",\n    },\n    lifecycle: {\n      onStart: async () => {\n        const log = getLogger([\"qgrid\", \"startup\"]);\n\n        let triggerReady = true;\n        try {\n          await ensureTokensTrigger(connConfig);\n        } catch (e) {\n          triggerReady = false;\n          log.warn(`trigger setup failed: ${(e as Error).message}`);\n        }\n\n        const subscriber = new TokenSubscriber(connConfig, QgridDispatcher);\n        QgridDispatcher.subscriber = subscriber;\n\n        const started = await subscriber.start();\n\n        try {\n          const openaiDispatcher = new OpenAIDispatcher();\n          await openaiDispatcher.start();\n          QgridDispatcher.openaiDispatcher = openaiDispatcher;\n        } catch (e) {\n          log.warn(`openai dispatcher failed: ${(e as Error).message}`);\n        }\n\n        try {\n          const anthropicDispatcher = new AnthropicDispatcher();\n          await anthropicDispatcher.start();\n          QgridDispatcher.anthropicDispatcher = anthropicDispatcher;\n        } catch (e) {\n          log.warn(`anthropic dispatcher failed: ${(e as Error).message}`);\n        }\n\n        const anthropicCount = QgridDispatcher.anthropicDispatcher?.tokenCount ?? 0;\n        const openaiReady = QgridDispatcher.openaiDispatcher?.readyWorkerCount ?? 0;\n        const openaiTotal = QgridDispatcher.openaiDispatcher?.workerCount ?? 0;\n\n        log.info(`listening on http://${host}:${port}`);\n        log.info(`anthropic: ${anthropicCount} tokens ready`);\n        log.info(`openai: ${openaiReady}/${openaiTotal} tokens ready`);\n        log.info(\n          `subscriber: ${started ? \"LISTEN active\" : \"degraded\"}${triggerReady ? \"\" : \", trigger failed\"}`,\n        );\n      },\n      onShutdown: async () => {\n        const log = getLogger([\"qgrid\", \"startup\"]);\n        if (QgridDispatcher.openaiDispatcher) {\n          await QgridDispatcher.openaiDispatcher.stop();\n        }\n        if (QgridDispatcher.anthropicDispatcher) {\n          await QgridDispatcher.anthropicDispatcher.stop();\n        }\n        if (QgridDispatcher.subscriber) {\n          await QgridDispatcher.subscriber.stop();\n        }\n        log.info(\"graceful shutdown\");\n      },\n      onError: (error, _request, reply) => {\n        getLogger([\"qgrid\"]).error(`${error}`);\n        reply.status(500).send({\n          name: error.name,\n          message: error.message,\n        });\n      },\n    },\n  },\n});\n"],"mappings":";;;;;;;;;;;;;;AAgBA,OAAO,OAAO,EAAE,MAAM,KAAK,KAAK,OAAO,KAAK,SAAS,UAAU,EAAE,CAAC;AAElE,MAAM,OAAO,QAAQ,IAAI,QAAQ;AACjC,MAAM,OAAO,OAAO,QAAQ,IAAI,QAAQ,MAAM;AAE9C,MAAM,aAAa;CACjB,MAAM,QAAQ,IAAI,iBAAiB;CACnC,MAAM,OAAO,QAAQ,IAAI,iBAAiB,KAAK;CAC/C,MAAM,QAAQ,IAAI,iBAAiB;CACnC,UAAU,QAAQ,IAAI,qBAAqB;CAC3C,UAAU,QAAQ,IAAI,iBAAiB;CACxC;AAED,IAAA,wBAAe,aAAa;CAC1B,aAAa,QAAQ,IAAI,gBAAgB;CACzC,UAAU;EACR,MAAM;EACN,gBAAgB,EACd,YAAY;GACV,GAAG;GACH,WAAW;GACX,6BAA6B;GAC9B,EACF;EACD,cAAc;GACZ,SAAS,EACP,YAAY;IACV,GAAG;IACH,UAAU,QAAQ,IAAI;IACvB,EACF;GACD,MAAM,EACJ,YAAY;IACV,GAAG;IACH,UAAU,QAAQ,IAAI;IACvB,EACF;GACF;EACF;CACD,KAAK;EACH,KAAK;EACL,UAAU;EACV,OAAO,EACL,QAAQ,QACT;EACF;CACD,MAAM;EACJ,eAAe;EACf,kBAAkB,CAAC,MAAM,KAAK;EAC/B;CACD,MAAM,EACJ,SAAS,CAAC,MAAM,EACjB;CACD,MAAM;EACJ,UAAU;EACV,YAAY;EACZ,WAAW,EAAE,SAAS,MAAM;EAC7B;CACD,SAAS;EACP,OAAO,EACL,SAAS,eAAe,EACtB,WAAW,mBAAmB;GAC5B,WAAW;GACX,eAAe;GACf,kBAAkB;GACnB,CAAC,EACH,CAAC,EACH;EACD,SAAS;GAEP;IAAE,UAAU,CAAC,QAAQ;IAAE,OAAO,CAAC,UAAU;IAAE,aAAa;IAAQ;GAEhE;IAAE,UAAU,CAAC,SAAS;IAAE,OAAO,CAAC,UAAU;IAAE,aAAa;IAAW;GAEpE;IAAE,UAAU,CAAC,UAAU;IAAE,OAAO,EAAE;IAAE,aAAa;IAAS;GAC3D;EACF;CACD,QAAQ;EACN,QAAQ;GAAE;GAAM;GAAM;EACtB,SAAS,EACP,WAAW,KAAK,OAAO,MACxB;EACD,SAAS;GACP,UAAU;GACV,IAAI;GACJ,KAAK;GACL,WAAW,EAAE,QAAQ,EAAE,UAAU,OAAO,OAAO,IAAI,EAAE;GACrD,QAAQ;IACN,MAAM,KAAK,KAAK,OAAO,KAAK,SAAS,QAAQ,SAAS;IACtD,QAAQ;IACT;GACD,SAAS,WAAW;AAElB,WAAO,IAAI,aAAa,OAAO,SAAS,UAAU;KAChD,MAAM,EAAE,MAAM,UAAU,QAAQ;AAChC,SAAI,CAAC,QAAQ,CAAC,MACZ,QAAO,MAAM,SAAS,sCAAsC;AAE9D,SAAI;AACF,aAAO,WAAW,oBAAoB,MAAM,OAAO,MAAM;cAClD,GAAG;AACV,aAAO,MAAM,SACX,wBAAwB,mBAAoB,EAAY,QAAQ,GACjE;;MAEH;;GAKL;EACD,WAAW;GACT,kBAAkB,gBAAgB,YAAY;AAC5C,WAAO;KACL,GAAG;KACH,IAAI,QAAQ;KACZ,MAAM,QAAQ;KACf;;GAEH,oBAAoB;GACpB,sBAAsB,QAAQ;AAC5B,YAAQ,IAAI,MAAZ;KACE,KAAK;AAEH,UAAI,IAAI,KAAK,MAAM,eAAe,CAChC,QAAO,aAAa;AAEtB,aAAO,aAAa;KAEtB,KAAK;AAEH,UAAI,IAAI,WAAW,OAAO;AAExB,WAAI,IAAI,KAAK,WAAW,mBAAmB,CACzC,QAAO,aAAa;AAEtB,WAAI,IAAI,KAAK,WAAW,aAAa,CACnC,QAAO,aAAa;;AAIxB,aAAO,aAAa;KAEtB,KAAK,MAEH,QAAO,aAAa;KAEtB,KAAK,MAEH,QAAO,aAAa;;AAExB,WAAO,aAAa;;GAEvB;EACD,OAAO;GACL,SAAS;GACT,QAAQ,EACN,MAAM,OAAO,CAAC,WAAWA,QAAa,OAAO,EAAE,SAAS,QAAQ,CAAC,CAAC,EACnE;GACD,KAAK;GACL,QAAQ;GACT;EACD,WAAW;GACT,SAAS,YAAY;IACnB,MAAM,MAAM,UAAU,CAAC,SAAS,UAAU,CAAC;IAE3C,IAAI,eAAe;AACnB,QAAI;AACF,WAAM,oBAAoB,WAAW;aAC9B,GAAG;AACV,oBAAe;AACf,SAAI,KAAK,yBAA0B,EAAY,UAAU;;IAG3D,MAAM,aAAa,IAAI,gBAAgB,YAAY,gBAAgB;AACnE,oBAAgB,aAAa;IAE7B,MAAM,UAAU,MAAM,WAAW,OAAO;AAExC,QAAI;KACF,MAAM,mBAAmB,IAAI,kBAAkB;AAC/C,WAAM,iBAAiB,OAAO;AAC9B,qBAAgB,mBAAmB;aAC5B,GAAG;AACV,SAAI,KAAK,6BAA8B,EAAY,UAAU;;AAG/D,QAAI;KACF,MAAM,sBAAsB,IAAI,qBAAqB;AACrD,WAAM,oBAAoB,OAAO;AACjC,qBAAgB,sBAAsB;aAC/B,GAAG;AACV,SAAI,KAAK,gCAAiC,EAAY,UAAU;;IAGlE,MAAM,iBAAiB,gBAAgB,qBAAqB,cAAc;IAC1E,MAAM,cAAc,gBAAgB,kBAAkB,oBAAoB;IAC1E,MAAM,cAAc,gBAAgB,kBAAkB,eAAe;AAErE,QAAI,KAAK,uBAAuB,KAAK,GAAG,OAAO;AAC/C,QAAI,KAAK,cAAc,eAAe,eAAe;AACrD,QAAI,KAAK,WAAW,YAAY,GAAG,YAAY,eAAe;AAC9D,QAAI,KACF,eAAe,UAAU,kBAAkB,aAAa,eAAe,KAAK,qBAC7E;;GAEH,YAAY,YAAY;IACtB,MAAM,MAAM,UAAU,CAAC,SAAS,UAAU,CAAC;AAC3C,QAAI,gBAAgB,iBAClB,OAAM,gBAAgB,iBAAiB,MAAM;AAE/C,QAAI,gBAAgB,oBAClB,OAAM,gBAAgB,oBAAoB,MAAM;AAElD,QAAI,gBAAgB,WAClB,OAAM,gBAAgB,WAAW,MAAM;AAEzC,QAAI,KAAK,oBAAoB;;GAE/B,UAAU,OAAO,UAAU,UAAU;AACnC,cAAU,CAAC,QAAQ,CAAC,CAAC,MAAM,GAAG,QAAQ;AACtC,UAAM,OAAO,IAAI,CAAC,KAAK;KACrB,MAAM,MAAM;KACZ,SAAS,MAAM;KAChB,CAAC;;GAEL;EACF;CACF,CAAC"}

package/bundle/dist/startup-migrations.js

@@ -0,0 +1,21 @@
+import "./_virtual/_rolldown/runtime.js";
+import { TokenModel } from "./application/token/token.model.js";
+import { getLogger } from "@logtape/logtape";
+import path from "node:path";
+//#region src/startup-migrations.ts
+async function runRequiredMigrations() {
+	const log = getLogger(["qgrid", "startup"]);
+	try {
+		const knex = TokenModel.getDB("w");
+		const migrationsDir = path.join(import.meta.dirname, "../src/migrations");
+		const [batch, migrations] = await knex.migrate.latest({ directory: migrationsDir });
+		if (migrations.length > 0) log.info(`migration: ${migrations.length} applied (batch ${batch})`);
+	} catch (error) {
+		log.error(`migration failed: ${error.message}`);
+		process.exit(1);
+	}
+}
+//#endregion
+export { runRequiredMigrations };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RhcnR1cC1taWdyYXRpb25zLmpzIiwibmFtZXMiOltdLCJzb3VyY2VzIjpbIi4uL3NyYy9zdGFydHVwLW1pZ3JhdGlvbnMudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHBhdGggZnJvbSBcIm5vZGU6cGF0aFwiO1xuXG5pbXBvcnQgeyBnZXRMb2dnZXIgfSBmcm9tIFwiQGxvZ3RhcGUvbG9ndGFwZVwiO1xuXG5pbXBvcnQgeyBUb2tlbk1vZGVsIH0gZnJvbSBcIi4vYXBwbGljYXRpb24vdG9rZW4vdG9rZW4ubW9kZWxcIjtcblxuZXhwb3J0IGFzeW5jIGZ1bmN0aW9uIHJ1blJlcXVpcmVkTWlncmF0aW9ucygpOiBQcm9taXNlPHZvaWQ+IHtcbiAgY29uc3QgbG9nID0gZ2V0TG9nZ2VyKFtcInFncmlkXCIsIFwic3RhcnR1cFwiXSk7XG4gIHRyeSB7XG4gICAgY29uc3Qga25leCA9IFRva2VuTW9kZWwuZ2V0REIoXCJ3XCIpO1xuICAgIGNvbnN0IG1pZ3JhdGlvbnNEaXIgPSBwYXRoLmpvaW4oaW1wb3J0Lm1ldGEuZGlybmFtZSwgXCIuLi9zcmMvbWlncmF0aW9uc1wiKTtcbiAgICBjb25zdCBbYmF0Y2gsIG1pZ3JhdGlvbnNdID0gYXdhaXQga25leC5taWdyYXRlLmxhdGVzdCh7IGRpcmVjdG9yeTogbWlncmF0aW9uc0RpciB9KTtcbiAgICBpZiAobWlncmF0aW9ucy5sZW5ndGggPiAwKSB7XG4gICAgICBsb2cuaW5mbyhgbWlncmF0aW9uOiAke21pZ3JhdGlvbnMubGVuZ3RofSBhcHBsaWVkIChiYXRjaCAke2JhdGNofSlgKTtcbiAgICB9XG4gIH0gY2F0Y2ggKGVycm9yKSB7XG4gICAgbG9nLmVycm9yKGBtaWdyYXRpb24gZmFpbGVkOiAkeyhlcnJvciBhcyBFcnJvcikubWVzc2FnZX1gKTtcbiAgICBwcm9jZXNzLmV4aXQoMSk7XG4gIH1cbn1cbiJdLCJtYXBwaW5ncyI6Ijs7Ozs7QUFNQSxlQUFzQix3QkFBdUM7Q0FDM0QsTUFBTSxNQUFNLFVBQVUsQ0FBQyxTQUFTLFVBQVUsQ0FBQztBQUMzQyxLQUFJO0VBQ0YsTUFBTSxPQUFPLFdBQVcsTUFBTSxJQUFJO0VBQ2xDLE1BQU0sZ0JBQWdCLEtBQUssS0FBSyxPQUFPLEtBQUssU0FBUyxvQkFBb0I7RUFDekUsTUFBTSxDQUFDLE9BQU8sY0FBYyxNQUFNLEtBQUssUUFBUSxPQUFPLEVBQUUsV0FBVyxlQUFlLENBQUM7QUFDbkYsTUFBSSxXQUFXLFNBQVMsRUFDdEIsS0FBSSxLQUFLLGNBQWMsV0FBVyxPQUFPLGtCQUFrQixNQUFNLEdBQUc7VUFFL0QsT0FBTztBQUNkLE1BQUksTUFBTSxxQkFBc0IsTUFBZ0IsVUFBVTtBQUMxRCxVQUFRLEtBQUssRUFBRSJ9

package/bundle/dist/testing/global.js

@@ -1,12 +1,100 @@
 import "../_virtual/_rolldown/runtime.js";
+import { Client } from "pg";
 import dotenv from "dotenv";
 //#region src/testing/global.ts
 dotenv.config();
-async function setup() {
-	const { setup: sonamuSetup } = await import(new URL("../../node_modules/sonamu/dist/testing/global-setup.js", import.meta.url).href);
-	return sonamuSetup();
+const MAX_WORKERS = 4;
+const TEMPLATE_DB = process.env.QGRID_TEST_DB_NAME ?? "qgrid_test";
+function quoteIdentifier(value) {
+	if (!/^[A-Za-z0-9_]+$/.test(value)) throw new Error(`invalid database identifier: ${value}`);
+	return `"${value}"`;
+}
+function workerDatabaseNames(templateDb, maxWorkers) {
+	return Array.from({ length: maxWorkers }, (_, index) => `${templateDb}_${index + 1}`);
+}
+async function terminateConnections(client, database) {
+	await client.query(`
+      SELECT pg_terminate_backend(pid)
+      FROM pg_stat_activity
+      WHERE datname = $1
+        AND pid <> pg_backend_pid()
+    `, [database]);
+}
+async function recreateWorkerDatabases(client, templateDb, runDatabase, maxWorkers) {
+	const workers = workerDatabaseNames(runDatabase, maxWorkers);
+	for (const database of [...workers, templateDb]) await terminateConnections(client, database);
+	for (const database of workers) {
+		await client.query(`DROP DATABASE IF EXISTS ${quoteIdentifier(database)}`);
+		await client.query(`CREATE DATABASE ${quoteIdentifier(database)} TEMPLATE ${quoteIdentifier(templateDb)} STRATEGY FILE_COPY`);
+	}
+	return workers;
+}
+async function dropWorkerDatabases(client, templateDb, maxWorkers) {
+	const errors = [];
+	for (const database of workerDatabaseNames(templateDb, maxWorkers)) {
+		await terminateConnections(client, database).catch((error) => {
+			errors.push(error);
+		});
+		await client.query(`DROP DATABASE IF EXISTS ${quoteIdentifier(database)}`).catch((error) => {
+			errors.push(error);
+		});
+	}
+	if (errors.length > 0) throw new AggregateError(errors, "failed to clean one or more test databases", { cause: errors[0] });
+}
+function createAdminClient() {
+	return new Client({
+		host: process.env.QGRID_DB_HOST ?? "localhost",
+		port: Number(process.env.QGRID_DB_PORT ?? 5432),
+		user: process.env.QGRID_DB_USER ?? "postgres",
+		password: process.env.QGRID_DB_PASSWORD ?? "postgres",
+		database: "postgres",
+		application_name: "qgrid-vitest-global-setup"
+	});
+}
+function resolveMaxWorkers(project) {
+	const maxWorkers = project?.config?.maxWorkers;
+	return Number.isInteger(maxWorkers) && maxWorkers !== void 0 && maxWorkers > 0 ? maxWorkers : MAX_WORKERS;
+}
+async function provisionWorkerDatabases(createClient, templateDb, runDatabase, maxWorkers) {
+	const client = createClient();
+	await client.connect();
+	try {
+		await recreateWorkerDatabases(client, templateDb, runDatabase, maxWorkers);
+	} catch (setupError) {
+		await client.end().catch(() => {});
+		const cleanupClient = createClient();
+		let cleanupError;
+		try {
+			await cleanupClient.connect();
+			await dropWorkerDatabases(cleanupClient, runDatabase, maxWorkers);
+		} catch (error) {
+			cleanupError = error;
+		} finally {
+			await cleanupClient.end().catch((error) => {
+				cleanupError ??= error;
+			});
+		}
+		if (cleanupError) throw new AggregateError([setupError, cleanupError], "test database setup and cleanup both failed", { cause: setupError });
+		throw setupError;
+	}
+	await client.end();
+}
+async function setup(project) {
+	const runDatabase = process.env.QGRID_TEST_RUN_DB;
+	if (!runDatabase || process.env.QGRID_DB_NAME !== runDatabase) throw new Error("Vitest test database name was not configured consistently");
+	const maxWorkers = resolveMaxWorkers(project);
+	await provisionWorkerDatabases(createAdminClient, TEMPLATE_DB, runDatabase, maxWorkers);
+	return async () => {
+		const teardownClient = createAdminClient();
+		await teardownClient.connect();
+		try {
+			await dropWorkerDatabases(teardownClient, runDatabase, maxWorkers);
+		} finally {
+			await teardownClient.end();
+		}
+	};
 }
 //#endregion
-export { setup };
+export { dropWorkerDatabases, provisionWorkerDatabases, recreateWorkerDatabases, resolveMaxWorkers, setup };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2xvYmFsLmpzIiwibmFtZXMiOltdLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy90ZXN0aW5nL2dsb2JhbC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgZG90ZW52IGZyb20gXCJkb3RlbnZcIjtcblxuZG90ZW52LmNvbmZpZygpO1xuXG50eXBlIFNvbmFtdUdsb2JhbFNldHVwTW9kdWxlID0ge1xuICBzZXR1cDogKCkgPT4gUHJvbWlzZTwoKCkgPT4gUHJvbWlzZTx2b2lkPikgfCB2b2lkPjtcbn07XG5cbi8vIHNvbmFtdS90ZXN0IOydmCBiYXJyZWwgZXhwb3J0IOuKlCBib290c3RyYXAuanMg66W8IO2VqOq7mCDroZzrk5ztlZjqs6AsIGJvb3RzdHJhcC5qcyDripQgdG9wLWxldmVsIOyXkOyEnFxuLy8gdml0ZXN0IOulvCBpbXBvcnQg7ZWc64ukLiBWaXRlc3QgNCBnbG9iYWxTZXR1cCDsu6jthY3siqTtirjsl5DshJzripQg7J20IGltcG9ydCDqsIAgaW50ZXJuYWwgc3RhdGUg7JeQ65+s66W8XG4vLyDrp4zrk6TquLAg65WM66y47JeQIGdsb2JhbC1zZXR1cC5qcyDrp4wg7KeB7KCRIOuhnOuTnO2VnOuLpC5cbmV4cG9ydCBhc3luYyBmdW5jdGlvbiBzZXR1cCgpOiBQcm9taXNlPCgoKSA9PiBQcm9taXNlPHZvaWQ+KSB8IHZvaWQ+IHtcbiAgY29uc3QgZ2xvYmFsU2V0dXBVcmwgPSBuZXcgVVJMKFxuICAgIFwiLi4vLi4vbm9kZV9tb2R1bGVzL3NvbmFtdS9kaXN0L3Rlc3RpbmcvZ2xvYmFsLXNldHVwLmpzXCIsXG4gICAgaW1wb3J0Lm1ldGEudXJsLFxuICApO1xuICBjb25zdCB7IHNldHVwOiBzb25hbXVTZXR1cCB9ID0gKGF3YWl0IGltcG9ydChnbG9iYWxTZXR1cFVybC5ocmVmKSkgYXMgU29uYW11R2xvYmFsU2V0dXBNb2R1bGU7XG5cbiAgcmV0dXJuIHNvbmFtdVNldHVwKCk7XG59XG4iXSwibWFwcGluZ3MiOiI7OztBQUVBLE9BQU8sUUFBUTtBQVNmLGVBQXNCLFFBQStDO0NBS25FLE1BQU0sRUFBRSxPQUFPLGdCQUFpQixNQUFNLE9BSmYsSUFBSSxJQUN6QiwwREFDQSxPQUFPLEtBQUssSUFDYixDQUMyRDtBQUU1RCxRQUFPLGFBQWEifQ==
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"global.js","names":[],"sources":["../../src/testing/global.ts"],"sourcesContent":["import dotenv from \"dotenv\";\nimport { Client } from \"pg\";\n\ndotenv.config();\n\nconst MAX_WORKERS = 4;\nconst TEMPLATE_DB = process.env.QGRID_TEST_DB_NAME ?? \"qgrid_test\";\n\ntype QueryClient = Pick<Client, \"query\">;\ntype AdminClient = Pick<Client, \"connect\" | \"end\" | \"query\">;\ntype AdminClientFactory = () => AdminClient;\ntype VitestProject = { config?: { maxWorkers?: number } };\n\nfunction quoteIdentifier(value: string): string {\n  if (!/^[A-Za-z0-9_]+$/.test(value)) {\n    throw new Error(`invalid database identifier: ${value}`);\n  }\n  return `\"${value}\"`;\n}\n\nfunction workerDatabaseNames(templateDb: string, maxWorkers: number): string[] {\n  return Array.from({ length: maxWorkers }, (_, index) => `${templateDb}_${index + 1}`);\n}\n\nasync function terminateConnections(client: QueryClient, database: string): Promise<void> {\n  await client.query(\n    `\n      SELECT pg_terminate_backend(pid)\n      FROM pg_stat_activity\n      WHERE datname = $1\n        AND pid <> pg_backend_pid()\n    `,\n    [database],\n  );\n}\n\nexport async function recreateWorkerDatabases(\n  client: QueryClient,\n  templateDb: string,\n  runDatabase: string,\n  maxWorkers: number,\n): Promise<string[]> {\n  const workers = workerDatabaseNames(runDatabase, maxWorkers);\n  for (const database of [...workers, templateDb]) {\n    await terminateConnections(client, database);\n  }\n  for (const database of workers) {\n    await client.query(`DROP DATABASE IF EXISTS ${quoteIdentifier(database)}`);\n    await client.query(\n      `CREATE DATABASE ${quoteIdentifier(database)} TEMPLATE ${quoteIdentifier(templateDb)} STRATEGY FILE_COPY`,\n    );\n  }\n  return workers;\n}\n\nexport async function dropWorkerDatabases(\n  client: QueryClient,\n  templateDb: string,\n  maxWorkers: number,\n): Promise<void> {\n  const errors: unknown[] = [];\n  for (const database of workerDatabaseNames(templateDb, maxWorkers)) {\n    await terminateConnections(client, database).catch((error) => {\n      errors.push(error);\n    });\n    await client.query(`DROP DATABASE IF EXISTS ${quoteIdentifier(database)}`).catch((error) => {\n      errors.push(error);\n    });\n  }\n  if (errors.length > 0) {\n    const cleanupError = new AggregateError(errors, \"failed to clean one or more test databases\", {\n      cause: errors[0],\n    });\n    throw cleanupError;\n  }\n}\n\nfunction createAdminClient(): Client {\n  return new Client({\n    host: process.env.QGRID_DB_HOST ?? \"localhost\",\n    port: Number(process.env.QGRID_DB_PORT ?? 5432),\n    user: process.env.QGRID_DB_USER ?? \"postgres\",\n    password: process.env.QGRID_DB_PASSWORD ?? \"postgres\",\n    database: \"postgres\",\n    application_name: \"qgrid-vitest-global-setup\",\n  });\n}\n\nexport function resolveMaxWorkers(project?: VitestProject): number {\n  const maxWorkers = project?.config?.maxWorkers;\n  return Number.isInteger(maxWorkers) && maxWorkers !== undefined && maxWorkers > 0\n    ? maxWorkers\n    : MAX_WORKERS;\n}\n\nexport async function provisionWorkerDatabases(\n  createClient: AdminClientFactory,\n  templateDb: string,\n  runDatabase: string,\n  maxWorkers: number,\n): Promise<void> {\n  const client = createClient();\n  await client.connect();\n  try {\n    await recreateWorkerDatabases(client, templateDb, runDatabase, maxWorkers);\n  } catch (setupError) {\n    await client.end().catch(() => {});\n    const cleanupClient = createClient();\n    let cleanupError: unknown;\n    try {\n      await cleanupClient.connect();\n      await dropWorkerDatabases(cleanupClient, runDatabase, maxWorkers);\n    } catch (error) {\n      cleanupError = error;\n    } finally {\n      await cleanupClient.end().catch((error) => {\n        cleanupError ??= error;\n      });\n    }\n    if (cleanupError) {\n      const combinedError = new AggregateError(\n        [setupError, cleanupError],\n        \"test database setup and cleanup both failed\",\n        { cause: setupError },\n      );\n      throw combinedError;\n    }\n    throw setupError;\n  }\n  await client.end();\n}\n\nexport async function setup(project?: VitestProject): Promise<() => Promise<void>> {\n  const runDatabase = process.env.QGRID_TEST_RUN_DB;\n  if (!runDatabase || process.env.QGRID_DB_NAME !== runDatabase) {\n    throw new Error(\"Vitest test database name was not configured consistently\");\n  }\n  const maxWorkers = resolveMaxWorkers(project);\n  await provisionWorkerDatabases(createAdminClient, TEMPLATE_DB, runDatabase, maxWorkers);\n\n  return async () => {\n    const teardownClient = createAdminClient();\n    await teardownClient.connect();\n    try {\n      await dropWorkerDatabases(teardownClient, runDatabase, maxWorkers);\n    } finally {\n      await teardownClient.end();\n    }\n  };\n}\n"],"mappings":"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"}

package/bundle/dist/testing/test-database-name.js

@@ -0,0 +1,22 @@
+import "../_virtual/_rolldown/runtime.js";
+import { randomUUID } from "node:crypto";
+//#region src/testing/test-database-name.ts
+let configuredRunDatabase;
+function createTestRunDatabaseName(prefix, entropy) {
+	const safePrefix = prefix.replaceAll(/[^A-Za-z0-9_]/g, "_");
+	const safeEntropy = entropy.replaceAll(/[^A-Za-z0-9_]/g, "_");
+	const maxPrefixLength = 63 - safeEntropy.length - 1;
+	return `${safePrefix.slice(0, maxPrefixLength)}_${safeEntropy}`;
+}
+function configureTestRunDatabaseName() {
+	if (configuredRunDatabase) return configuredRunDatabase;
+	const runDatabase = createTestRunDatabaseName(process.env.QGRID_TEST_RUN_DB ?? "qgrid_test", `${process.pid}_${Date.now().toString(36)}_${randomUUID().slice(0, 8)}`);
+	configuredRunDatabase = runDatabase;
+	process.env.QGRID_TEST_RUN_DB = runDatabase;
+	process.env.QGRID_DB_NAME = runDatabase;
+	return runDatabase;
+}
+//#endregion
+export { configureTestRunDatabaseName, createTestRunDatabaseName };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/bundle/dist/utils/providers/anthropic/anthropic-dispatcher.js

@@ -2,6 +2,7 @@ import "../../../_virtual/_rolldown/runtime.js";
 import { getExpiresAt, getRefreshToken } from "../common/credentials.js";
 import { QuotaThresholdExceededError } from "../../../application/qgrid/qgrid.types.js";
 import { TokenModel } from "../../../application/token/token.model.js";
+import { SmoothWeightedRoundRobin } from "../common/smooth-weighted-round-robin.js";
 import { assertSupportedOneMillionSuffix, canonicalAnthropicModel } from "./anthropic-constants.js";
 import { readAnthropicQuotaUsage } from "./anthropic-quota.js";
 import { makeAnthropicWorkerId, runClaudeSession } from "./claude-session.js";
@@ -11,7 +12,7 @@ import { getLogger } from "@logtape/logtape";
 * AnthropicDispatcher
 *
 * OpenAIDispatcher와 달리, worker pool을 두는 대신 요청별 fresh spawn
-* 토큰은 인메모리(MAP)으로 관리하고 least-used, round-robin 으로 고른다
+* 토큰은 인메모리(MAP)으로 관리하고 smooth weighted round-robin 으로 고른다
 *
 * - 모든 요청은 fresh `--session-id` 로 실행
 * - 멀티턴 문맥은 클라이언트가 매 호출 보내는 full history 를 평탄화해 전달한다.
@@ -28,8 +29,7 @@ function quotaThresholdExceededMessage(provider, tokens) {
 }
 var AnthropicDispatcher = class {
 	tokenPool = /* @__PURE__ */ new Map();
-	requestCounts = /* @__PURE__ */ new Map();
-	rrIndex = 0;
+	weightedSelector = new SmoothWeightedRoundRobin();
 	async start() {
 		const tokens = await TokenModel.findActiveByProvider("A", "anthropic");
 		for (const t of tokens) {
@@ -37,15 +37,18 @@ var AnthropicDispatcher = class {
 				id: t.id,
 				name: t.name,
 				credentials: t.credentials,
-				quotaThreshold: t.quota_threshold
+				quotaThreshold: t.quota_threshold,
+				weight: t.weight
 			});
+			this.weightedSelector.setToken(t.id, t.weight);
 			logger.info(`worker spawned: ${t.name}`);
 		}
 	}
 	async stop() {
+		const tokenIds = [...this.tokenPool.keys()];
+		for (const id of tokenIds) this.weightedSelector.removeToken(id);
 		this.tokenPool.clear();
-		this.requestCounts.clear();
-		this.rrIndex = 0;
+		this.weightedSelector.resetScores();
 	}
 	get tokenCount() {
 		return this.tokenPool.size;
@@ -54,31 +57,32 @@ var AnthropicDispatcher = class {
 		const next = new Set(rows.map((r) => r.id));
 		const currentIds = Array.from(this.tokenPool.keys());
 		for (const id of currentIds) if (!next.has(id)) this.onTokenRemoved(id);
-		for (const r of rows) if (this.tokenPool.has(r.id)) this.onTokenUpdated(r.id, r.name, r.credentials, r.quotaThreshold);
-		else this.onTokenAdded(r.id, r.name, r.credentials, r.quotaThreshold);
+		for (const r of rows) if (this.tokenPool.has(r.id)) this.onTokenUpdated(r.id, r.name, r.credentials, r.quotaThreshold, r.weight);
+		else this.onTokenAdded(r.id, r.name, r.credentials, r.quotaThreshold, r.weight);
 	}
-	onTokenAdded(id, name, credentials, quotaThreshold) {
+	onTokenAdded(id, name, credentials, quotaThreshold, weight = 1) {
 		this.tokenPool.set(id, {
 			id,
 			name,
 			credentials,
-			quotaThreshold
+			quotaThreshold,
+			weight
 		});
+		this.weightedSelector.setToken(id, weight);
 	}
-	onTokenUpdated(id, name, credentials, quotaThreshold) {
+	onTokenUpdated(id, name, credentials, quotaThreshold, weight = 1) {
 		this.tokenPool.set(id, {
 			id,
 			name,
 			credentials,
-			quotaThreshold
+			quotaThreshold,
+			weight
 		});
+		this.weightedSelector.setToken(id, weight);
 	}
 	onTokenRemoved(id) {
 		this.tokenPool.delete(id);
-		this.requestCounts.delete(id);
-	}
-	countOf(id) {
-		return this.requestCounts.get(id) ?? 0;
+		this.weightedSelector.removeToken(id);
 	}
 	async selectToken() {
 		const rows = [...this.tokenPool.values()];
@@ -94,12 +98,9 @@ var AnthropicDispatcher = class {
 			});
 			throw new QuotaThresholdExceededError(quotaThresholdExceededMessage("anthropic", overThresholdTokens));
 		}
-		const minCount = Math.min(...eligible.map((r) => this.countOf(r.id)));
-		const idle = eligible.filter((r) => this.countOf(r.id) === minCount);
-		const picked = idle[this.rrIndex % idle.length];
-		if (!picked) return null;
-		this.rrIndex++;
-		return this.charge(picked);
+		const selectedId = this.weightedSelector.select(new Set(eligible.map((token) => token.id)));
+		if (selectedId === null) return null;
+		return this.tokenPool.get(selectedId) ?? null;
 	}
 	async filterEligibleTokens(rows) {
 		const thresholded = rows.filter((token) => this.hasQuotaThreshold(token));
@@ -166,10 +167,6 @@ var AnthropicDispatcher = class {
 			lookupReason: reason
 		});
 	}
-	charge(token) {
-		this.requestCounts.set(token.id, this.countOf(token.id) + 1);
-		return token;
-	}
 	async generate(req) {
 		return this.run(req, () => {});
 	}
@@ -244,4 +241,4 @@ var AnthropicDispatcher = class {
 //#endregion
 export { AnthropicDispatcher };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"anthropic-dispatcher.js","names":[],"sources":["../../../../src/utils/providers/anthropic/anthropic-dispatcher.ts"],"sourcesContent":["/**\n * AnthropicDispatcher\n *\n * OpenAIDispatcher와 달리, worker pool을 두는 대신 요청별 fresh spawn\n * 토큰은 인메모리(MAP)으로 관리하고 least-used, round-robin 으로 고른다\n *\n * - 모든 요청은 fresh `--session-id` 로 실행\n * - 멀티턴 문맥은 클라이언트가 매 호출 보내는 full history 를 평탄화해 전달한다.\n * - 발급한 session-id 를 GenerateResult.threadCoord(threadId=session-id, workerId=tokenId,\n *   epoch=0)로 올려, 상위(issueConvContext)가 클라에 회송할 좌표를 만든다. 다음 turn 이 좌표를\n *   회송해도 Anthropic 라우팅에는 쓰지 않는다.\n */\n\nimport { getLogger } from \"@logtape/logtape\";\n\nimport { QuotaThresholdExceededError } from \"../../../application/qgrid/qgrid.types\";\nimport { TokenModel } from \"../../../application/token/token.model\";\nimport { type AnthropicCredentials } from \"../../../application/token/token.types\";\nimport { getExpiresAt, getRefreshToken } from \"../common/credentials\";\nimport {\n  type GenerateRequest,\n  type GenerateResult,\n  type GenerateStreamCallbacks,\n  type ProviderDispatcher,\n} from \"../common/provider-dispatcher\";\nimport { assertSupportedOneMillionSuffix, canonicalAnthropicModel } from \"./anthropic-constants\";\nimport { readAnthropicQuotaUsage, type AnthropicQuotaUsageResult } from \"./anthropic-quota\";\nimport { makeAnthropicWorkerId, runClaudeSession } from \"./claude-session\";\n\nconst logger = getLogger([\"qgrid\", \"anthropic-dispatcher\"]);\n\n// 1M context 정상 생성은 실측상 100s+까지 간다. 240s는 완충 장치일 뿐,\n// 거부+거대 system 재생성 지연을 완전히 해결하는 값은 아니다.\nconst DEFAULT_TIMEOUT_MS = 240_000;\n// access token 만료 임박 임계 — 기존 standalone 경로(qgrid.dispatcher.ts)와 동일(60s).\nconst REFRESH_SAFETY_MS = 60_000;\n\ninterface PooledToken {\n  id: number;\n  name: string;\n  credentials: AnthropicCredentials;\n  quotaThreshold?: number | null;\n}\n\nfunction quotaThresholdExceededMessage(\n  provider: string,\n  tokens: Array<{ tokenName: string; threshold: number }>,\n): string {\n  const details = tokens\n    .map((token) => `${token.tokenName} (threshold ${token.threshold}%)`)\n    .join(\", \");\n  return details.length > 0\n    ? `All ${provider} tokens exceeded quota threshold: ${details}`\n    : `All ${provider} tokens exceeded quota threshold`;\n}\n\nexport class AnthropicDispatcher implements ProviderDispatcher {\n  // tokenId → 풀 항목. start()/token 이벤트로 채움\n  private tokenPool = new Map<number, PooledToken>();\n  // tokenId 별 사용 카운터(least-used RR). name 이 아니라 id 기준 — 이름 충돌 안전\n  private requestCounts = new Map<number, number>();\n  private rrIndex = 0;\n\n  async start(): Promise<void> {\n    // OpenAIDispatcher.start() 와 동일하게 DB 에서 기존 anthropic 토큰을 self-bootstrap 한다.\n    // (서버 재시작 시 NOTIFY 가 안 오므로 부트스트랩이 없으면 풀이 빈 채로 남는다.)\n    // 이후 변경분은 token-subscriber 가 onTokenAdded/Updated/Removed 로 전달한다.\n    // findActiveByProvider 가 active=true + provider 필터를 DB 에서 처리 → inactive 는 애초에 안 온다.\n    const tokens = await TokenModel.findActiveByProvider(\"A\", \"anthropic\");\n    for (const t of tokens) {\n      this.tokenPool.set(t.id, {\n        id: t.id,\n        name: t.name,\n        credentials: t.credentials as AnthropicCredentials,\n        quotaThreshold: t.quota_threshold,\n      });\n      logger.info(`worker spawned: ${t.name}`);\n    }\n  }\n\n  async stop(): Promise<void> {\n    this.tokenPool.clear();\n    // lifecycle 정합: RR 카운터/인덱스도 비워 stop→start 재등록 시 이전 카운트가 안 남게 한다.\n    this.requestCounts.clear();\n    this.rrIndex = 0;\n  }\n\n  // 현재 풀의 토큰 수(startup 로그/health 용).\n  get tokenCount(): number {\n    return this.tokenPool.size;\n  }\n\n  // DB active anthropic 토큰 목록으로 풀을 재동기화한다(periodic reconcile/재연결용).\n  // LISTEN/NOTIFY 가 끊긴 동안 유실된 추가/삭제/비활성화를 DB 기준으로 다시 맞춘다.\n  // 이벤트 핸들러를 재사용해 풀 갱신이 일관되게 적용되도록 한다:\n  //  - DB 에 없는데 풀에 있는 토큰 → onTokenRemoved\n  //  - DB 에 있는 토큰 → 신규면 onTokenAdded, 기존이면 onTokenUpdated\n  replaceTokens(\n    rows: Array<{\n      id: number;\n      name: string;\n      credentials: AnthropicCredentials;\n      quotaThreshold?: number | null;\n    }>,\n  ): void {\n    const next = new Set(rows.map((r) => r.id));\n    // onTokenRemoved 가 tokenPool 을 delete 하므로 순회 중 수정을 피하려 키를 먼저 스냅샷한다.\n    const currentIds = Array.from(this.tokenPool.keys());\n    for (const id of currentIds) {\n      if (!next.has(id)) this.onTokenRemoved(id);\n    }\n    for (const r of rows) {\n      if (this.tokenPool.has(r.id)) {\n        this.onTokenUpdated(r.id, r.name, r.credentials, r.quotaThreshold);\n      } else {\n        this.onTokenAdded(r.id, r.name, r.credentials, r.quotaThreshold);\n      }\n    }\n  }\n\n  // token events (token-subscriber 가 호출)\n  onTokenAdded(\n    id: number,\n    name: string,\n    credentials: AnthropicCredentials,\n    quotaThreshold?: number | null,\n  ): void {\n    this.tokenPool.set(id, { id, name, credentials, quotaThreshold });\n  }\n\n  onTokenUpdated(\n    id: number,\n    name: string,\n    credentials: AnthropicCredentials,\n    quotaThreshold?: number | null,\n  ): void {\n    this.tokenPool.set(id, { id, name, credentials, quotaThreshold });\n  }\n\n  onTokenRemoved(id: number): void {\n    this.tokenPool.delete(id);\n    this.requestCounts.delete(id);\n  }\n\n  private countOf(id: number): number {\n    return this.requestCounts.get(id) ?? 0;\n  }\n\n  // 요청마다 least-used RR 로 토큰을 고른다(동점이면 rrIndex 로 회전).\n  private async selectToken(): Promise<PooledToken | null> {\n    const rows = [...this.tokenPool.values()];\n    if (rows.length === 0) return null;\n    const { eligible, overThresholdTokens } = await this.filterEligibleTokens(rows);\n    if (eligible.length === 0) {\n      logger.warn(\"quota_threshold gate: all_exceeded\", {\n        provider: \"anthropic\",\n        tokenCount: rows.length,\n        thresholdedTokenCount: rows.filter((r) => this.hasQuotaThreshold(r)).length,\n        overThresholdTokens,\n        reason: \"all_exceeded\",\n      });\n      throw new QuotaThresholdExceededError(\n        quotaThresholdExceededMessage(\"anthropic\", overThresholdTokens),\n      );\n    }\n\n    const minCount = Math.min(...eligible.map((r) => this.countOf(r.id)));\n    const idle = eligible.filter((r) => this.countOf(r.id) === minCount);\n    const picked = idle[this.rrIndex % idle.length];\n    if (!picked) return null;\n    this.rrIndex++;\n    return this.charge(picked);\n  }\n\n  private async filterEligibleTokens(rows: PooledToken[]): Promise<{\n    eligible: PooledToken[];\n    overThresholdTokens: Array<{ tokenName: string; threshold: number }>;\n  }> {\n    const thresholded = rows.filter((token) => this.hasQuotaThreshold(token));\n    if (thresholded.length === 0) return { eligible: rows, overThresholdTokens: [] };\n\n    const eligibleIds = new Set(\n      rows.filter((token) => !this.hasQuotaThreshold(token)).map((token) => token.id),\n    );\n    const overThresholdTokens: Array<{ tokenName: string; threshold: number }> = [];\n    const checks = await Promise.allSettled(\n      thresholded.map(async (token) => ({\n        token,\n        result: await readAnthropicQuotaUsage(token.credentials.accessToken),\n      })),\n    );\n\n    checks.forEach((check, index) => {\n      if (check.status === \"rejected\") {\n        const token = thresholded[index];\n        if (!token) return;\n        this.logQuotaLookupFailOpen(token, String(check.reason));\n        eligibleIds.add(token.id);\n        return;\n      }\n\n      const token = check.value.token;\n      const result = check.value.result;\n      if (result.kind === \"lookup_failed\") {\n        this.logQuotaLookupFailOpen(token, result.reason);\n        eligibleIds.add(token.id);\n        return;\n      }\n\n      if (result.utilizationPct >= token.quotaThreshold) {\n        this.logQuotaOverThreshold(token, result);\n        overThresholdTokens.push({ tokenName: token.name, threshold: token.quotaThreshold });\n        return;\n      }\n\n      eligibleIds.add(token.id);\n    });\n\n    return { eligible: rows.filter((token) => eligibleIds.has(token.id)), overThresholdTokens };\n  }\n\n  private hasQuotaThreshold(token: PooledToken): token is PooledToken & { quotaThreshold: number } {\n    return token.quotaThreshold !== undefined && token.quotaThreshold !== null;\n  }\n\n  private logQuotaOverThreshold(\n    token: PooledToken & { quotaThreshold: number },\n    result: Extract<AnthropicQuotaUsageResult, { kind: \"ok\" }>,\n  ): void {\n    logger.info(\"quota_threshold gate: over_threshold\", {\n      tokenId: token.id,\n      tokenName: token.name,\n      provider: \"anthropic\",\n      threshold: token.quotaThreshold,\n      cachedUtilization: result.utilizationPct,\n      cacheAge: result.cacheAgeMs,\n      reason: \"over_threshold\",\n    });\n  }\n\n  private logQuotaLookupFailOpen(\n    token: PooledToken & { quotaThreshold: number },\n    reason: string,\n  ): void {\n    logger.warn(\"quota_threshold gate: lookup_fail_open\", {\n      tokenId: token.id,\n      tokenName: token.name,\n      provider: \"anthropic\",\n      threshold: token.quotaThreshold,\n      reason: \"lookup_fail_open\",\n      lookupReason: reason,\n    });\n  }\n\n  // 선택된 토큰의 사용 카운트를 await 전에 선반영(동시 요청이 다른 토큰을 고르도록).\n  private charge(token: PooledToken): PooledToken {\n    this.requestCounts.set(token.id, this.countOf(token.id) + 1);\n    return token;\n  }\n\n  async generate(req: GenerateRequest): Promise<GenerateResult> {\n    return this.run(req, () => {});\n  }\n\n  async generateStream(req: GenerateRequest, cb: GenerateStreamCallbacks): Promise<void> {\n    try {\n      const result = await this.run(req, cb.onDelta, { includePartialMessages: true });\n      cb.onThreadId?.(result.threadCoord.threadId);\n      cb.onComplete(result);\n    } catch (e) {\n      cb.onError(e as Error);\n    }\n  }\n\n  // generate/generateStream 공통 실행. onDelta 는 스트림이면 점진 방출, 비스트림이면 no-op.\n  private async run(\n    req: GenerateRequest,\n    onDelta: (t: string) => void,\n    opts?: { includePartialMessages?: boolean },\n  ): Promise<GenerateResult> {\n    // 이미지 생성은 OpenAI(codex) 경로 전용. Anthropic 라우팅에 이미지 플래그가\n    // 도달하면 조용히 텍스트로 폴백하지 않고 명시적으로 거부한다.\n    if (req.imageGeneration) {\n      throw new Error(\"image generation is not supported on the Anthropic route\");\n    }\n    // model 정규화를 dispatcher 진입점에서 한 번 한다: result.model / runClaudeSession 전부\n    // canonical(prefix 없는 cost 키) 을 쓰게 통일. 미지정이면 ANTHROPIC_DEFAULT_MODEL — qgrid.dispatcher\n    // 의 \"sonnet\" 별칭 우회 차단. 정규화 규칙은 fallback 경로와 공유(canonicalAnthropicModel).\n    assertSupportedOneMillionSuffix(req.model);\n    const model = canonicalAnthropicModel(req.model);\n    const jsonSchema =\n      req.outputSchema !== undefined ? JSON.stringify(req.outputSchema) : undefined;\n\n    const token = await this.selectToken();\n    if (!token) throw new Error(\"No anthropic tokens available\");\n\n    const exec = async (): Promise<GenerateResult> => {\n      // 만료 임박 토큰 preemptive refresh(기존 standalone 경로와 동일). 실패해도 진행.\n      let accessToken = token.credentials.accessToken;\n      const expiresAt = getExpiresAt(token.credentials);\n      if (\n        expiresAt &&\n        expiresAt - Date.now() < REFRESH_SAFETY_MS &&\n        getRefreshToken(token.credentials)\n      ) {\n        try {\n          const { QgridFrame } = await import(\"../../../application/qgrid/qgrid.frame\");\n          // provider 를 반드시 채워야 refreshToken 내부 TokenModel.save 가 성공한다.\n          // refreshToken(TokenSubsetA) 는 id/provider/credentials/name 만 사용하므로 그 4개만 넘긴다.\n          accessToken = await QgridFrame.refreshToken({\n            id: token.id,\n            provider: \"anthropic\",\n            name: token.name,\n            credentials: token.credentials,\n          } as Parameters<typeof QgridFrame.refreshToken>[0]);\n        } catch (e) {\n          logger.warn(`refresh failed for ${token.name}: ${(e as Error).message}`);\n        }\n      }\n\n      logger.info(`→ ${token.name} (model: ${model})`);\n      const session = await runClaudeSession(\n        {\n          tokenId: token.id,\n          token: accessToken,\n          model,\n          system: req.systemPrompt,\n          jsonSchema,\n          effort: req.effort,\n          timeoutMs: DEFAULT_TIMEOUT_MS,\n          coldHistory: req.coldHistory,\n          input: req.coldInput,\n          abortSignal: req.abortSignal,\n          includePartialMessages: opts?.includePartialMessages,\n        },\n        onDelta,\n      );\n\n      if (session.quotaExhausted) throw new Error(`quota exhausted (${token.name})`);\n      if (session.isError) {\n        // 진단(SON-495): isError 판정 사유(subtype/terminal_reason)를 메시지 앞에 드러낸다.\n        // 그동안 detail 이 session.text(완전한 JSON 본문)뿐이라 \"schema 위반인지 / max retries 인지 /\n        // max turns 인지\"를 구분할 수 없었다. text 는 진단에 필요한 만큼만 잘라 덧붙인다.\n        const reason =\n          session.subtype ?? session.terminalReason ?? (session.isError ? \"is_error\" : \"unknown\");\n        const body = session.text\n          ? session.text.length > 500\n            ? `${session.text.slice(0, 500)}…(${session.text.length} chars)`\n            : session.text\n          : `empty text, outputTokens=${session.usage.outputTokens}`;\n        throw new Error(`claude error (${token.name}) [${reason}]: ${body}`);\n      }\n\n      return {\n        text: session.text,\n        tokenName: token.name,\n        usage: session.usage,\n        durationMs: session.durationMs,\n        ttftMs: session.ttftMs,\n        costUsd: session.costUsd,\n        model,\n        // systemHash 는 상위 issueConvContext 가 채운다(여기선 비운다).\n        threadCoord: {\n          workerId: makeAnthropicWorkerId(token.id),\n          threadId: session.sessionId,\n          epoch: 0,\n        },\n      };\n    };\n\n    return exec();\n  }\n}\n"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"anthropic-dispatcher.js","names":[],"sources":["../../../../src/utils/providers/anthropic/anthropic-dispatcher.ts"],"sourcesContent":["/**\n * AnthropicDispatcher\n *\n * OpenAIDispatcher와 달리, worker pool을 두는 대신 요청별 fresh spawn\n * 토큰은 인메모리(MAP)으로 관리하고 smooth weighted round-robin 으로 고른다\n *\n * - 모든 요청은 fresh `--session-id` 로 실행\n * - 멀티턴 문맥은 클라이언트가 매 호출 보내는 full history 를 평탄화해 전달한다.\n * - 발급한 session-id 를 GenerateResult.threadCoord(threadId=session-id, workerId=tokenId,\n *   epoch=0)로 올려, 상위(issueConvContext)가 클라에 회송할 좌표를 만든다. 다음 turn 이 좌표를\n *   회송해도 Anthropic 라우팅에는 쓰지 않는다.\n */\n\nimport { getLogger } from \"@logtape/logtape\";\n\nimport { QuotaThresholdExceededError } from \"../../../application/qgrid/qgrid.types\";\nimport { TokenModel } from \"../../../application/token/token.model\";\nimport { type AnthropicCredentials } from \"../../../application/token/token.types\";\nimport { getExpiresAt, getRefreshToken } from \"../common/credentials\";\nimport {\n  type GenerateRequest,\n  type GenerateResult,\n  type GenerateStreamCallbacks,\n  type ProviderDispatcher,\n} from \"../common/provider-dispatcher\";\nimport { SmoothWeightedRoundRobin } from \"../common/smooth-weighted-round-robin\";\nimport { assertSupportedOneMillionSuffix, canonicalAnthropicModel } from \"./anthropic-constants\";\nimport { readAnthropicQuotaUsage, type AnthropicQuotaUsageResult } from \"./anthropic-quota\";\nimport { makeAnthropicWorkerId, runClaudeSession } from \"./claude-session\";\n\nconst logger = getLogger([\"qgrid\", \"anthropic-dispatcher\"]);\n\n// 1M context 정상 생성은 실측상 100s+까지 간다. 240s는 완충 장치일 뿐,\n// 거부+거대 system 재생성 지연을 완전히 해결하는 값은 아니다.\nconst DEFAULT_TIMEOUT_MS = 240_000;\n// access token 만료 임박 임계 — 기존 standalone 경로(qgrid.dispatcher.ts)와 동일(60s).\nconst REFRESH_SAFETY_MS = 60_000;\n\ninterface PooledToken {\n  id: number;\n  name: string;\n  credentials: AnthropicCredentials;\n  quotaThreshold?: number | null;\n  weight: number;\n}\n\nfunction quotaThresholdExceededMessage(\n  provider: string,\n  tokens: Array<{ tokenName: string; threshold: number }>,\n): string {\n  const details = tokens\n    .map((token) => `${token.tokenName} (threshold ${token.threshold}%)`)\n    .join(\", \");\n  return details.length > 0\n    ? `All ${provider} tokens exceeded quota threshold: ${details}`\n    : `All ${provider} tokens exceeded quota threshold`;\n}\n\nexport class AnthropicDispatcher implements ProviderDispatcher {\n  // tokenId → 풀 항목. start()/token 이벤트로 채움\n  private tokenPool = new Map<number, PooledToken>();\n  private readonly weightedSelector = new SmoothWeightedRoundRobin();\n\n  async start(): Promise<void> {\n    // OpenAIDispatcher.start() 와 동일하게 DB 에서 기존 anthropic 토큰을 self-bootstrap 한다.\n    // (서버 재시작 시 NOTIFY 가 안 오므로 부트스트랩이 없으면 풀이 빈 채로 남는다.)\n    // 이후 변경분은 token-subscriber 가 onTokenAdded/Updated/Removed 로 전달한다.\n    // findActiveByProvider 가 active=true + provider 필터를 DB 에서 처리 → inactive 는 애초에 안 온다.\n    const tokens = await TokenModel.findActiveByProvider(\"A\", \"anthropic\");\n    for (const t of tokens) {\n      this.tokenPool.set(t.id, {\n        id: t.id,\n        name: t.name,\n        credentials: t.credentials as AnthropicCredentials,\n        quotaThreshold: t.quota_threshold,\n        weight: t.weight,\n      });\n      this.weightedSelector.setToken(t.id, t.weight);\n      logger.info(`worker spawned: ${t.name}`);\n    }\n  }\n\n  async stop(): Promise<void> {\n    const tokenIds = [...this.tokenPool.keys()];\n    for (const id of tokenIds) this.weightedSelector.removeToken(id);\n    this.tokenPool.clear();\n    this.weightedSelector.resetScores();\n  }\n\n  // 현재 풀의 토큰 수(startup 로그/health 용).\n  get tokenCount(): number {\n    return this.tokenPool.size;\n  }\n\n  // DB active anthropic 토큰 목록으로 풀을 재동기화한다(periodic reconcile/재연결용).\n  // LISTEN/NOTIFY 가 끊긴 동안 유실된 추가/삭제/비활성화를 DB 기준으로 다시 맞춘다.\n  // 이벤트 핸들러를 재사용해 풀 갱신이 일관되게 적용되도록 한다:\n  //  - DB 에 없는데 풀에 있는 토큰 → onTokenRemoved\n  //  - DB 에 있는 토큰 → 신규면 onTokenAdded, 기존이면 onTokenUpdated\n  replaceTokens(\n    rows: Array<{\n      id: number;\n      name: string;\n      credentials: AnthropicCredentials;\n      quotaThreshold?: number | null;\n      weight: number;\n    }>,\n  ): void {\n    const next = new Set(rows.map((r) => r.id));\n    // onTokenRemoved 가 tokenPool 을 delete 하므로 순회 중 수정을 피하려 키를 먼저 스냅샷한다.\n    const currentIds = Array.from(this.tokenPool.keys());\n    for (const id of currentIds) {\n      if (!next.has(id)) this.onTokenRemoved(id);\n    }\n    for (const r of rows) {\n      if (this.tokenPool.has(r.id)) {\n        this.onTokenUpdated(r.id, r.name, r.credentials, r.quotaThreshold, r.weight);\n      } else {\n        this.onTokenAdded(r.id, r.name, r.credentials, r.quotaThreshold, r.weight);\n      }\n    }\n  }\n\n  // token events (token-subscriber 가 호출)\n  onTokenAdded(\n    id: number,\n    name: string,\n    credentials: AnthropicCredentials,\n    quotaThreshold?: number | null,\n    weight = 1,\n  ): void {\n    this.tokenPool.set(id, { id, name, credentials, quotaThreshold, weight });\n    this.weightedSelector.setToken(id, weight);\n  }\n\n  onTokenUpdated(\n    id: number,\n    name: string,\n    credentials: AnthropicCredentials,\n    quotaThreshold?: number | null,\n    weight = 1,\n  ): void {\n    this.tokenPool.set(id, { id, name, credentials, quotaThreshold, weight });\n    this.weightedSelector.setToken(id, weight);\n  }\n\n  onTokenRemoved(id: number): void {\n    this.tokenPool.delete(id);\n    this.weightedSelector.removeToken(id);\n  }\n\n  // quota 통과 후보만으로 요청마다 smooth weighted round-robin 선택한다.\n  private async selectToken(): Promise<PooledToken | null> {\n    const rows = [...this.tokenPool.values()];\n    if (rows.length === 0) return null;\n    const { eligible, overThresholdTokens } = await this.filterEligibleTokens(rows);\n    if (eligible.length === 0) {\n      logger.warn(\"quota_threshold gate: all_exceeded\", {\n        provider: \"anthropic\",\n        tokenCount: rows.length,\n        thresholdedTokenCount: rows.filter((r) => this.hasQuotaThreshold(r)).length,\n        overThresholdTokens,\n        reason: \"all_exceeded\",\n      });\n      throw new QuotaThresholdExceededError(\n        quotaThresholdExceededMessage(\"anthropic\", overThresholdTokens),\n      );\n    }\n\n    const selectedId = this.weightedSelector.select(new Set(eligible.map((token) => token.id)));\n    if (selectedId === null) return null;\n    return this.tokenPool.get(selectedId) ?? null;\n  }\n\n  private async filterEligibleTokens(rows: PooledToken[]): Promise<{\n    eligible: PooledToken[];\n    overThresholdTokens: Array<{ tokenName: string; threshold: number }>;\n  }> {\n    const thresholded = rows.filter((token) => this.hasQuotaThreshold(token));\n    if (thresholded.length === 0) return { eligible: rows, overThresholdTokens: [] };\n\n    const eligibleIds = new Set(\n      rows.filter((token) => !this.hasQuotaThreshold(token)).map((token) => token.id),\n    );\n    const overThresholdTokens: Array<{ tokenName: string; threshold: number }> = [];\n    const checks = await Promise.allSettled(\n      thresholded.map(async (token) => ({\n        token,\n        result: await readAnthropicQuotaUsage(token.credentials.accessToken),\n      })),\n    );\n\n    checks.forEach((check, index) => {\n      if (check.status === \"rejected\") {\n        const token = thresholded[index];\n        if (!token) return;\n        this.logQuotaLookupFailOpen(token, String(check.reason));\n        eligibleIds.add(token.id);\n        return;\n      }\n\n      const token = check.value.token;\n      const result = check.value.result;\n      if (result.kind === \"lookup_failed\") {\n        this.logQuotaLookupFailOpen(token, result.reason);\n        eligibleIds.add(token.id);\n        return;\n      }\n\n      if (result.utilizationPct >= token.quotaThreshold) {\n        this.logQuotaOverThreshold(token, result);\n        overThresholdTokens.push({ tokenName: token.name, threshold: token.quotaThreshold });\n        return;\n      }\n\n      eligibleIds.add(token.id);\n    });\n\n    return { eligible: rows.filter((token) => eligibleIds.has(token.id)), overThresholdTokens };\n  }\n\n  private hasQuotaThreshold(token: PooledToken): token is PooledToken & { quotaThreshold: number } {\n    return token.quotaThreshold !== undefined && token.quotaThreshold !== null;\n  }\n\n  private logQuotaOverThreshold(\n    token: PooledToken & { quotaThreshold: number },\n    result: Extract<AnthropicQuotaUsageResult, { kind: \"ok\" }>,\n  ): void {\n    logger.info(\"quota_threshold gate: over_threshold\", {\n      tokenId: token.id,\n      tokenName: token.name,\n      provider: \"anthropic\",\n      threshold: token.quotaThreshold,\n      cachedUtilization: result.utilizationPct,\n      cacheAge: result.cacheAgeMs,\n      reason: \"over_threshold\",\n    });\n  }\n\n  private logQuotaLookupFailOpen(\n    token: PooledToken & { quotaThreshold: number },\n    reason: string,\n  ): void {\n    logger.warn(\"quota_threshold gate: lookup_fail_open\", {\n      tokenId: token.id,\n      tokenName: token.name,\n      provider: \"anthropic\",\n      threshold: token.quotaThreshold,\n      reason: \"lookup_fail_open\",\n      lookupReason: reason,\n    });\n  }\n\n  async generate(req: GenerateRequest): Promise<GenerateResult> {\n    return this.run(req, () => {});\n  }\n\n  async generateStream(req: GenerateRequest, cb: GenerateStreamCallbacks): Promise<void> {\n    try {\n      const result = await this.run(req, cb.onDelta, { includePartialMessages: true });\n      cb.onThreadId?.(result.threadCoord.threadId);\n      cb.onComplete(result);\n    } catch (e) {\n      cb.onError(e as Error);\n    }\n  }\n\n  // generate/generateStream 공통 실행. onDelta 는 스트림이면 점진 방출, 비스트림이면 no-op.\n  private async run(\n    req: GenerateRequest,\n    onDelta: (t: string) => void,\n    opts?: { includePartialMessages?: boolean },\n  ): Promise<GenerateResult> {\n    // 이미지 생성은 OpenAI(codex) 경로 전용. Anthropic 라우팅에 이미지 플래그가\n    // 도달하면 조용히 텍스트로 폴백하지 않고 명시적으로 거부한다.\n    if (req.imageGeneration) {\n      throw new Error(\"image generation is not supported on the Anthropic route\");\n    }\n    // model 정규화를 dispatcher 진입점에서 한 번 한다: result.model / runClaudeSession 전부\n    // canonical(prefix 없는 cost 키) 을 쓰게 통일. 미지정이면 ANTHROPIC_DEFAULT_MODEL — qgrid.dispatcher\n    // 의 \"sonnet\" 별칭 우회 차단. 정규화 규칙은 fallback 경로와 공유(canonicalAnthropicModel).\n    assertSupportedOneMillionSuffix(req.model);\n    const model = canonicalAnthropicModel(req.model);\n    const jsonSchema =\n      req.outputSchema !== undefined ? JSON.stringify(req.outputSchema) : undefined;\n\n    const token = await this.selectToken();\n    if (!token) throw new Error(\"No anthropic tokens available\");\n\n    const exec = async (): Promise<GenerateResult> => {\n      // 만료 임박 토큰 preemptive refresh(기존 standalone 경로와 동일). 실패해도 진행.\n      let accessToken = token.credentials.accessToken;\n      const expiresAt = getExpiresAt(token.credentials);\n      if (\n        expiresAt &&\n        expiresAt - Date.now() < REFRESH_SAFETY_MS &&\n        getRefreshToken(token.credentials)\n      ) {\n        try {\n          const { QgridFrame } = await import(\"../../../application/qgrid/qgrid.frame\");\n          // provider 를 반드시 채워야 refreshToken 내부 TokenModel.save 가 성공한다.\n          // refreshToken(TokenSubsetA) 는 id/provider/credentials/name 만 사용하므로 그 4개만 넘긴다.\n          accessToken = await QgridFrame.refreshToken({\n            id: token.id,\n            provider: \"anthropic\",\n            name: token.name,\n            credentials: token.credentials,\n          } as Parameters<typeof QgridFrame.refreshToken>[0]);\n        } catch (e) {\n          logger.warn(`refresh failed for ${token.name}: ${(e as Error).message}`);\n        }\n      }\n\n      logger.info(`→ ${token.name} (model: ${model})`);\n      const session = await runClaudeSession(\n        {\n          tokenId: token.id,\n          token: accessToken,\n          model,\n          system: req.systemPrompt,\n          jsonSchema,\n          effort: req.effort,\n          timeoutMs: DEFAULT_TIMEOUT_MS,\n          coldHistory: req.coldHistory,\n          input: req.coldInput,\n          abortSignal: req.abortSignal,\n          includePartialMessages: opts?.includePartialMessages,\n        },\n        onDelta,\n      );\n\n      if (session.quotaExhausted) throw new Error(`quota exhausted (${token.name})`);\n      if (session.isError) {\n        // 진단(SON-495): isError 판정 사유(subtype/terminal_reason)를 메시지 앞에 드러낸다.\n        // 그동안 detail 이 session.text(완전한 JSON 본문)뿐이라 \"schema 위반인지 / max retries 인지 /\n        // max turns 인지\"를 구분할 수 없었다. text 는 진단에 필요한 만큼만 잘라 덧붙인다.\n        const reason =\n          session.subtype ?? session.terminalReason ?? (session.isError ? \"is_error\" : \"unknown\");\n        const body = session.text\n          ? session.text.length > 500\n            ? `${session.text.slice(0, 500)}…(${session.text.length} chars)`\n            : session.text\n          : `empty text, outputTokens=${session.usage.outputTokens}`;\n        throw new Error(`claude error (${token.name}) [${reason}]: ${body}`);\n      }\n\n      return {\n        text: session.text,\n        tokenName: token.name,\n        usage: session.usage,\n        durationMs: session.durationMs,\n        ttftMs: session.ttftMs,\n        costUsd: session.costUsd,\n        model,\n        // systemHash 는 상위 issueConvContext 가 채운다(여기선 비운다).\n        threadCoord: {\n          workerId: makeAnthropicWorkerId(token.id),\n          threadId: session.sessionId,\n          epoch: 0,\n        },\n      };\n    };\n\n    return exec();\n  }\n}\n"],"mappings":"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"}

package/bundle/dist/utils/providers/common/smooth-weighted-round-robin.js

@@ -0,0 +1,43 @@
+import "../../../_virtual/_rolldown/runtime.js";
+//#region src/utils/providers/common/smooth-weighted-round-robin.ts
+var SmoothWeightedRoundRobin = class {
+	weights = /* @__PURE__ */ new Map();
+	currentScores = /* @__PURE__ */ new Map();
+	setToken(tokenId, weight) {
+		if (!Number.isInteger(weight) || weight < 1 || weight > 100) throw new RangeError("weight must be an integer between 1 and 100");
+		if (this.weights.get(tokenId) === weight) return;
+		this.weights.set(tokenId, weight);
+		this.resetScores();
+	}
+	removeToken(tokenId) {
+		if (!this.weights.delete(tokenId)) return;
+		this.currentScores.delete(tokenId);
+		this.resetScores();
+	}
+	resetScores() {
+		this.currentScores.clear();
+	}
+	select(eligibleTokenIds) {
+		const candidates = [...eligibleTokenIds].filter((tokenId) => this.weights.has(tokenId)).toSorted((a, b) => a - b);
+		if (candidates.length === 0) return null;
+		let selected = candidates[0];
+		let selectedScore = Number.NEGATIVE_INFINITY;
+		let totalWeight = 0;
+		for (const tokenId of candidates) {
+			const weight = this.weights.get(tokenId);
+			totalWeight += weight;
+			const score = (this.currentScores.get(tokenId) ?? 0) + weight;
+			this.currentScores.set(tokenId, score);
+			if (score > selectedScore) {
+				selected = tokenId;
+				selectedScore = score;
+			}
+		}
+		this.currentScores.set(selected, selectedScore - totalWeight);
+		return selected;
+	}
+};
+//#endregion
+export { SmoothWeightedRoundRobin };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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