@cartanova/qgrid-cli 2.5.9 → 2.5.10

package/bundle/src/utils/providers/openai/codex-worker.ts

@@ -431,7 +431,7 @@ export class CodexAppServerWorker {
   // thread 의 기본 model 도 반환 (req.model 미지정 시 fallback).
   async createThread(req: TurnRequest): Promise<{ threadId: string; model: string }> {
     if (!this.rpc || !this.ready) throw new Error("worker not ready");
-    this.sweepIdleThreads();
+    this.sweepIdleThreads(true);
 
     const threadConfig: ThreadStartParams["config"] = {
       ...THREAD_DEFAULTS.config,
@@ -528,7 +528,11 @@ export class CodexAppServerWorker {
       // 이미지 thread 는 1 회용 cold thread 인데 threadMeta 에 등록되지 않아
       // sweep 이 못 잡는다. MB 급 base64 가 상주하므로 turn 종료 즉시(성공/실패
       // 불문) 구독을 끊어 codex 30분 언로드 대상으로 만든다.
-      if (req.imageGeneration) this.unsubscribeThread(threadId);
+      if (req.imageGeneration) {
+        this.unsubscribeThread(threadId);
+      } else {
+        this.touchThread(threadId);
+      }
     }
   }
 
@@ -548,18 +552,22 @@ export class CodexAppServerWorker {
     cb.onThreadId?.(threadId);
     const ttftTracker = createTtftTracker();
     const resultPromise = this.consumeStreamNotifications(threadId, model, cb, ttftTracker);
-    let turnId: string;
     try {
-      ttftTracker.markStart();
-      ({ turnId } = await this.startTurnOnThread(threadId, req));
-    } catch (e) {
-      this.failActiveTurn(e as Error);
-      await resultPromise.catch(() => {});
-      throw e;
+      let turnId: string;
+      try {
+        ttftTracker.markStart();
+        ({ turnId } = await this.startTurnOnThread(threadId, req));
+      } catch (e) {
+        this.failActiveTurn(e as Error);
+        await resultPromise.catch(() => {});
+        throw e;
+      }
+      cb.onTurnId?.(turnId);
+      await resultPromise;
+      return { threadId };
+    } finally {
+      this.touchThread(threadId);
     }
-    cb.onTurnId?.(turnId);
-    await resultPromise;
-    return { threadId };
   }
 
   // ── thread 재사용 지원 ───────────────────────────────────────────
@@ -572,21 +580,21 @@ export class CodexAppServerWorker {
     return this.threadMeta.has(threadId);
   }
 
-  // idle TTL 초과 / 개수 상한 초과 thread 를 정리. createThread 직전 lazy 호출.
+  // idle TTL 초과 / 개수 상한 초과 thread 를 정리.
   // 맵 제거(재사용 라우팅 차단)와 함께 thread/unsubscribe 를 보낸다 — codex 는
   // "구독자 0 + idle" 이 30분(THREAD_UNLOADING_DELAY, 하드코딩) 지속된 thread 를
   // 메모리에서 자동 언로드하는데, thread/start 가 이 커넥션을 자동 구독자로 등록해
   // 두기 때문에 unsubscribe 없이는 그 언로드가 영원히 발동하지 않는다(SON-516 실증).
-  sweepIdleThreads(): void {
+  sweepIdleThreads(reserveSlotForNewThread = false): void {
     const now = Date.now();
     for (const [id, meta] of this.threadMeta) {
       if (now - meta.lastUsedAt > CodexAppServerWorker.THREAD_IDLE_TTL_MS) {
         this.evictThread(id);
       }
     }
-    // createThread 직전 호출 → 새 thread 1 개가 곧 추가된다. 추가 후에도 MAX 를 넘지 않도록
-    // MAX-1 이하로 줄여 둔다(그래야 생성 직후 정확히 MAX). LRU: lastUsedAt 오름차순으로 제거.
-    const limit = CodexAppServerWorker.MAX_THREADS_PER_WORKER - 1;
+    // createThread 직전에는 새 thread 1개가 곧 추가되므로 MAX-1을 사용한다.
+    // 주기 sweep은 현재 cap인 MAX까지만 줄인다. LRU: lastUsedAt 오름차순으로 제거.
+    const limit = CodexAppServerWorker.MAX_THREADS_PER_WORKER - (reserveSlotForNewThread ? 1 : 0);
     if (this.threadMeta.size > limit) {
       const sorted = [...this.threadMeta.entries()].toSorted(
         (a, b) => a[1].lastUsedAt - b[1].lastUsedAt,
@@ -596,6 +604,11 @@ export class CodexAppServerWorker {
     }
   }
 
+  private touchThread(threadId: string): void {
+    const meta = this.threadMeta.get(threadId);
+    if (meta) meta.lastUsedAt = Date.now();
+  }
+
   // thread 재사용 포기: 맵 제거(라우팅 차단)와 구독 해제를 한 단위로 묶는다.
   // unsubscribe 한 thread 에 turn 을 보내면 알림이 이 커넥션으로 오지 않으므로
   // 두 동작은 반드시 함께여야 한다.

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

@@ -142,6 +142,7 @@ function fakeWorker(
     releaseTurn: vi.fn(() => {
       busy = false;
     }),
+    sweepIdleThreads: vi.fn(),
     hasThread: vi.fn((threadId: string) => (options.threads ?? []).includes(threadId)),
     getRateLimits: vi.fn(
       async () => options.rateLimits ?? { rateLimits: {}, rateLimitsByLimitId: null },
@@ -296,6 +297,46 @@ describe("OpenAIDispatcher autoscaling", () => {
     }
   });
 
+  it("runs idle-thread cleanup from the fixed-mode health timer", async () => {
+    vi.useFakeTimers();
+    const findMany = vi.spyOn(TokenModel, "findMany").mockResolvedValue({ rows: [] } as never);
+    const dispatcher = new OpenAIDispatcher(
+      autoscaleConfig({
+        autoscale: false,
+        minWorkersPerToken: 1,
+        maxWorkersPerToken: 1,
+      }),
+      () => 64,
+    );
+    const worker = fakeWorker({ tokenId: 1 });
+    addWorkers(dispatcher, [worker]);
+
+    try {
+      await dispatcher.start();
+      await vi.advanceTimersByTimeAsync(5_000);
+
+      expect(worker.sweepIdleThreads).toHaveBeenCalledTimes(1);
+    } finally {
+      await dispatcher.stop();
+      findMany.mockRestore();
+      vi.useRealTimers();
+    }
+  });
+
+  it("sweeps only ready idle workers so active turns keep their subscription", async () => {
+    const dispatcher = new OpenAIDispatcher(autoscaleConfig(), () => 64);
+    const idle = fakeWorker({ tokenId: 1, workerIndex: 0 });
+    const busy = fakeWorker({ tokenId: 1, workerIndex: 1, busy: true });
+    const restarting = fakeWorker({ tokenId: 1, workerIndex: 2, ready: false });
+    addWorkers(dispatcher, [idle, busy, restarting]);
+
+    await dispatcher.evaluateAutoscaling();
+
+    expect(idle.sweepIdleThreads).toHaveBeenCalledTimes(1);
+    expect(busy.sweepIdleThreads).not.toHaveBeenCalled();
+    expect(restarting.sweepIdleThreads).not.toHaveBeenCalled();
+  });
+
   it("repairs an absent token pool after every initial worker spawn failed", async () => {
     const dispatcher = new OpenAIDispatcher(autoscaleConfig(), () => 64);
     const tokenCredentials = credentials();

package/bundle/src/utils/providers/openai/openai-dispatcher.ts

@@ -780,6 +780,7 @@ export class OpenAIDispatcher implements ProviderDispatcher {
 
   async evaluateAutoscaling(): Promise<void> {
     if (this.stopped) return;
+    this.sweepIdleWorkerThreads();
     const minimumDeficitTokenIds = await this.ensureMinimumWorkersOneStep();
     if (!this.poolConfig.autoscale || this.stopped) return;
     if (this.queue.length > 0) {
@@ -913,6 +914,14 @@ export class OpenAIDispatcher implements ProviderDispatcher {
     return this.poolConfig.maxWorkersPerToken;
   }
 
+  private sweepIdleWorkerThreads(): void {
+    for (const worker of [...this.workerPool.values()].flat()) {
+      // turn 중 unsubscribe하면 해당 connection으로 notification이 더 오지 않아
+      // 실행 중 요청이 timeout될 수 있다. ready + idle worker만 sweep한다.
+      if (worker.isReady && worker.hasCapacity) worker.sweepIdleThreads();
+    }
+  }
+
   private async spawnAndCommitWorker(
     tokenId: number,
     metadata: TokenMetadata,