@cartanova/qgrid-cli 2.5.9 → 2.6.0

package/bundle/src/application/request-log/request-log.entity.json

@@ -97,6 +97,13 @@
       "nullable": true,
       "desc": "inject_items 히스토리"
     },
+    {
+      "name": "tools",
+      "type": "json",
+      "id": "ToolDefinitions",
+      "nullable": true,
+      "desc": "요청에 장착된 tool 정의 목록"
+    },
     {
       "name": "status",
       "type": "enum",
@@ -153,6 +160,7 @@
       "image_cost_method",
       "effort",
       "history",
+      "tools",
       "status",
       "error_message",
       "tool_call_count",

package/bundle/src/application/request-log/request-log.model.test.ts

@@ -113,7 +113,7 @@ describe("RequestLogModel run lifecycle", () => {
     vi.restoreAllMocks();
   });
 
-  it("stores the requested model but no serving model when a run starts", async () => {
+  it("stores the requested model and attached tools but no serving model when a run starts", async () => {
     const ubRegister = vi.fn();
     const transaction = vi.fn(
       async (cb: (trx: { ubUpsert: () => Promise<number[]> }) => Promise<number>) =>
@@ -130,6 +130,7 @@ describe("RequestLogModel run lifecycle", () => {
       RequestLogModel.createRun({
         user_prompt: "hi",
         requested_model_name: "openai/gpt-5-codex",
+        tools: [{ name: "getWeather", description: "Get weather", inputSchema: { type: "object" } }],
       }),
     ).resolves.toBe(17);
 
@@ -139,6 +140,7 @@ describe("RequestLogModel run lifecycle", () => {
         status: "running",
         requested_model_name: "openai/gpt-5-codex",
         model_name: null,
+        tools: [{ name: "getWeather", description: "Get weather", inputSchema: { type: "object" } }],
       }),
     );
   });

package/bundle/src/application/request-log/request-log.model.ts

@@ -14,7 +14,11 @@ import { SD } from "../../i18n/sd.generated";
 import { calculateCostUsd } from "../../utils/providers/common/model-cost";
 import { type RequestLogSubsetKey, type RequestLogSubsetMapping } from "../sonamu.generated";
 import { requestLogLoaderQueries, requestLogSubsetQueries } from "../sonamu.generated.sso";
-import { type RequestLogListParams, type RequestLogSaveParams } from "./request-log.types";
+import {
+  type RequestLogListParams,
+  type RequestLogSaveParams,
+  type ToolDefinitions,
+} from "./request-log.types";
 
 // cost_usd는 정수 micro-USD로 저장. 실제 USD = cost_usd / MICRO_USD.
 export const MICRO_USD = 1_000_000;
@@ -287,6 +291,7 @@ class RequestLogModelClass extends BaseModelClass<
     effort?: string | null;
     project_name?: string | null;
     history?: unknown;
+    tools?: ToolDefinitions;
     is_image_generation?: boolean;
   }): Promise<number> {
     const wdb = this.getPuri("w");
@@ -309,6 +314,7 @@ class RequestLogModelClass extends BaseModelClass<
       // 이미지 turn 식별(R13). run 경로(tools+image 조합)도 auto 경로와 동일하게 마킹.
       is_image_generation: params.is_image_generation ?? false,
       ...(params.history !== undefined ? { history: params.history as { type: string }[] } : {}),
+      ...(params.tools !== undefined ? { tools: params.tools } : {}),
     });
     return wdb.transaction(async (trx) => {
       const ids = await trx.ubUpsert("request_logs");

package/bundle/src/application/request-log/request-log.types.ts

@@ -1,5 +1,6 @@
 import { z } from "zod";
 
+import { QgridTool } from "../qgrid/qgrid.types";
 import { RequestLogBaseListParams, RequestLogBaseSchema } from "../sonamu.generated";
 
 export const HistoryItems = z.array(
@@ -15,6 +16,10 @@ export const HistoryItems = z.array(
 );
 export type HistoryItems = z.infer<typeof HistoryItems>;
 
+// 요청에 장착된 tool 정의 목록 — 저장 형태는 QgridTool 계약을 그대로 따른다.
+export const ToolDefinitions = z.array(QgridTool);
+export type ToolDefinitions = z.infer<typeof ToolDefinitions>;
+
 // RequestLog - ListParams
 // project_name NULL 분기: IS NULL만 조회(unassigned 필터) 또는 IS NOT NULL만(distinct 조회).
 export const RequestLogListParams = RequestLogBaseListParams.extend({

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

@@ -199,6 +199,7 @@ Content-Type: application/json
       "image_cost_method": null,
       "effort": null,
       "history": null,
+      "tools": null,
       "status": "running",
       "error_message": null,
       "tool_call_count": 0,
@@ -252,7 +253,6 @@ Content-Type: application/json
     "serviceTier": "fast",
     "history": "HISTORY",
     "projectName": "PROJECTNAME",
-    "isStep": false,
     "logger": false,
     "runContext": {
       "requestLogId": 0,
@@ -313,7 +313,6 @@ Content-Type: application/json
     "serviceTier": "fast",
     "history": "HISTORY",
     "projectName": "PROJECTNAME",
-    "isStep": false,
     "logger": false,
     "runContext": {
       "requestLogId": 0,

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

@@ -42,6 +42,7 @@ export const requestLogSubsetQueries = {
       image_cost_method: "request_logs.image_cost_method",
       effort: "request_logs.effort",
       history: "request_logs.history",
+      tools: "request_logs.tools",
       status: "request_logs.status",
       error_message: "request_logs.error_message",
       tool_call_count: "request_logs.tool_call_count",

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

@@ -42,6 +42,16 @@ const TokenCredentials = z.union([
 ]);
 type TokenCredentials = z.infer<typeof TokenCredentials>;
 
+// CustomScalar: ToolDefinitions
+const ToolDefinitions = z.array(
+  z.object({
+    name: z.string(),
+    description: z.string().optional(),
+    inputSchema: z.unknown(),
+  }),
+);
+type ToolDefinitions = z.infer<typeof ToolDefinitions>;
+
 // Enums: RequestLog
 export const RequestLogOrderBy = z.enum(["id-desc"]).describe("RequestLogOrderBy");
 export type RequestLogOrderBy = z.infer<typeof RequestLogOrderBy>;
@@ -111,6 +121,7 @@ export const RequestLogBaseSchema = z.object({
   image_cost_method: z.string().max(100).nullable(),
   effort: z.string().max(10).nullable(),
   history: HistoryItems.nullable(),
+  tools: ToolDefinitions.nullable(),
   status: RequestLogStatus,
   error_message: z.string().nullable(),
   tool_call_count: z.int(),
@@ -141,6 +152,7 @@ export type RequestLogBaseSchema = z.infer<typeof RequestLogBaseSchema> & {
     "image_cost_method",
     "effort",
     "history",
+    "tools",
     "status",
     "error_message",
     "tool_call_count",
@@ -308,6 +320,7 @@ export const RequestLogSubsetA = z.object({
   image_cost_method: z.string().max(100).nullable(),
   effort: z.string().max(10).nullable(),
   history: HistoryItems.nullable(),
+  tools: ToolDefinitions.nullable(),
   status: RequestLogStatus,
   error_message: z.string().nullable(),
   tool_call_count: z.int(),

package/bundle/src/i18n/sd.generated.ts

@@ -234,6 +234,7 @@ const entityLabels = {
   "entity.RequestLog.image_cost_method": "이미지 비용 추정 방식",
   "entity.RequestLog.effort": "effort level",
   "entity.RequestLog.history": "inject_items 히스토리",
+  "entity.RequestLog.tools": "요청에 장착된 tool 정의 목록",
   "entity.RequestLog.status": "실행 상태",
   "entity.RequestLog.error_message": "에러 메시지",
   "entity.RequestLog.tool_call_count": "tool call 횟수",

package/bundle/src/migrations/20260806141701_alter_request_logs_add1_alter1.ts

@@ -0,0 +1,15 @@
+import { type Knex } from "knex";
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.schema.alterTable("request_logs", (table) => {
+    // add
+    table.jsonb("tools").nullable();
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.alterTable("request_logs", (table) => {
+    // rollback - add
+    table.dropColumns("tools");
+  });
+}

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

@@ -382,6 +382,92 @@ describe("CodexAppServerWorker TTFT", () => {
   });
 });
 
+describe("CodexAppServerWorker thread activity timestamps", () => {
+  type ThreadMetaInternals = {
+    threadMeta: Map<string, { lastUsedAt: number }>;
+  };
+
+  it("records non-stream thread activity at turn completion", async () => {
+    let now = 1_000;
+    const nowSpy = vi.spyOn(Date, "now").mockImplementation(() => now);
+    const { worker, request, handlers } = createWorkerWithNotificationRpc(
+      async (method, _params) => {
+        if (method === "thread/start") {
+          return { thread: { id: "thread-1" }, model: "gpt-test" };
+        }
+        if (method === "turn/start") return { turn: { id: "turn-1" } };
+        throw new Error(`unexpected request: ${method}`);
+      },
+    );
+
+    try {
+      const turn = worker.executeTurn({
+        input: [{ type: "text", text: "hi", text_elements: [] }],
+      });
+      await vi.waitFor(() =>
+        expect(request).toHaveBeenCalledWith("turn/start", expect.anything()),
+      );
+      now = 700_000;
+      handlers.get("turn/completed")?.({
+        threadId: "thread-1",
+        turn: { status: "completed", durationMs: 699_000 },
+      } as never);
+
+      await turn;
+
+      expect(
+        (worker as unknown as ThreadMetaInternals).threadMeta.get("thread-1")?.lastUsedAt,
+      ).toBe(700_000);
+    } finally {
+      nowSpy.mockRestore();
+    }
+  });
+
+  it("records streaming thread activity at turn completion", async () => {
+    let now = 2_000;
+    const nowSpy = vi.spyOn(Date, "now").mockImplementation(() => now);
+    const { worker, request, handlers } = createWorkerWithNotificationRpc(
+      async (method, _params) => {
+        if (method === "thread/start") {
+          return { thread: { id: "thread-1" }, model: "gpt-test" };
+        }
+        if (method === "turn/start") return { turn: { id: "turn-1" } };
+        throw new Error(`unexpected request: ${method}`);
+      },
+    );
+    const callbacks: StreamCallbacks = {
+      onDelta: vi.fn(),
+      onComplete: vi.fn(),
+      onError: vi.fn(),
+    };
+
+    try {
+      const turn = worker.executeTurnStream(
+        {
+          input: [{ type: "text", text: "hi", text_elements: [] }],
+        },
+        callbacks,
+      );
+      await vi.waitFor(() =>
+        expect(request).toHaveBeenCalledWith("turn/start", expect.anything()),
+      );
+      now = 800_000;
+      handlers.get("turn/completed")?.({
+        threadId: "thread-1",
+        turn: { status: "completed", durationMs: 798_000 },
+      } as never);
+
+      await turn;
+
+      expect(
+        (worker as unknown as ThreadMetaInternals).threadMeta.get("thread-1")?.lastUsedAt,
+      ).toBe(800_000);
+    } finally {
+      nowSpy.mockRestore();
+    }
+  });
+});
+
 describe("CodexAppServerWorker prompt prefix", () => {
   it("uses the same base instructions with and without an output schema", async () => {
     type WorkerInternals = {
@@ -800,7 +886,7 @@ describe("CodexAppServerWorker thread unsubscribe on eviction", () => {
     expect(unsubscribedIds(request).toSorted()).toEqual(["stale-1", "stale-2"]);
   });
 
-  it("sends thread/unsubscribe for LRU-evicted threads over the cap", () => {
+  it("caps periodic LRU cleanup at the configured maximum", () => {
     const { worker, request, meta } = createWorkerWithUnsubscribeSpy();
     const now = Date.now();
     for (let i = 0; i < 17; i++) {
@@ -809,7 +895,19 @@ describe("CodexAppServerWorker thread unsubscribe on eviction", () => {
 
     worker.sweepIdleThreads();
 
-    // 상한(MAX-1=15)으로 줄이며 가장 오래된 2개가 축출·구독 해제된다.
+    expect(meta.size).toBe(16);
+    expect(unsubscribedIds(request)).toEqual(["t-0"]);
+  });
+
+  it("reserves one LRU slot before creating a new thread", () => {
+    const { worker, request, meta } = createWorkerWithUnsubscribeSpy();
+    const now = Date.now();
+    for (let i = 0; i < 17; i++) {
+      meta.set(`t-${i}`, { lastUsedAt: now - (17 - i) * 1_000 });
+    }
+
+    worker.sweepIdleThreads(true);
+
     expect(meta.size).toBe(15);
     expect(unsubscribedIds(request).toSorted()).toEqual(["t-0", "t-1"]);
   });

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,