@cartanova/qgrid-cli 2.1.0 → 2.2.0

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

@@ -18,6 +18,12 @@ const WORKERS_PER_TOKEN = Math.min(Number(process.env.QGRID_WORKERS_PER_TOKEN ??
 const QUEUE_TIMEOUT_MS = 6e4;
 const MAX_QUEUE_SIZE = 50;
 const SPAWN_INTERVAL_MS = 500;
+const THREAD_REUSE_ENABLED = process.env.QGRID_OPENAI_THREAD_REUSE !== "false";
+const REUSE_WORKER_WAIT_MS = 5e3;
+const REUSE_WORKER_POLL_MS = 50;
+function makeWorkerId(tokenId, workerIndex) {
+	return tokenId * 10 + workerIndex;
+}
 function sleep(ms) {
 	return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -53,6 +59,16 @@ var OpenAIDispatcher = class OpenAIDispatcher {
 	}
 	async onTokenUpdated(id, name, credentials) {
 		const existing = this.workerPool.get(id) ?? [];
+		if (existing.length === 0) {
+			await this.spawnWorkers(id, name, credentials);
+			return;
+		}
+		if (existing.every((w) => w.canReuseForToken(name, credentials))) {
+			existing.forEach((w) => w.updateTokenState(name, credentials));
+			logger.info(`workers updated in-place for token ${id} (${name})`);
+			this.drainQueue();
+			return;
+		}
 		this.workerPool.delete(id);
 		await Promise.allSettled(existing.map((w) => w.kill()));
 		await this.spawnWorkers(id, name, credentials);
@@ -72,6 +88,11 @@ var OpenAIDispatcher = class OpenAIDispatcher {
 		logger.info(`workers activated: token ${id}`);
 	}
 	async generate(req) {
+		const reuseWorker = await this.acquireReuseWorker(req);
+		if (reuseWorker) {
+			logger.info(`↻ ${reuseWorker.tokenName}[${reuseWorker.tokenId}] (reuse thread, ${req.model})`);
+			return this.executeAndRelease(reuseWorker, (w) => this.executeTurn(w, req, req.reuse.threadId));
+		}
 		const worker = this.acquireIdleWorker();
 		if (worker) {
 			logger.info(`→ ${worker.tokenName}[${worker.tokenId}] (model: ${req.model})`);
@@ -83,6 +104,11 @@ var OpenAIDispatcher = class OpenAIDispatcher {
 		});
 	}
 	async generateStream(req, cb) {
+		const reuseWorker = await this.acquireReuseWorker(req);
+		if (reuseWorker) {
+			logger.info(`↻ ${reuseWorker.tokenName}[${reuseWorker.tokenId}] (reuse thread, [stream])`);
+			return this.executeAndRelease(reuseWorker, (w) => this.executeStreamTurn(w, req, cb, req.reuse.threadId));
+		}
 		const worker = this.acquireIdleWorker();
 		if (worker) {
 			logger.info(`→ ${worker.tokenName}[${worker.tokenId}] (model: ${req.model}, [stream])`);
@@ -93,6 +119,25 @@ var OpenAIDispatcher = class OpenAIDispatcher {
 			return this.executeStreamTurn(w, req, cb);
 		});
 	}
+	async acquireReuseWorker(req) {
+		if (!THREAD_REUSE_ENABLED || !req.reuse) return null;
+		const { workerId, threadId, epoch } = req.reuse;
+		const worker = this.findWorkerById(workerId);
+		if (!worker || !worker.isReady || !worker.active) return null;
+		if (worker.epoch !== epoch) return null;
+		if (!worker.hasThread(threadId)) return null;
+		const deadline = Date.now() + REUSE_WORKER_WAIT_MS;
+		for (;;) {
+			if (worker.epoch !== epoch || !worker.hasThread(threadId)) return null;
+			if (worker.tryAcquireTurn()) return worker;
+			if (Date.now() >= deadline) return null;
+			await sleep(REUSE_WORKER_POLL_MS);
+		}
+	}
+	findWorkerById(workerId) {
+		for (const workers of this.workerPool.values()) for (const w of workers) if (makeWorkerId(w.tokenId, w.workerIndex) === workerId) return w;
+		return null;
+	}
 	async interruptWorkerTurn(threadId, turnId) {
 		const allWorkers = [...this.workerPool.values()].flat().filter((w) => w.isReady);
 		await Promise.allSettled(allWorkers.map((w) => w.interruptTurn(threadId, turnId)));
@@ -169,49 +214,58 @@ var OpenAIDispatcher = class OpenAIDispatcher {
 			this.drainQueue(worker);
 		}
 	}
-	async executeTurn(worker, req) {
-		const turnReq = {
-			input: req.input,
+	buildTurnRequest(req, reuseThreadId) {
+		const reusing = reuseThreadId !== void 0;
+		return {
+			input: reusing && req.reuseInput ? req.reuseInput : req.coldInput,
+			history: reusing ? void 0 : req.coldHistory,
 			developerInstructions: req.systemPrompt,
 			outputSchema: req.outputSchema,
 			effort: req.effort ?? DEFAULT_EFFORT,
 			model: req.model,
-			history: req.history,
 			verbosity: req.verbosity,
 			reasoningSummary: req.reasoningSummary,
 			serviceTier: req.serviceTier
 		};
-		const result = await worker.executeTurn(turnReq);
+	}
+	async executeTurn(worker, req, reuseThreadId) {
+		const turnReq = this.buildTurnRequest(req, reuseThreadId);
+		const result = await worker.executeTurn(turnReq, reuseThreadId);
 		return {
 			text: result.text,
 			tokenName: worker.tokenName,
 			usage: result.usage,
 			durationMs: result.durationMs,
-			model: result.model
+			model: result.model,
+			threadCoord: {
+				workerId: makeWorkerId(worker.tokenId, worker.workerIndex),
+				threadId: result.threadId,
+				epoch: worker.epoch
+			}
 		};
 	}
-	async executeStreamTurn(worker, req, cb) {
-		const turnReq = {
-			input: req.input,
-			developerInstructions: req.systemPrompt,
-			outputSchema: req.outputSchema,
-			effort: req.effort ?? DEFAULT_EFFORT,
-			model: req.model,
-			history: req.history,
-			verbosity: req.verbosity,
-			reasoningSummary: req.reasoningSummary,
-			serviceTier: req.serviceTier
-		};
+	async executeStreamTurn(worker, req, cb, reuseThreadId) {
+		const turnReq = this.buildTurnRequest(req, reuseThreadId);
+		let resolvedThreadId = reuseThreadId ?? "";
 		const wrappedCb = {
 			...cb,
+			onThreadId: (threadId) => {
+				resolvedThreadId = threadId;
+				cb.onThreadId?.(threadId);
+			},
 			onComplete: (result) => {
 				cb.onComplete({
 					...result,
-					tokenName: worker.tokenName
+					tokenName: worker.tokenName,
+					threadCoord: {
+						workerId: makeWorkerId(worker.tokenId, worker.workerIndex),
+						threadId: resolvedThreadId,
+						epoch: worker.epoch
+					}
 				});
 			}
 		};
-		await worker.executeTurnStream(turnReq, wrappedCb);
+		await worker.executeTurnStream(turnReq, wrappedCb, reuseThreadId);
 	}
 	async spawnWorkers(tokenId, tokenName, credentials) {
 		const workers = [];
@@ -322,4 +376,4 @@ var OpenAIDispatcher = class OpenAIDispatcher {
 //#endregion
 export { OpenAIDispatcher };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"openai-dispatcher.js","names":[],"sources":["../../../../src/utils/providers/openai/openai-dispatcher.ts"],"sourcesContent":["/**\n * OpenAIDispatcher — codex app-server worker pool + 토큰 라우팅.\n *\n * - 토큰당 N worker (CodexAppServerWorker), 기본 3\n * - idle worker round-robin 선택 + 큐 대기 (전부 busy 시)\n * - TokenSubscriber 이벤트로 worker pool 동기화\n * - backpressure: 큐 full 또는 timeout 시 SERVER_BUSY\n */\nimport { getLogger } from \"@logtape/logtape\";\n\nimport { TokenModel } from \"../../../application/token/token.model\";\nimport { type OpenAICredentials } from \"../../../application/token/token.types\";\nimport {\n  type GenerateRequest,\n  type GenerateResult,\n  type ProviderDispatcher,\n} from \"../common/provider-dispatcher\";\nimport {\n  CodexAppServerWorker,\n  type StreamCallbacks,\n  type TurnRequest,\n  type TurnResult,\n} from \"./codex-worker\";\nimport { handleChatgptAuthTokensRefresh } from \"./openai-refresh\";\n\nconst logger = getLogger([\"qgrid\", \"openai-dispatcher\"]);\n\nconst DEFAULT_EFFORT = \"low\";\nconst MAX_WORKERS_PER_TOKEN = 5;\nconst WORKERS_PER_TOKEN = Math.min(\n  Number(process.env.QGRID_WORKERS_PER_TOKEN ?? 3),\n  MAX_WORKERS_PER_TOKEN,\n);\nconst QUEUE_TIMEOUT_MS = 60_000;\nconst MAX_QUEUE_SIZE = 50;\nconst SPAWN_INTERVAL_MS = 500;\n\nfunction sleep(ms: number): Promise<void> {\n  return new Promise((resolve) => setTimeout(resolve, ms));\n}\n\ntype QueueItem = {\n  resolve: (worker: CodexAppServerWorker) => void;\n  reject: (error: Error) => void;\n  timer: ReturnType<typeof setTimeout>;\n  abortCleanup?: () => void;\n};\n\nexport class OpenAIDispatcher implements ProviderDispatcher {\n  workerPool = new Map<number, CodexAppServerWorker[]>();\n  rrCursor = 0;\n  queue: QueueItem[] = [];\n\n  async start(): Promise<void> {\n    const { rows } = await TokenModel.findMany(\"A\");\n    const openaiTokens = rows.filter((t) => t.provider === \"openai\");\n    logger.info(\n      `starting ${openaiTokens.length} openai tokens (${WORKERS_PER_TOKEN} workers each)`,\n    );\n\n    await Promise.allSettled(\n      openaiTokens.map(async (t) => {\n        await this.spawnWorkers(t.id, t.name, t.credentials as OpenAICredentials);\n        if (!t.active) this.onTokenDeactivated(t.id);\n      }),\n    );\n  }\n\n  async stop(): Promise<void> {\n    this.rejectAllQueued(\"DISPATCHER_SHUTDOWN\");\n    const kills = [...this.workerPool.values()].flat().map((w) => w.kill());\n    await Promise.allSettled(kills);\n    this.workerPool.clear();\n  }\n\n  // ── Token events (from TokenSubscriber) ─────────────────────────\n\n  async onTokenAdded(id: number, name: string, credentials: OpenAICredentials): Promise<void> {\n    if (this.workerPool.has(id)) return;\n    await this.spawnWorkers(id, name, credentials);\n  }\n\n  async onTokenRemoved(id: number): Promise<void> {\n    const workers = this.workerPool.get(id) ?? [];\n    this.workerPool.delete(id);\n    await Promise.allSettled(workers.map((w) => w.kill()));\n    if (this.getAllReadyActiveWorkers().length === 0) {\n      this.rejectAllQueued(\"NO_OPENAI_WORKERS\");\n    }\n    if (workers.length > 0) logger.info(`workers removed for token ${id}: ${workers.length}`);\n  }\n\n  async onTokenUpdated(id: number, name: string, credentials: OpenAICredentials): Promise<void> {\n    const existing = this.workerPool.get(id) ?? [];\n    this.workerPool.delete(id);\n    await Promise.allSettled(existing.map((w) => w.kill()));\n    await this.spawnWorkers(id, name, credentials);\n  }\n\n  onTokenDeactivated(id: number): void {\n    (this.workerPool.get(id) ?? []).forEach((w) => {\n      w.active = false;\n    });\n    if (this.getAllReadyActiveWorkers().length === 0) {\n      this.rejectAllQueued(\"NO_ACTIVE_WORKERS\");\n    }\n    logger.info(`workers deactivated: token ${id}`);\n  }\n\n  onTokenActivated(id: number): void {\n    (this.workerPool.get(id) ?? []).forEach((w) => {\n      w.active = true;\n    });\n    this.drainQueue();\n    logger.info(`workers activated: token ${id}`);\n  }\n\n  // ── Generate ────────────────────────────────────────────────────\n\n  async generate(req: GenerateRequest): Promise<GenerateResult> {\n    const worker = this.acquireIdleWorker();\n    if (worker) {\n      logger.info(`→ ${worker.tokenName}[${worker.tokenId}] (model: ${req.model})`);\n      return this.executeAndRelease(worker, (w) => this.executeTurn(w, req));\n    }\n    return this.enqueue((w) => {\n      logger.info(`→ ${w.tokenName}[${w.tokenId}] (model: ${req.model}, queued)`);\n      return this.executeTurn(w, req);\n    });\n  }\n\n  async generateStream(req: GenerateRequest, cb: StreamCallbacks): Promise<void> {\n    const worker = this.acquireIdleWorker();\n    if (worker) {\n      logger.info(`→ ${worker.tokenName}[${worker.tokenId}] (model: ${req.model}, [stream])`);\n      return this.executeAndRelease(worker, (w) => this.executeStreamTurn(w, req, cb));\n    }\n    return this.enqueue((w) => {\n      logger.info(`→ ${w.tokenName}[${w.tokenId}] (model: ${req.model}, [stream], queued)`);\n      return this.executeStreamTurn(w, req, cb);\n    });\n  }\n\n  async interruptWorkerTurn(threadId: string, turnId: string): Promise<void> {\n    const allWorkers = [...this.workerPool.values()].flat().filter((w) => w.isReady);\n    await Promise.allSettled(allWorkers.map((w) => w.interruptTurn(threadId, turnId)));\n  }\n\n  // ── Worker selection ────────────────────────────────────────────\n  //  기본 round-robin\n  // TODO: 추후 다른 알고리즘으로 변경 가능하게 지원\n  acquireIdleWorker(): CodexAppServerWorker | null {\n    const allWorkers = this.getAllReadyActiveWorkers();\n    if (allWorkers.length === 0) return null;\n    for (let i = 0; i < allWorkers.length; i++) {\n      const w = allWorkers[(this.rrCursor + i) % allWorkers.length]!;\n      if (w.tryAcquireTurn()) {\n        this.rrCursor = (this.rrCursor + i + 1) % allWorkers.length;\n        return w;\n      }\n    }\n    return null;\n  }\n\n  getAllReadyActiveWorkers(): CodexAppServerWorker[] {\n    return [...this.workerPool.values()].flat().filter((w) => w.isReady && w.active);\n  }\n\n  // ── Queue ───────────────────────────────────────────────────────\n\n  enqueue<T>(execute: (worker: CodexAppServerWorker) => Promise<T>): Promise<T> {\n    if (this.getAllReadyActiveWorkers().length === 0) {\n      return Promise.reject(new Error(\"NO_OPENAI_WORKERS\"));\n    }\n    if (this.queue.length >= MAX_QUEUE_SIZE) {\n      return Promise.reject(new Error(\"SERVER_BUSY\"));\n    }\n\n    return new Promise<T>((resolve, reject) => {\n      const item: QueueItem = {\n        resolve: (worker) => {\n          clearTimeout(item.timer);\n          item.abortCleanup?.();\n          Promise.resolve()\n            .then(() => this.executeAndRelease(worker, execute))\n            .then(resolve, reject);\n        },\n        reject: (err) => {\n          clearTimeout(item.timer);\n          item.abortCleanup?.();\n          reject(err);\n        },\n        timer: setTimeout(() => {\n          this.removeFromQueue(item);\n          reject(new Error(\"SERVER_BUSY\"));\n        }, QUEUE_TIMEOUT_MS),\n      };\n\n      this.queue.push(item);\n    });\n  }\n\n  removeFromQueue(item: QueueItem): void {\n    clearTimeout(item.timer);\n    item.abortCleanup?.();\n    const idx = this.queue.indexOf(item);\n    if (idx !== -1) this.queue.splice(idx, 1);\n  }\n\n  rejectAllQueued(reason: string): void {\n    const err = new Error(reason);\n    this.queue.forEach((item) => {\n      clearTimeout(item.timer);\n      item.abortCleanup?.();\n      item.reject(err);\n    });\n    this.queue = [];\n  }\n\n  drainQueue(releasedWorker?: CodexAppServerWorker): void {\n    if (\n      releasedWorker &&\n      this.queue.length > 0 &&\n      releasedWorker.isReady &&\n      releasedWorker.active &&\n      releasedWorker.tryAcquireTurn()\n    ) {\n      const next = this.queue.shift()!;\n      next.resolve(releasedWorker);\n      return;\n    }\n\n    while (this.queue.length > 0) {\n      const worker = this.acquireIdleWorker();\n      if (!worker) break;\n      const next = this.queue.shift()!;\n      next.resolve(worker);\n    }\n  }\n\n  // ── Execution ───────────────────────────────────────────────────\n\n  async executeAndRelease<T>(\n    worker: CodexAppServerWorker,\n    execute: (worker: CodexAppServerWorker) => Promise<T>,\n  ): Promise<T> {\n    try {\n      return await execute(worker);\n    } finally {\n      worker.releaseTurn();\n      this.drainQueue(worker);\n    }\n  }\n\n  async executeTurn(worker: CodexAppServerWorker, req: GenerateRequest): Promise<GenerateResult> {\n    const turnReq: TurnRequest = {\n      input: req.input,\n      developerInstructions: req.systemPrompt,\n      outputSchema: req.outputSchema,\n      effort: req.effort ?? DEFAULT_EFFORT,\n      model: req.model,\n      history: req.history,\n      verbosity: req.verbosity,\n      reasoningSummary: req.reasoningSummary,\n      serviceTier: req.serviceTier,\n    };\n    const result: TurnResult = await worker.executeTurn(turnReq);\n    return {\n      text: result.text,\n      tokenName: worker.tokenName,\n      usage: result.usage,\n      durationMs: result.durationMs,\n      model: result.model,\n    };\n  }\n\n  async executeStreamTurn(\n    worker: CodexAppServerWorker,\n    req: GenerateRequest,\n    cb: StreamCallbacks,\n  ): Promise<void> {\n    const turnReq: TurnRequest = {\n      input: req.input,\n      developerInstructions: req.systemPrompt,\n      outputSchema: req.outputSchema,\n      effort: req.effort ?? DEFAULT_EFFORT,\n      model: req.model,\n      history: req.history,\n      verbosity: req.verbosity,\n      reasoningSummary: req.reasoningSummary,\n      serviceTier: req.serviceTier,\n    };\n    const wrappedCb: StreamCallbacks = {\n      ...cb,\n      onComplete: (result) => {\n        cb.onComplete({ ...result, tokenName: worker.tokenName } as TurnResult & {\n          tokenName: string;\n        });\n      },\n    };\n    await worker.executeTurnStream(turnReq, wrappedCb);\n  }\n\n  // ── Spawn ───────────────────────────────────────────────────────\n\n  async spawnWorkers(\n    tokenId: number,\n    tokenName: string,\n    credentials: OpenAICredentials,\n  ): Promise<void> {\n    const workers: CodexAppServerWorker[] = [];\n    for (let i = 0; i < WORKERS_PER_TOKEN; i++) {\n      if (i > 0) await sleep(SPAWN_INTERVAL_MS);\n      const worker = await this.spawnSingleWorker(tokenId, tokenName, credentials, i);\n      if (worker) workers.push(worker);\n    }\n    if (workers.length > 0) {\n      this.workerPool.set(tokenId, workers);\n      logger.info(`${workers.length}/${WORKERS_PER_TOKEN} workers spawned for ${tokenName}`);\n    }\n  }\n\n  async spawnSingleWorker(\n    tokenId: number,\n    tokenName: string,\n    credentials: OpenAICredentials,\n    workerIndex: number,\n  ): Promise<CodexAppServerWorker | null> {\n    const worker = new CodexAppServerWorker({\n      tokenId,\n      tokenName,\n      accessToken: credentials.accessToken,\n      accountId: credentials.accountId,\n      planType: credentials.planType,\n      workerIndex,\n    });\n\n    worker.onReady = () => this.drainQueue();\n\n    worker.setServerRequestHandler(async (method) => {\n      if (method === \"account/chatgptAuthTokens/refresh\") {\n        return handleChatgptAuthTokensRefresh(tokenId);\n      }\n      throw new Error(`unhandled server-request: ${method}`);\n    });\n\n    try {\n      await worker.initialize();\n      logger.info(`worker spawned: ${tokenName}[${workerIndex}] (id=${tokenId + 1})`);\n      return worker;\n    } catch (e) {\n      logger.warn(`worker spawn failed: ${tokenName}[${workerIndex}]: ${(e as Error).message}`);\n      await worker.kill().catch(() => {});\n      return null;\n    }\n  }\n\n  // ── Rate limits ─────────────────────────────────────────────────\n\n  rateLimitsCache = new Map<string, { data: unknown; cachedAt: number }>();\n  static readonly RATE_LIMITS_CACHE_TTL = 60_000;\n\n  async getRateLimits(tokenName?: string): Promise<unknown> {\n    const cacheKey = tokenName ?? \"_default\";\n    const cached = this.rateLimitsCache.get(cacheKey);\n    if (cached && Date.now() - cached.cachedAt < OpenAIDispatcher.RATE_LIMITS_CACHE_TTL) {\n      return cached.data;\n    }\n\n    const allWorkers = [...this.workerPool.values()].flat().filter((w) => w.isReady);\n    const worker = tokenName ? allWorkers.find((w) => w.tokenName === tokenName) : allWorkers[0];\n    if (!worker) throw new Error(\"no ready openai workers\");\n    const data = await worker.getRateLimits();\n    this.rateLimitsCache.set(cacheKey, { data, cachedAt: Date.now() });\n    return data;\n  }\n\n  // ── Browser login flow ───────────────────────────────────────────\n\n  pendingLogin: {\n    worker: CodexAppServerWorker;\n    name: string;\n    timer: ReturnType<typeof setTimeout>;\n  } | null = null;\n\n  async startBrowserLogin(name: string): Promise<{ authUrl: string }> {\n    if (this.pendingLogin) {\n      this.pendingLogin.worker.kill().catch(() => {});\n      clearTimeout(this.pendingLogin.timer);\n      this.pendingLogin = null;\n    }\n\n    const tempId = Date.now();\n    const worker = new CodexAppServerWorker({\n      tokenId: tempId,\n      tokenName: name,\n      accessToken: \"\",\n      accountId: \"\",\n    });\n\n    const authUrl = await worker.startBrowserLogin();\n\n    const timer = setTimeout(() => {\n      if (this.pendingLogin?.worker === worker) {\n        logger.warn(`browser login timeout for ${name}, killing worker`);\n        worker.kill().catch(() => {});\n        this.pendingLogin = null;\n      }\n    }, 300_000);\n\n    this.pendingLogin = { worker, name, timer };\n    return { authUrl };\n  }\n\n  get pendingLoginName(): string | null {\n    return this.pendingLogin?.name ?? null;\n  }\n\n  async completeBrowserLogin(): Promise<{\n    accessToken: string;\n    refreshToken: string;\n    idToken?: string;\n    accountId: string;\n  }> {\n    if (!this.pendingLogin) throw new Error(\"no pending login\");\n    const { worker, timer } = this.pendingLogin;\n\n    try {\n      await worker.waitForBrowserLoginComplete();\n      const creds = await worker.readManagedCredentials();\n      if (!creds) throw new Error(\"failed to read credentials after login\");\n      return creds;\n    } finally {\n      clearTimeout(timer);\n      this.pendingLogin = null;\n      await worker.kill().catch(() => {});\n    }\n  }\n\n  // ── Stats ───────────────────────────────────────────────────────\n\n  get workerCount(): number {\n    return [...this.workerPool.values()].flat().length;\n  }\n\n  get readyWorkerCount(): number {\n    return [...this.workerPool.values()].flat().filter((w) => w.isReady).length;\n  }\n\n  get queueLength(): number {\n    return this.queue.length;\n  }\n}\n"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"openai-dispatcher.js","names":[],"sources":["../../../../src/utils/providers/openai/openai-dispatcher.ts"],"sourcesContent":["/**\n * OpenAIDispatcher — codex app-server worker pool + 토큰 라우팅.\n *\n * - 토큰당 N worker (CodexAppServerWorker), 기본 3\n * - idle worker round-robin 선택 + 큐 대기 (전부 busy 시)\n * - TokenSubscriber 이벤트로 worker pool 동기화\n * - backpressure: 큐 full 또는 timeout 시 SERVER_BUSY\n */\nimport { getLogger } from \"@logtape/logtape\";\n\nimport { TokenModel } from \"../../../application/token/token.model\";\nimport { type OpenAICredentials } from \"../../../application/token/token.types\";\nimport {\n  type GenerateRequest,\n  type GenerateResult,\n  type GenerateStreamCallbacks,\n  type ProviderDispatcher,\n} from \"../common/provider-dispatcher\";\nimport { CodexAppServerWorker, type StreamCallbacks, type TurnRequest } from \"./codex-worker\";\nimport { handleChatgptAuthTokensRefresh } from \"./openai-refresh\";\n\nconst logger = getLogger([\"qgrid\", \"openai-dispatcher\"]);\n\nconst DEFAULT_EFFORT = \"low\";\nconst MAX_WORKERS_PER_TOKEN = 5;\nconst WORKERS_PER_TOKEN = Math.min(\n  Number(process.env.QGRID_WORKERS_PER_TOKEN ?? 3),\n  MAX_WORKERS_PER_TOKEN,\n);\nconst QUEUE_TIMEOUT_MS = 60_000;\nconst MAX_QUEUE_SIZE = 50;\nconst SPAWN_INTERVAL_MS = 500;\n\n// thread 재사용(prompt cache 고정). 끄면 기존 \"매 turn 새 thread + history inject\" 동작.\nconst THREAD_REUSE_ENABLED = process.env.QGRID_OPENAI_THREAD_REUSE !== \"false\";\n// 좌표 worker 가 busy 일 때 free 를 기다리는 최대 시간. 초과 시 새 thread 로 폴백.\nconst REUSE_WORKER_WAIT_MS = 5_000;\nconst REUSE_WORKER_POLL_MS = 50;\n\n// workerId 합성: tokenId 와 workerIndex(0..4) 를 하나의 안정 숫자로 인코딩.\nfunction makeWorkerId(tokenId: number, workerIndex: number): number {\n  return tokenId * 10 + workerIndex;\n}\n\nfunction sleep(ms: number): Promise<void> {\n  return new Promise((resolve) => setTimeout(resolve, ms));\n}\n\ntype QueueItem = {\n  resolve: (worker: CodexAppServerWorker) => void;\n  reject: (error: Error) => void;\n  timer: ReturnType<typeof setTimeout>;\n  abortCleanup?: () => void;\n};\n\nexport class OpenAIDispatcher implements ProviderDispatcher {\n  workerPool = new Map<number, CodexAppServerWorker[]>();\n  rrCursor = 0;\n  queue: QueueItem[] = [];\n\n  async start(): Promise<void> {\n    const { rows } = await TokenModel.findMany(\"A\");\n    const openaiTokens = rows.filter((t) => t.provider === \"openai\");\n    logger.info(\n      `starting ${openaiTokens.length} openai tokens (${WORKERS_PER_TOKEN} workers each)`,\n    );\n\n    await Promise.allSettled(\n      openaiTokens.map(async (t) => {\n        await this.spawnWorkers(t.id, t.name, t.credentials as OpenAICredentials);\n        if (!t.active) this.onTokenDeactivated(t.id);\n      }),\n    );\n  }\n\n  async stop(): Promise<void> {\n    this.rejectAllQueued(\"DISPATCHER_SHUTDOWN\");\n    const kills = [...this.workerPool.values()].flat().map((w) => w.kill());\n    await Promise.allSettled(kills);\n    this.workerPool.clear();\n  }\n\n  // ── Token events (from TokenSubscriber) ─────────────────────────\n\n  async onTokenAdded(id: number, name: string, credentials: OpenAICredentials): Promise<void> {\n    if (this.workerPool.has(id)) return;\n    await this.spawnWorkers(id, name, credentials);\n  }\n\n  async onTokenRemoved(id: number): Promise<void> {\n    const workers = this.workerPool.get(id) ?? [];\n    this.workerPool.delete(id);\n    await Promise.allSettled(workers.map((w) => w.kill()));\n    if (this.getAllReadyActiveWorkers().length === 0) {\n      this.rejectAllQueued(\"NO_OPENAI_WORKERS\");\n    }\n    if (workers.length > 0) logger.info(`workers removed for token ${id}: ${workers.length}`);\n  }\n\n  async onTokenUpdated(id: number, name: string, credentials: OpenAICredentials): Promise<void> {\n    const existing = this.workerPool.get(id) ?? [];\n    if (existing.length === 0) {\n      await this.spawnWorkers(id, name, credentials);\n      return;\n    }\n\n    if (existing.every((w) => w.canReuseForToken(name, credentials))) {\n      existing.forEach((w) => w.updateTokenState(name, credentials));\n      logger.info(`workers updated in-place for token ${id} (${name})`);\n      this.drainQueue();\n      return;\n    }\n\n    this.workerPool.delete(id);\n    await Promise.allSettled(existing.map((w) => w.kill()));\n    await this.spawnWorkers(id, name, credentials);\n  }\n\n  onTokenDeactivated(id: number): void {\n    (this.workerPool.get(id) ?? []).forEach((w) => {\n      w.active = false;\n    });\n    if (this.getAllReadyActiveWorkers().length === 0) {\n      this.rejectAllQueued(\"NO_ACTIVE_WORKERS\");\n    }\n    logger.info(`workers deactivated: token ${id}`);\n  }\n\n  onTokenActivated(id: number): void {\n    (this.workerPool.get(id) ?? []).forEach((w) => {\n      w.active = true;\n    });\n    this.drainQueue();\n    logger.info(`workers activated: token ${id}`);\n  }\n\n  // ── Generate ────────────────────────────────────────────────────\n\n  async generate(req: GenerateRequest): Promise<GenerateResult> {\n    // thread 재사용 경로: 좌표 worker 를 점유해 기존 thread 에 turn 만 실행.\n    const reuseWorker = await this.acquireReuseWorker(req);\n    if (reuseWorker) {\n      logger.info(\n        `↻ ${reuseWorker.tokenName}[${reuseWorker.tokenId}] (reuse thread, ${req.model})`,\n      );\n      return this.executeAndRelease(reuseWorker, (w) =>\n        this.executeTurn(w, req, req.reuse!.threadId),\n      );\n    }\n\n    const worker = this.acquireIdleWorker();\n    if (worker) {\n      logger.info(`→ ${worker.tokenName}[${worker.tokenId}] (model: ${req.model})`);\n      return this.executeAndRelease(worker, (w) => this.executeTurn(w, req));\n    }\n    return this.enqueue((w) => {\n      logger.info(`→ ${w.tokenName}[${w.tokenId}] (model: ${req.model}, queued)`);\n      return this.executeTurn(w, req);\n    });\n  }\n\n  async generateStream(req: GenerateRequest, cb: GenerateStreamCallbacks): Promise<void> {\n    const reuseWorker = await this.acquireReuseWorker(req);\n    if (reuseWorker) {\n      logger.info(`↻ ${reuseWorker.tokenName}[${reuseWorker.tokenId}] (reuse thread, [stream])`);\n      return this.executeAndRelease(reuseWorker, (w) =>\n        this.executeStreamTurn(w, req, cb, req.reuse!.threadId),\n      );\n    }\n\n    const worker = this.acquireIdleWorker();\n    if (worker) {\n      logger.info(`→ ${worker.tokenName}[${worker.tokenId}] (model: ${req.model}, [stream])`);\n      return this.executeAndRelease(worker, (w) => this.executeStreamTurn(w, req, cb));\n    }\n    return this.enqueue((w) => {\n      logger.info(`→ ${w.tokenName}[${w.tokenId}] (model: ${req.model}, [stream], queued)`);\n      return this.executeStreamTurn(w, req, cb);\n    });\n  }\n\n  // reuse 좌표가 유효하면 그 worker 를 busy 점유해 반환. 없거나 폴백 대상이면 null.\n  // 폴백 사유: 기능 off / 좌표 없음 / worker 부재·죽음 / epoch 불일치(restart) / thread 소멸 /\n  //            busy 대기 타임아웃. null 반환 시 호출부는 새 thread 경로로 진행.\n  async acquireReuseWorker(req: GenerateRequest): Promise<CodexAppServerWorker | null> {\n    if (!THREAD_REUSE_ENABLED || !req.reuse) return null;\n    const { workerId, threadId, epoch } = req.reuse;\n\n    const worker = this.findWorkerById(workerId);\n    if (!worker || !worker.isReady || !worker.active) return null;\n    if (worker.epoch !== epoch) return null;\n    if (!worker.hasThread(threadId)) return null;\n\n    const deadline = Date.now() + REUSE_WORKER_WAIT_MS;\n    for (;;) {\n      // restart(epoch 변경) / thread 소멸이 대기 중에 발생하면 폴백.\n      if (worker.epoch !== epoch || !worker.hasThread(threadId)) return null;\n      if (worker.tryAcquireTurn()) return worker;\n      if (Date.now() >= deadline) return null;\n      await sleep(REUSE_WORKER_POLL_MS);\n    }\n  }\n\n  findWorkerById(workerId: number): CodexAppServerWorker | null {\n    for (const workers of this.workerPool.values()) {\n      for (const w of workers) {\n        if (makeWorkerId(w.tokenId, w.workerIndex) === workerId) return w;\n      }\n    }\n    return null;\n  }\n\n  async interruptWorkerTurn(threadId: string, turnId: string): Promise<void> {\n    const allWorkers = [...this.workerPool.values()].flat().filter((w) => w.isReady);\n    await Promise.allSettled(allWorkers.map((w) => w.interruptTurn(threadId, turnId)));\n  }\n\n  // ── Worker selection ────────────────────────────────────────────\n  //  기본 round-robin\n  // TODO: 추후 다른 알고리즘으로 변경 가능하게 지원\n  acquireIdleWorker(): CodexAppServerWorker | null {\n    const allWorkers = this.getAllReadyActiveWorkers();\n    if (allWorkers.length === 0) return null;\n    for (let i = 0; i < allWorkers.length; i++) {\n      const w = allWorkers[(this.rrCursor + i) % allWorkers.length]!;\n      if (w.tryAcquireTurn()) {\n        this.rrCursor = (this.rrCursor + i + 1) % allWorkers.length;\n        return w;\n      }\n    }\n    return null;\n  }\n\n  getAllReadyActiveWorkers(): CodexAppServerWorker[] {\n    return [...this.workerPool.values()].flat().filter((w) => w.isReady && w.active);\n  }\n\n  // ── Queue ───────────────────────────────────────────────────────\n\n  enqueue<T>(execute: (worker: CodexAppServerWorker) => Promise<T>): Promise<T> {\n    if (this.getAllReadyActiveWorkers().length === 0) {\n      return Promise.reject(new Error(\"NO_OPENAI_WORKERS\"));\n    }\n    if (this.queue.length >= MAX_QUEUE_SIZE) {\n      return Promise.reject(new Error(\"SERVER_BUSY\"));\n    }\n\n    return new Promise<T>((resolve, reject) => {\n      const item: QueueItem = {\n        resolve: (worker) => {\n          clearTimeout(item.timer);\n          item.abortCleanup?.();\n          Promise.resolve()\n            .then(() => this.executeAndRelease(worker, execute))\n            .then(resolve, reject);\n        },\n        reject: (err) => {\n          clearTimeout(item.timer);\n          item.abortCleanup?.();\n          reject(err);\n        },\n        timer: setTimeout(() => {\n          this.removeFromQueue(item);\n          reject(new Error(\"SERVER_BUSY\"));\n        }, QUEUE_TIMEOUT_MS),\n      };\n\n      this.queue.push(item);\n    });\n  }\n\n  removeFromQueue(item: QueueItem): void {\n    clearTimeout(item.timer);\n    item.abortCleanup?.();\n    const idx = this.queue.indexOf(item);\n    if (idx !== -1) this.queue.splice(idx, 1);\n  }\n\n  rejectAllQueued(reason: string): void {\n    const err = new Error(reason);\n    this.queue.forEach((item) => {\n      clearTimeout(item.timer);\n      item.abortCleanup?.();\n      item.reject(err);\n    });\n    this.queue = [];\n  }\n\n  drainQueue(releasedWorker?: CodexAppServerWorker): void {\n    if (\n      releasedWorker &&\n      this.queue.length > 0 &&\n      releasedWorker.isReady &&\n      releasedWorker.active &&\n      releasedWorker.tryAcquireTurn()\n    ) {\n      const next = this.queue.shift()!;\n      next.resolve(releasedWorker);\n      return;\n    }\n\n    while (this.queue.length > 0) {\n      const worker = this.acquireIdleWorker();\n      if (!worker) break;\n      const next = this.queue.shift()!;\n      next.resolve(worker);\n    }\n  }\n\n  // ── Execution ───────────────────────────────────────────────────\n\n  async executeAndRelease<T>(\n    worker: CodexAppServerWorker,\n    execute: (worker: CodexAppServerWorker) => Promise<T>,\n  ): Promise<T> {\n    try {\n      return await execute(worker);\n    } finally {\n      worker.releaseTurn();\n      this.drainQueue(worker);\n    }\n  }\n\n  // reuseThreadId 가 있으면 기존 thread 에 delta(reuseInput)만, 없으면 새 thread 에 전체\n  // prompt(coldInput) + history inject. reuse 가 dispatcher 단에서 폴백되면 후자로 떨어진다.\n  private buildTurnRequest(req: GenerateRequest, reuseThreadId?: string): TurnRequest {\n    const reusing = reuseThreadId !== undefined;\n    return {\n      input: reusing && req.reuseInput ? req.reuseInput : req.coldInput,\n      history: reusing ? undefined : req.coldHistory,\n      developerInstructions: req.systemPrompt,\n      outputSchema: req.outputSchema,\n      effort: req.effort ?? DEFAULT_EFFORT,\n      model: req.model,\n      verbosity: req.verbosity,\n      reasoningSummary: req.reasoningSummary,\n      serviceTier: req.serviceTier,\n    };\n  }\n\n  async executeTurn(\n    worker: CodexAppServerWorker,\n    req: GenerateRequest,\n    reuseThreadId?: string,\n  ): Promise<GenerateResult> {\n    const turnReq = this.buildTurnRequest(req, reuseThreadId);\n    const result = await worker.executeTurn(turnReq, reuseThreadId);\n    return {\n      text: result.text,\n      tokenName: worker.tokenName,\n      usage: result.usage,\n      durationMs: result.durationMs,\n      model: result.model,\n      threadCoord: {\n        workerId: makeWorkerId(worker.tokenId, worker.workerIndex),\n        threadId: result.threadId,\n        epoch: worker.epoch,\n      },\n    };\n  }\n\n  async executeStreamTurn(\n    worker: CodexAppServerWorker,\n    req: GenerateRequest,\n    cb: GenerateStreamCallbacks,\n    reuseThreadId?: string,\n  ): Promise<void> {\n    const turnReq = this.buildTurnRequest(req, reuseThreadId);\n    // worker 의 TurnResult 에 tokenName/threadCoord 를 붙여 상위(GenerateResult)로 올린다.\n    // threadId 는 새 thread 면 onThreadId 로 확정되므로 미리 보관해 두고 onComplete 때 읽는다.\n    let resolvedThreadId = reuseThreadId ?? \"\";\n    const wrappedCb: StreamCallbacks = {\n      ...cb,\n      onThreadId: (threadId) => {\n        resolvedThreadId = threadId;\n        cb.onThreadId?.(threadId);\n      },\n      onComplete: (result) => {\n        cb.onComplete({\n          ...result,\n          tokenName: worker.tokenName,\n          threadCoord: {\n            workerId: makeWorkerId(worker.tokenId, worker.workerIndex),\n            threadId: resolvedThreadId,\n            epoch: worker.epoch,\n          },\n        });\n      },\n    };\n    await worker.executeTurnStream(turnReq, wrappedCb, reuseThreadId);\n  }\n\n  // ── Spawn ───────────────────────────────────────────────────────\n\n  async spawnWorkers(\n    tokenId: number,\n    tokenName: string,\n    credentials: OpenAICredentials,\n  ): Promise<void> {\n    const workers: CodexAppServerWorker[] = [];\n    for (let i = 0; i < WORKERS_PER_TOKEN; i++) {\n      if (i > 0) await sleep(SPAWN_INTERVAL_MS);\n      const worker = await this.spawnSingleWorker(tokenId, tokenName, credentials, i);\n      if (worker) workers.push(worker);\n    }\n    if (workers.length > 0) {\n      this.workerPool.set(tokenId, workers);\n      logger.info(`${workers.length}/${WORKERS_PER_TOKEN} workers spawned for ${tokenName}`);\n    }\n  }\n\n  async spawnSingleWorker(\n    tokenId: number,\n    tokenName: string,\n    credentials: OpenAICredentials,\n    workerIndex: number,\n  ): Promise<CodexAppServerWorker | null> {\n    const worker = new CodexAppServerWorker({\n      tokenId,\n      tokenName,\n      accessToken: credentials.accessToken,\n      accountId: credentials.accountId,\n      planType: credentials.planType,\n      workerIndex,\n    });\n\n    worker.onReady = () => this.drainQueue();\n\n    worker.setServerRequestHandler(async (method) => {\n      if (method === \"account/chatgptAuthTokens/refresh\") {\n        return handleChatgptAuthTokensRefresh(tokenId);\n      }\n      throw new Error(`unhandled server-request: ${method}`);\n    });\n\n    try {\n      await worker.initialize();\n      logger.info(`worker spawned: ${tokenName}[${workerIndex}] (id=${tokenId + 1})`);\n      return worker;\n    } catch (e) {\n      logger.warn(`worker spawn failed: ${tokenName}[${workerIndex}]: ${(e as Error).message}`);\n      await worker.kill().catch(() => {});\n      return null;\n    }\n  }\n\n  // ── Rate limits ─────────────────────────────────────────────────\n\n  rateLimitsCache = new Map<string, { data: unknown; cachedAt: number }>();\n  static readonly RATE_LIMITS_CACHE_TTL = 60_000;\n\n  async getRateLimits(tokenName?: string): Promise<unknown> {\n    const cacheKey = tokenName ?? \"_default\";\n    const cached = this.rateLimitsCache.get(cacheKey);\n    if (cached && Date.now() - cached.cachedAt < OpenAIDispatcher.RATE_LIMITS_CACHE_TTL) {\n      return cached.data;\n    }\n\n    const allWorkers = [...this.workerPool.values()].flat().filter((w) => w.isReady);\n    const worker = tokenName ? allWorkers.find((w) => w.tokenName === tokenName) : allWorkers[0];\n    if (!worker) throw new Error(\"no ready openai workers\");\n    const data = await worker.getRateLimits();\n    this.rateLimitsCache.set(cacheKey, { data, cachedAt: Date.now() });\n    return data;\n  }\n\n  // ── Browser login flow ───────────────────────────────────────────\n\n  pendingLogin: {\n    worker: CodexAppServerWorker;\n    name: string;\n    timer: ReturnType<typeof setTimeout>;\n  } | null = null;\n\n  async startBrowserLogin(name: string): Promise<{ authUrl: string }> {\n    if (this.pendingLogin) {\n      this.pendingLogin.worker.kill().catch(() => {});\n      clearTimeout(this.pendingLogin.timer);\n      this.pendingLogin = null;\n    }\n\n    const tempId = Date.now();\n    const worker = new CodexAppServerWorker({\n      tokenId: tempId,\n      tokenName: name,\n      accessToken: \"\",\n      accountId: \"\",\n    });\n\n    const authUrl = await worker.startBrowserLogin();\n\n    const timer = setTimeout(() => {\n      if (this.pendingLogin?.worker === worker) {\n        logger.warn(`browser login timeout for ${name}, killing worker`);\n        worker.kill().catch(() => {});\n        this.pendingLogin = null;\n      }\n    }, 300_000);\n\n    this.pendingLogin = { worker, name, timer };\n    return { authUrl };\n  }\n\n  get pendingLoginName(): string | null {\n    return this.pendingLogin?.name ?? null;\n  }\n\n  async completeBrowserLogin(): Promise<{\n    accessToken: string;\n    refreshToken: string;\n    idToken?: string;\n    accountId: string;\n  }> {\n    if (!this.pendingLogin) throw new Error(\"no pending login\");\n    const { worker, timer } = this.pendingLogin;\n\n    try {\n      await worker.waitForBrowserLoginComplete();\n      const creds = await worker.readManagedCredentials();\n      if (!creds) throw new Error(\"failed to read credentials after login\");\n      return creds;\n    } finally {\n      clearTimeout(timer);\n      this.pendingLogin = null;\n      await worker.kill().catch(() => {});\n    }\n  }\n\n  // ── Stats ───────────────────────────────────────────────────────\n\n  get workerCount(): number {\n    return [...this.workerPool.values()].flat().length;\n  }\n\n  get readyWorkerCount(): number {\n    return [...this.workerPool.values()].flat().filter((w) => w.isReady).length;\n  }\n\n  get queueLength(): number {\n    return this.queue.length;\n  }\n}\n"],"mappings":"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"}

package/bundle/src/application/qgrid/conv-routing.ts

@@ -0,0 +1,97 @@
+/**
+ * conv-routing — conversation(=codex thread) 재사용을 위한 thread 좌표 검증/구성.
+ *
+ * 목표: thread(=conversation_id=prompt_cache_key)를 재사용해 OpenAI prompt caching 적중.
+ * - 후속 turn: 기존 thread 에 delta(마지막 user / tool 결과)만 보냄 (history inject 없음).
+ * - 첫 turn / 검증 실패: 새 thread + history inject (폴백, 정확성 보존).
+ *
+ * 식별: 서버 발급 불투명 thread 좌표(QgridThreadCoord)를 클라가 그대로 회송.
+ * 검증: systemHash(다른 대화 오접속 차단) + (dispatcher의) epoch/worker 생존.
+ */
+import { createHash } from "node:crypto";
+
+import { type JsonValue } from "../../codex-protocol/serde_json/JsonValue";
+import { type UserInput } from "../../codex-protocol/v2/UserInput";
+import { type ReuseThreadCoord } from "../../utils/providers/common/provider-dispatcher";
+import { type QgridThreadCoord, type QueryInput, type QgridToolResultInput } from "./qgrid.types";
+
+export function systemHash(system?: string): string {
+  return createHash("sha256")
+    .update(system ?? "")
+    .digest("hex")
+    .slice(0, 16);
+}
+
+// tool 결과를 다음 turn 의 input text 로 변환 (codex turn/start.input 은 UserInput 만 받음).
+function toolResultsToText(toolResults: QgridToolResultInput[]): string {
+  const lines = toolResults.map((tr) => {
+    const name = tr.toolName ? ` (${tr.toolName})` : "";
+    const errMark = tr.isError ? " [error]" : "";
+    return `Tool result for call ${tr.toolCallId}${name}${errMark}: ${tr.output}`;
+  });
+  return `${lines.join("\n")}\n\nNow continue answering the user's request using these results.`;
+}
+
+export interface ConvDecision {
+  // dispatcher 로 넘길 reuse 좌표 (검증 통과 시에만). dispatcher 가 epoch/worker 생존 재검증 후 폴백 가능.
+  reuse?: ReuseThreadCoord;
+  // 재사용 성공 시 turn/start 에 보낼 input — delta(마지막 user/tool 결과)만. reuse 가 있을 때만 설정.
+  reuseInput?: Array<UserInput>;
+  // 첫 turn / 재사용 폴백 시 보낼 input — 전체 prompt. 항상 설정(폴백 안전망).
+  coldInput: Array<UserInput>;
+  // 새 thread 일 때 inject 할 전체 history. 재사용 성공 시엔 dispatcher 가 안 쓴다(thread 가 이미 누적).
+  coldHistory?: Array<JsonValue>;
+  // 이 요청 시점의 system 해시 (응답에서 thread 좌표 발급 시 사용).
+  systemHash: string;
+}
+
+// thread 좌표 + 들어온 요청으로 "재사용 가능한가"를 판정하고, reuse/cold 양쪽 payload 를 구성한다.
+// dispatcher 단의 epoch/worker 생존 검증은 여기서 못 하므로(상태 없음) reuse 좌표 + 두 payload 를
+// 모두 넘기고, dispatcher 의 acquireReuseWorker 결과에 따라 reuse(delta) 또는 cold(전체) 를 고른다.
+// 양쪽을 다 들고 가야 reuse 가 실패로 폴백돼도 전체 history 로 문맥을 복구할 수 있다.
+export function decideConvRouting(input: QueryInput): ConvDecision {
+  const sysHash = systemHash(input.system);
+  const history: Array<JsonValue> | undefined = input.history
+    ? (JSON.parse(input.history) as Array<JsonValue>)
+    : undefined;
+
+  const coord = input.runContext?.threadCoord;
+
+  // 재사용 자격: 좌표 존재 + system 동일. sessionKey 격리 + systemHash 로 대화 동일성이
+  // 보장되고, 공통 prefix 는 codex 가 prompt_cache_key 고정으로 알아서 캐시한다.
+  const eligible = coord !== undefined && coord.systemHash === sysHash;
+
+  return {
+    reuse:
+      eligible && coord
+        ? { workerId: coord.workerId, threadId: coord.threadId, epoch: coord.epoch }
+        : undefined,
+    // 재사용 turn 은 delta(마지막 user/tool 결과)만 — thread 가 이미 이전 turn 들을 누적.
+    reuseInput: eligible ? buildDeltaInput(input) : undefined,
+    // 첫 turn / 폴백: 전체 prompt + history inject.
+    coldInput: [{ type: "text", text: input.prompt, text_elements: [] }],
+    coldHistory: history,
+    systemHash: sysHash,
+  };
+}
+
+// 후속 turn 의 input: tool 결과가 있으면 그걸 text 로, 없으면 마지막 user(prompt).
+function buildDeltaInput(input: QueryInput): Array<UserInput> {
+  if (input.toolResults && input.toolResults.length > 0) {
+    return [{ type: "text", text: toolResultsToText(input.toolResults), text_elements: [] }];
+  }
+  return [{ type: "text", text: input.prompt, text_elements: [] }];
+}
+
+// 응답 threadCoord + 요청 시점 정보로 다음 thread 좌표를 발급한다.
+export function issueConvContext(
+  threadCoord: ReuseThreadCoord,
+  decision: ConvDecision,
+): QgridThreadCoord {
+  return {
+    workerId: threadCoord.workerId,
+    threadId: threadCoord.threadId,
+    epoch: threadCoord.epoch,
+    systemHash: decision.systemHash,
+  };
+}

package/bundle/src/application/qgrid/qgrid-run-lifecycle.ts

@@ -48,7 +48,8 @@ export async function beforeQuery(args: QueryInput): Promise<{
   let requestLogId: number;
   let stepIndex = 0;
 
-  if (args.runContext) {
+  // requestLogId 가 있을 때만 기존 run 연장. threadCoord 만 있는 conv 는 새 run 으로 시작.
+  if (args.runContext?.requestLogId !== undefined) {
     requestLogId = args.runContext.requestLogId;
 
     if (args.toolResults && args.toolResults.length > 0) {

package/bundle/src/application/qgrid/qgrid.dispatcher.ts

@@ -26,6 +26,7 @@ import { calculateCostUsd } from "../../utils/providers/common/model-cost";
 import { strictify } from "../../utils/providers/common/strictifier";
 import { type OpenAIDispatcher } from "../../utils/providers/openai/openai-dispatcher";
 import { type TokenSubsetA } from "../sonamu.generated";
+import { decideConvRouting, issueConvContext } from "./conv-routing";
 import { type QueryInput, type QueryOutput, type TokenStats } from "./qgrid.types";
 import { maskToken, ProcessError, QuotaError, TimeoutError } from "./qgrid.types";
 import { type TokenSubscriber } from "./token-subscriber";
@@ -130,9 +131,9 @@ export class QgridDispatcherClass {
       assert(model, "unknown model");
       if (provider === "openai") {
         if (!this.openaiDispatcher) throw new QuotaError("OpenAI dispatcher not initialized");
+        const decision = decideConvRouting(input);
         const result = await this.openaiDispatcher.generate({
           model: model,
-          input: [{ type: "text" as const, text: input.prompt, text_elements: [] }],
           systemPrompt: input.system,
           outputSchema: outputSchema
             ? (strictify(outputSchema as Parameters<typeof strictify>[0]) as JsonValue)
@@ -141,9 +142,13 @@ export class QgridDispatcherClass {
           verbosity: input.verbosity,
           reasoningSummary: input.reasoningSummary,
           serviceTier: input.serviceTier,
-          history: input.history ? JSON.parse(input.history) : undefined,
+          coldInput: decision.coldInput,
+          coldHistory: decision.coldHistory,
+          reuse: decision.reuse,
+          reuseInput: decision.reuseInput,
         });
 
+        const issuedCoord = issueConvContext(result.threadCoord, decision);
         return applyToolCallEmulation(
           {
             text: result.text,
@@ -163,6 +168,7 @@ export class QgridDispatcherClass {
             }),
           },
           input.tools,
+          issuedCoord,
         );
       }
     }
@@ -230,10 +236,10 @@ export class QgridDispatcherClass {
         ? (JSON.parse(input.jsonSchema) as JsonValue)
         : undefined;
 
+    const decision = decideConvRouting(input);
     await this.openaiDispatcher.generateStream(
       {
         model,
-        input: [{ type: "text" as const, text: input.prompt, text_elements: [] }],
         systemPrompt: input.system,
         outputSchema: outputSchema
           ? (strictify(outputSchema as Parameters<typeof strictify>[0]) as JsonValue)
@@ -242,17 +248,21 @@ export class QgridDispatcherClass {
         verbosity: input.verbosity,
         reasoningSummary: input.reasoningSummary,
         serviceTier: input.serviceTier,
-        history: input.history ? JSON.parse(input.history) : undefined,
+        coldInput: decision.coldInput,
+        coldHistory: decision.coldHistory,
+        reuse: decision.reuse,
+        reuseInput: decision.reuseInput,
       },
       {
         onDelta: cb.onDelta,
         onThreadId: cb.onThreadId,
         onTurnId: cb.onTurnId,
         onComplete: (turnResult) => {
+          const issuedCoord = issueConvContext(turnResult.threadCoord, decision);
           const applied = applyToolCallEmulation(
             {
               text: turnResult.text,
-              tokenName: (turnResult as unknown as { tokenName?: string }).tokenName,
+              tokenName: turnResult.tokenName,
               model: turnResult.model,
               usage: {
                 input_tokens: turnResult.usage.inputTokens,
@@ -268,6 +278,7 @@ export class QgridDispatcherClass {
               }),
             },
             input.tools,
+            issuedCoord,
           );
           cb.onComplete(applied);
         },

package/bundle/src/application/qgrid/qgrid.frame.ts

@@ -37,6 +37,7 @@ import {
   type HealthResponse,
   type OAuthStartResult,
   type QueryOutput,
+  type QgridRunContext,
   StreamEvents,
   type TokenStats,
   type UsageResponse,
@@ -72,6 +73,14 @@ async function deleteOAuthState(state: string): Promise<void> {
   await cache.delete({ key: `${OAUTH_STATE_PREFIX}${state}` });
 }
 
+function getOAuthRedirectUri(): string {
+  const publicBaseUrl = process.env.QGRID_PUBLIC_BASE_URL?.replace(/\/+$/, "");
+  if (publicBaseUrl) return `${publicBaseUrl}/callback`;
+
+  const serverPort = process.env.PORT ?? "44900";
+  return `http://localhost:${serverPort}/callback`;
+}
+
 const logger = getLogger(["qgrid"]);
 const oauthLogger = getLogger(["qgrid", "oauth"]);
 
@@ -90,7 +99,11 @@ class QgridFrameClass extends BaseFrameClass {
       try {
         const result = await QgridDispatcher.query(args, args.timeout);
         const lifecycle = await afterQuery(requestLogId, stepIndex, args, result);
-        return { ...result, runContext: lifecycle.runContext };
+        // lifecycle.runContext(requestLogId) 와 dispatcher 가 실은 threadCoord 를 병합.
+        return {
+          ...result,
+          runContext: { ...lifecycle.runContext, threadCoord: result.runContext?.threadCoord },
+        };
       } catch (e) {
         await finishRunWithError(requestLogId, (e as Error).message, args);
         throw e;
@@ -214,7 +227,10 @@ class QgridFrameClass extends BaseFrameClass {
 
     // dispatcher 완료 후 lifecycle 처리 (await 안전)
     if (streamResult) {
-      let runContext: { requestLogId: number } | undefined;
+      // dispatcher 가 실은 thread 재사용 좌표 (auto/run 공통으로 클라에 회송해야 함).
+      const threadCoord = streamResult.runContext?.threadCoord;
+      let runContext: QgridRunContext | undefined =
+        threadCoord !== undefined ? { threadCoord } : undefined;
       if (runInfo) {
         try {
           const lifecycle = await afterQuery(
@@ -223,7 +239,7 @@ class QgridFrameClass extends BaseFrameClass {
             args,
             streamResult,
           );
-          runContext = lifecycle.runContext;
+          runContext = { ...lifecycle.runContext, threadCoord };
         } catch (e) {
           logger.error(`stream afterQuery failed: ${(e as Error).message}`);
         }
@@ -376,8 +392,7 @@ class QgridFrameClass extends BaseFrameClass {
   async oauthStart(name: string): Promise<OAuthStartResult> {
     const { codeVerifier, codeChallenge, state } = generatePKCE();
 
-    const serverPort = process.env.PORT ?? "44900";
-    const redirectUri = `http://localhost:${serverPort}/callback`;
+    const redirectUri = getOAuthRedirectUri();
     const authUrl = buildAuthUrl(codeChallenge, state, redirectUri);
 
     await setOAuthState(state, { codeVerifier, name, redirectUri });

package/bundle/src/application/qgrid/qgrid.types.ts

@@ -43,8 +43,21 @@ export type ServiceTier = z.infer<typeof ServiceTier>;
 export const QgridLogMode = z.enum(["auto", "run", "none"]);
 export type QgridLogMode = z.infer<typeof QgridLogMode>;
 
+// codex thread 좌표. thread 재사용으로 conversation_id(=prompt_cache_key)를 고정해
+// OpenAI prompt caching 을 살리기 위한 핸들. 서버가 발급하고 클라가 다음 요청에 그대로 회송한다.
+// 핸들 미전송 시 기존 "매 turn 새 thread + history inject" 동작으로 폴백(QgridRunContext 참조).
+export const QgridThreadCoord = z.object({
+  workerId: z.number(), // 고정 라우팅 (thread 는 worker 프로세스 메모리에만 존재)
+  threadId: z.string(), // codex conversation_id = prompt_cache_key
+  epoch: z.number(), // worker spawn 카운터. restart 로 thread 증발 감지
+  systemHash: z.string(), // system_prompt 해시. 다른 대화 오접속 방지
+});
+export type QgridThreadCoord = z.infer<typeof QgridThreadCoord>;
+
 export const QgridRunContext = z.object({
-  requestLogId: z.number(),
+  // run lifecycle(logMode="run") 에서만 발급. auto 모드(예: IF)는 threadCoord 만 왕복.
+  requestLogId: z.number().optional(),
+  threadCoord: QgridThreadCoord.optional(),
 });
 export type QgridRunContext = z.infer<typeof QgridRunContext>;