@cartanova/qgrid-cli 2.1.0 → 2.2.0

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

@@ -54,6 +54,9 @@ export interface StreamCallbacks {
   onTurnId?: (turnId: string) => void;
 }
 
+type RefreshableWorkerCredentials = Pick<WorkerConfig, "accessToken" | "accountId" | "planType">;
+type ActiveTurnAbort = (error: Error) => void;
+
 // thread/start 공통 옵션
 const THREAD_DEFAULTS = {
   sandbox: "read-only",
@@ -63,10 +66,8 @@ const THREAD_DEFAULTS = {
   },
 } satisfies Partial<ThreadStartParams>;
 
-const BASE_INSTRUCTIONS = {
-  text: "You are a helpful assistant. Do not use any tools such as shell, file operations, or web search. Respond with text only.",
-  withSchema: "You are a helpful assistant. Respond using the provided output schema.",
-} as const;
+const BASE_INSTRUCTIONS =
+  "You are a helpful assistant. Do not use any tools such as shell, file operations, or web search. Respond with text only.";
 
 // codex가 매 요청에 자동 주입하는 내장 tool(shell/web_search/spawn_agent 등 14개)과
 // instruction 블록(permissions/environment_context/skills, ~10KB)을 비활성화
@@ -103,8 +104,19 @@ export class CodexAppServerWorker {
   private ready = false;
   private destroyed = false;
   private busy = false;
+  private activeTurnAbort?: ActiveTurnAbort;
   active = true;
   onReady?: () => void;
+  // restart 시 rpc 객체가 새로 생성되므로, 핸들러를 보관했다가 매 spawn마다 재바인딩한다.
+  serverRequestHandler?: (method: string, params: unknown) => Promise<unknown>;
+
+  // thread 재사용(prompt cache): worker 가 생성한 thread 들의 메타.
+  // ephemeral thread 는 이 프로세스 메모리에만 존재하므로 restart 시 전부 무효.
+  private threadMeta = new Map<string, { lastUsedAt: number }>();
+  // spawn 카운터. restart 마다 증가 → conv 핸들의 epoch 와 대조해 stale thread 감지.
+  private epochCounter = 0;
+  private static readonly THREAD_IDLE_TTL_MS = 10 * 60_000;
+  private static readonly MAX_THREADS_PER_WORKER = 16;
 
   constructor(private config: WorkerConfig) {
     const suffix = config.workerIndex !== undefined ? `-${config.workerIndex}` : "";
@@ -114,6 +126,9 @@ export class CodexAppServerWorker {
   // ── Lifecycle ───────────────────────────────────────────────────
 
   private async spawnAndInit(): Promise<void> {
+    // 새 codex 프로세스 → 기존 ephemeral thread 전부 무효. epoch 증가로 stale 감지.
+    this.epochCounter++;
+    this.threadMeta.clear();
     const cwd = `${this.codexHome}/cwd`;
     mkdirSync(cwd, { recursive: true });
     // codex 내장 tool/web_search/instruction 블록 비활성화
@@ -133,6 +148,9 @@ export class CodexAppServerWorker {
 
     this.proc.on("exit", (code) => {
       logger.info(`worker ${this.config.tokenName} exited (code=${code})`);
+      this.failActiveTurn(
+        new Error(`codex worker exited while turn was running (code=${code ?? "unknown"})`),
+      );
       this.ready = false;
       this.rpc = null;
       this.proc = null;
@@ -140,6 +158,8 @@ export class CodexAppServerWorker {
     });
 
     this.rpc = new CodexRpcClient(this.proc);
+    // restart 후에도 refresh server-request 핸들러를 유지 (없으면 codex 토큰 회전 실패 → session expired)
+    this.bindServerRequestHandler();
 
     await this.rpc.request("initialize", {
       clientInfo: { name: "qgrid", version: "1.0.0" },
@@ -212,6 +232,7 @@ export class CodexAppServerWorker {
   async kill(): Promise<void> {
     this.destroyed = true;
     this.ready = false;
+    this.failActiveTurn(new Error("codex worker stopped"));
     this.rpc?.destroy();
 
     if (this.proc) {
@@ -242,10 +263,31 @@ export class CodexAppServerWorker {
   get tokenId(): number {
     return this.config.tokenId;
   }
+  get workerIndex(): number {
+    return this.config.workerIndex ?? 0;
+  }
   get tokenName(): string {
     return this.config.tokenName;
   }
 
+  canReuseForToken(_tokenName: string, credentials: RefreshableWorkerCredentials): boolean {
+    return (
+      this.config.accountId === credentials.accountId &&
+      (this.config.planType ?? undefined) === (credentials.planType ?? undefined)
+    );
+  }
+
+  updateTokenState(tokenName: string, credentials: RefreshableWorkerCredentials): void {
+    this.config.tokenName = tokenName;
+    this.config.accessToken = credentials.accessToken;
+    this.config.accountId = credentials.accountId;
+    if (credentials.planType) {
+      this.config.planType = credentials.planType;
+    } else {
+      delete this.config.planType;
+    }
+  }
+
   // ── Rate limits ─────────────────────────────────────────────────
 
   async getRateLimits(): Promise<unknown> {
@@ -256,6 +298,14 @@ export class CodexAppServerWorker {
   // ── Server-request delegation ───────────────────────────────────
 
   setServerRequestHandler(handler: (method: string, params: unknown) => Promise<unknown>): void {
+    this.serverRequestHandler = handler;
+    this.bindServerRequestHandler();
+  }
+
+  // spawnAndInit에서 rpc 생성 직후 호출. restart로 rpc가 새로 만들어져도 핸들러가 유지된다.
+  bindServerRequestHandler(): void {
+    const handler = this.serverRequestHandler;
+    if (!handler) return;
     this.rpc?.onServerRequest("account/chatgptAuthTokens/refresh", (params) =>
       handler("account/chatgptAuthTokens/refresh", params),
     );
@@ -275,10 +325,12 @@ export class CodexAppServerWorker {
     return !this.busy;
   }
 
-  async startThread(
-    req: TurnRequest,
-  ): Promise<{ threadId: string; turnId: string; model: string }> {
+  // 새 thread 생성 (thread/start + 필요 시 history inject). 첫 turn / 폴백 경로용.
+  // 후속 turn 은 createThread 없이 startTurnOnThread 만 호출해 conversation_id 를 고정한다.
+  // 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();
 
     const threadConfig: ThreadStartParams["config"] = {
       ...THREAD_DEFAULTS.config,
@@ -289,7 +341,7 @@ export class CodexAppServerWorker {
       {
         ephemeral: true,
         cwd: `${this.codexHome}/cwd`,
-        baseInstructions: req.outputSchema ? BASE_INSTRUCTIONS.withSchema : BASE_INSTRUCTIONS.text,
+        baseInstructions: BASE_INSTRUCTIONS,
         developerInstructions: req.developerInstructions ?? "",
         sandbox: THREAD_DEFAULTS.sandbox,
         approvalPolicy: THREAD_DEFAULTS.approvalPolicy,
@@ -298,13 +350,20 @@ export class CodexAppServerWorker {
     );
 
     const threadId = thread.id;
-    const model = req.model ?? threadModel;
     if (req.history?.length) {
       await this.rpc.request("thread/inject_items", {
         threadId,
         items: req.history,
       } satisfies ThreadInjectItemsParams);
     }
+    this.threadMeta.set(threadId, { lastUsedAt: Date.now() });
+
+    return { threadId, model: req.model ?? threadModel };
+  }
+
+  // 기존 thread 에 turn 만 실행 (inject 없음). conversation_id 유지 → prompt cache 적중.
+  private async startTurnOnThread(threadId: string, req: TurnRequest): Promise<{ turnId: string }> {
+    if (!this.rpc || !this.ready) throw new Error("worker not ready");
 
     const { turn } = await this.rpc.request<TurnStartResponse>("turn/start", {
       threadId,
@@ -315,20 +374,79 @@ export class CodexAppServerWorker {
       ...(req.reasoningSummary ? { summary: req.reasoningSummary } : {}),
       ...(req.serviceTier ? { serviceTier: req.serviceTier } : {}),
     });
-
-    return { threadId, turnId: turn.id, model };
+    const meta = this.threadMeta.get(threadId);
+    if (meta) meta.lastUsedAt = Date.now();
+    return { turnId: turn.id };
   }
 
-  async executeTurn(req: TurnRequest): Promise<TurnResult> {
-    const { threadId, model } = await this.startThread(req);
-    return this.consumeTurnNotifications(threadId, model);
+  // existingThreadId 있으면 그 thread 재사용(후속 turn), 없으면 새 thread 생성(첫 turn).
+  // 호출 후 사용한 threadId 를 반환해 dispatcher 가 conv 핸들을 발급한다.
+  async executeTurn(
+    req: TurnRequest,
+    existingThreadId?: string,
+  ): Promise<TurnResult & { threadId: string }> {
+    let threadId: string;
+    let model: string;
+    if (existingThreadId) {
+      threadId = existingThreadId;
+      model = req.model ?? "";
+    } else {
+      ({ threadId, model } = await this.createThread(req));
+    }
+    await this.startTurnOnThread(threadId, req);
+    const result = await this.consumeTurnNotifications(threadId, model);
+    return { ...result, threadId };
   }
 
-  async executeTurnStream(req: TurnRequest, cb: StreamCallbacks): Promise<void> {
-    const { threadId, turnId, model } = await this.startThread(req);
+  async executeTurnStream(
+    req: TurnRequest,
+    cb: StreamCallbacks,
+    existingThreadId?: string,
+  ): Promise<{ threadId: string }> {
+    let threadId: string;
+    let model: string;
+    if (existingThreadId) {
+      threadId = existingThreadId;
+      model = req.model ?? "";
+    } else {
+      ({ threadId, model } = await this.createThread(req));
+    }
+    const { turnId } = await this.startTurnOnThread(threadId, req);
     cb.onThreadId?.(threadId);
     cb.onTurnId?.(turnId);
-    return this.consumeStreamNotifications(threadId, model, cb);
+    await this.consumeStreamNotifications(threadId, model, cb);
+    return { threadId };
+  }
+
+  // ── thread 재사용 지원 ───────────────────────────────────────────
+
+  get epoch(): number {
+    return this.epochCounter;
+  }
+
+  hasThread(threadId: string): boolean {
+    return this.threadMeta.has(threadId);
+  }
+
+  // idle TTL 초과 / 개수 상한 초과 thread 를 정리. createThread 직전 lazy 호출.
+  // codex ephemeral thread 는 명시적 close RPC 없이 맵에서 제거 → 더 이상 turn 안 보냄.
+  sweepIdleThreads(): void {
+    const now = Date.now();
+    for (const [id, meta] of this.threadMeta) {
+      if (now - meta.lastUsedAt > CodexAppServerWorker.THREAD_IDLE_TTL_MS) {
+        this.threadMeta.delete(id);
+      }
+    }
+    // createThread 직전 호출 → 새 thread 1 개가 곧 추가된다. 추가 후에도 MAX 를 넘지 않도록
+    // MAX-1 이하로 줄여 둔다(그래야 생성 직후 정확히 MAX). LRU: lastUsedAt 오름차순으로 제거.
+    const limit = CodexAppServerWorker.MAX_THREADS_PER_WORKER - 1;
+    if (this.threadMeta.size > limit) {
+      const sorted = [...this.threadMeta.entries()].toSorted(
+        (a, b) => a[1].lastUsedAt - b[1].lastUsedAt,
+      );
+      const over = this.threadMeta.size - limit;
+      for (let i = 0; i < over; i++) this.threadMeta.delete(sorted[i]![0]);
+    }
   }
 
   async interruptTurn(threadId: string, turnId: string): Promise<void> {
@@ -338,11 +456,18 @@ export class CodexAppServerWorker {
     } catch {}
   }
 
+  private failActiveTurn(error: Error): void {
+    const abort = this.activeTurnAbort;
+    this.activeTurnAbort = undefined;
+    abort?.(error);
+  }
+
   private consumeTurnNotifications(threadId: string, model: string): Promise<TurnResult> {
     return new Promise<TurnResult>((resolve, reject) => {
+      let settled = false;
+      let abort: ActiveTurnAbort;
       const timeout = setTimeout(() => {
-        cleanup();
-        reject(new Error("turn timeout (600s)"));
+        finishWithError(new Error("turn timeout (600s)"));
       }, 600_000);
 
       let text = "";
@@ -357,6 +482,7 @@ export class CodexAppServerWorker {
 
       const cleanup = () => {
         clearTimeout(timeout);
+        if (this.activeTurnAbort === abort) this.activeTurnAbort = undefined;
         for (const n of [
           "item/completed",
           "item/agentMessage/delta",
@@ -368,6 +494,23 @@ export class CodexAppServerWorker {
         }
       };
 
+      const finishWithError = (error: Error) => {
+        if (settled) return;
+        settled = true;
+        cleanup();
+        reject(error);
+      };
+
+      const finishWithResult = (result: TurnResult) => {
+        if (settled) return;
+        settled = true;
+        cleanup();
+        resolve(result);
+      };
+
+      abort = finishWithError;
+      this.activeTurnAbort = abort;
+
       this.rpc!.onNotification("item/completed", (p) => {
         if (p.threadId !== threadId) return;
         if (p.item.type === "agentMessage") text = p.item.text;
@@ -375,22 +518,23 @@ export class CodexAppServerWorker {
 
       this.rpc!.onNotification("thread/tokenUsage/updated", (p) => {
         if (p.threadId !== threadId) return;
-        usage = p.tokenUsage.total;
+        // thread 재사용 시 .total 은 대화 전체 누적이라, cold 였던 이전 turn 까지 섞여
+        // 이 요청 자체의 cache 적중률이 희석된다(예: turn1 cold 0% + turn2 90% → 48% 로 기록).
+        // .last 는 이번 turn 만의 usage 라 request_log 가 그 요청의 실제 토큰을 정확히 반영한다.
+        usage = p.tokenUsage.last;
       });
 
       this.rpc!.onNotification("turn/completed", (p) => {
         if (p.threadId !== threadId) return;
         durationMs = p.turn.durationMs ?? 0;
-        cleanup();
-        if (p.turn.status === "completed") resolve({ text, usage, durationMs, model });
-        else reject(new Error(`turn failed: ${JSON.stringify(p.turn.error)}`));
+        if (p.turn.status === "completed") finishWithResult({ text, usage, durationMs, model });
+        else finishWithError(new Error(`turn failed: ${JSON.stringify(p.turn.error)}`));
       });
 
       this.rpc!.onNotification("error", (p) => {
         if (p.threadId !== threadId) return;
         if (!p.willRetry) {
-          cleanup();
-          reject(new Error(`codex error: ${p.error.message}`));
+          finishWithError(new Error(`codex error: ${p.error.message}`));
         }
       });
     });
@@ -402,10 +546,10 @@ export class CodexAppServerWorker {
     cb: StreamCallbacks,
   ): Promise<void> {
     return new Promise<void>((resolve, reject) => {
+      let settled = false;
+      let abort: ActiveTurnAbort;
       const timeout = setTimeout(() => {
-        cleanup();
-        cb.onError(new Error("turn timeout (600s)"));
-        reject(new Error("turn timeout (600s)"));
+        finishWithError(new Error("turn timeout (600s)"));
       }, 600_000);
 
       let text = "";
@@ -419,6 +563,7 @@ export class CodexAppServerWorker {
 
       const cleanup = () => {
         clearTimeout(timeout);
+        if (this.activeTurnAbort === abort) this.activeTurnAbort = undefined;
         for (const n of [
           "item/completed",
           "item/agentMessage/delta",
@@ -430,6 +575,25 @@ export class CodexAppServerWorker {
         }
       };
 
+      const finishWithError = (error: Error) => {
+        if (settled) return;
+        settled = true;
+        cleanup();
+        cb.onError(error);
+        reject(error);
+      };
+
+      const finishWithComplete = (result: TurnResult) => {
+        if (settled) return;
+        settled = true;
+        cleanup();
+        cb.onComplete(result);
+        resolve();
+      };
+
+      abort = finishWithError;
+      this.activeTurnAbort = abort;
+
       this.rpc!.onNotification("item/agentMessage/delta", (p) => {
         if (p.threadId !== threadId) return;
         text += p.delta;
@@ -443,29 +607,25 @@ export class CodexAppServerWorker {
 
       this.rpc!.onNotification("thread/tokenUsage/updated", (p) => {
         if (p.threadId !== threadId) return;
-        usage = p.tokenUsage.total;
+        // thread 재사용 시 .total 은 대화 전체 누적이라, cold 였던 이전 turn 까지 섞여
+        // 이 요청 자체의 cache 적중률이 희석된다(예: turn1 cold 0% + turn2 90% → 48% 로 기록).
+        // .last 는 이번 turn 만의 usage 라 request_log 가 그 요청의 실제 토큰을 정확히 반영한다.
+        usage = p.tokenUsage.last;
       });
 
       this.rpc!.onNotification("turn/completed", (p) => {
         if (p.threadId !== threadId) return;
-        cleanup();
         if (p.turn.status === "completed") {
-          cb.onComplete({ text, usage, durationMs: p.turn.durationMs ?? 0, model });
-          resolve();
+          finishWithComplete({ text, usage, durationMs: p.turn.durationMs ?? 0, model });
         } else {
-          const err = new Error(`turn ${p.turn.status}: ${JSON.stringify(p.turn.error)}`);
-          cb.onError(err);
-          reject(err);
+          finishWithError(new Error(`turn ${p.turn.status}: ${JSON.stringify(p.turn.error)}`));
         }
       });
 
       this.rpc!.onNotification("error", (p) => {
         if (p.threadId !== threadId) return;
         if (!p.willRetry) {
-          cleanup();
-          const err = new Error(`codex error: ${p.error.message}`);
-          cb.onError(err);
-          reject(err);
+          finishWithError(new Error(`codex error: ${p.error.message}`));
         }
       });
     });

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

@@ -0,0 +1,59 @@
+import { describe, expect, it, vi } from "vitest";
+
+import { type OpenAICredentials } from "../../../application/token/token.types";
+import { type CodexAppServerWorker } from "./codex-worker";
+import { OpenAIDispatcher } from "./openai-dispatcher";
+
+function credentials(overrides: Partial<OpenAICredentials> = {}): OpenAICredentials {
+  return {
+    accessToken: "access",
+    refreshToken: "refresh",
+    accessTokenExpiresAt: Date.now() + 60_000,
+    accountId: "account",
+    planType: "plus",
+    ...overrides,
+  };
+}
+
+function fakeWorker(reusable: boolean): CodexAppServerWorker {
+  return {
+    kill: vi.fn(async () => {}),
+    canReuseForToken: vi.fn(() => reusable),
+    updateTokenState: vi.fn(),
+  } as unknown as CodexAppServerWorker;
+}
+
+describe("OpenAIDispatcher token updates", () => {
+  it("keeps existing workers when only OpenAI auth tokens rotate", async () => {
+    const dispatcher = new OpenAIDispatcher();
+    const worker = fakeWorker(true);
+    const spawnWorkers = vi.spyOn(dispatcher, "spawnWorkers").mockResolvedValue(undefined);
+    dispatcher.workerPool.set(1, [worker]);
+
+    const rotated = credentials({
+      accessToken: "new-access",
+      refreshToken: "new-refresh",
+      idToken: "new-id",
+      accessTokenExpiresAt: Date.now() + 120_000,
+    });
+    await dispatcher.onTokenUpdated(1, "renamed-token", rotated);
+
+    expect(worker.kill).not.toHaveBeenCalled();
+    expect(worker.updateTokenState).toHaveBeenCalledWith("renamed-token", rotated);
+    expect(spawnWorkers).not.toHaveBeenCalled();
+    expect(dispatcher.workerPool.get(1)).toEqual([worker]);
+  });
+
+  it("restarts workers when the OpenAI login identity changes", async () => {
+    const dispatcher = new OpenAIDispatcher();
+    const worker = fakeWorker(false);
+    const spawnWorkers = vi.spyOn(dispatcher, "spawnWorkers").mockResolvedValue(undefined);
+    dispatcher.workerPool.set(1, [worker]);
+
+    const changedIdentity = credentials({ accountId: "other-account" });
+    await dispatcher.onTokenUpdated(1, "token", changedIdentity);
+
+    expect(worker.kill).toHaveBeenCalledTimes(1);
+    expect(spawnWorkers).toHaveBeenCalledWith(1, "token", changedIdentity);
+  });
+});