@cartanova/qgrid-cli 2.4.2 → 2.4.4

package/bundle/src/utils/providers/common/smooth-weighted-round-robin.ts

@@ -0,0 +1,48 @@
+export class SmoothWeightedRoundRobin {
+  private readonly weights = new Map<number, number>();
+  private readonly currentScores = new Map<number, number>();
+
+  setToken(tokenId: number, weight: number): void {
+    if (!Number.isInteger(weight) || weight < 1 || weight > 100) {
+      throw new RangeError("weight must be an integer between 1 and 100");
+    }
+    if (this.weights.get(tokenId) === weight) return;
+    this.weights.set(tokenId, weight);
+    this.resetScores();
+  }
+
+  removeToken(tokenId: number): void {
+    if (!this.weights.delete(tokenId)) return;
+    this.currentScores.delete(tokenId);
+    this.resetScores();
+  }
+
+  resetScores(): void {
+    this.currentScores.clear();
+  }
+
+  select(eligibleTokenIds: ReadonlySet<number>): number | null {
+    const candidates = [...eligibleTokenIds]
+      .filter((tokenId) => this.weights.has(tokenId))
+      .toSorted((a, b) => a - b);
+    if (candidates.length === 0) return null;
+
+    let selected = candidates[0]!;
+    let selectedScore = Number.NEGATIVE_INFINITY;
+    let totalWeight = 0;
+
+    for (const tokenId of candidates) {
+      const weight = this.weights.get(tokenId)!;
+      totalWeight += weight;
+      const score = (this.currentScores.get(tokenId) ?? 0) + weight;
+      this.currentScores.set(tokenId, score);
+      if (score > selectedScore) {
+        selected = tokenId;
+        selectedScore = score;
+      }
+    }
+
+    this.currentScores.set(selected, selectedScore - totalWeight);
+    return selected;
+  }
+}

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

@@ -1,6 +1,10 @@
+import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
 import { describe, expect, it, vi } from "vitest";
 
-import { CodexAppServerWorker, type StreamCallbacks } from "./codex-worker";
+import { CODEX_CONFIG_TOML, CodexAppServerWorker, type StreamCallbacks } from "./codex-worker";
 
 function createWorkerWithFakeRpc() {
   const worker = new CodexAppServerWorker({
@@ -349,6 +353,40 @@ describe("CodexAppServerWorker image generation capture", () => {
     expect(result.imageAttempted).toBe(true);
   });
 
+  it("removes generated image artifacts after a successful image turn", async () => {
+    const { worker } = createWorkerWithNotificationRpc(async (method, _params, handlers) => {
+      if (method === "thread/start") return { thread: { id: "t1" }, model: "gpt-test" };
+      if (method === "turn/start") {
+        handlers.get("item/completed")?.({
+          threadId: "t1",
+          item: imageItem("img-a", IMAGE_B64, "a red circle"),
+        } as never);
+        handlers.get("turn/completed")?.({
+          threadId: "t1",
+          turn: { status: "completed", durationMs: 100 },
+        } as never);
+        return { turn: { id: "turn-1" } };
+      }
+      throw new Error(`unexpected request: ${method}`);
+    });
+    const codexHome = mkdtempSync(join(tmpdir(), "qgrid-codex-worker-test-"));
+    const generatedImages = join(codexHome, "generated_images", "session");
+    mkdirSync(generatedImages, { recursive: true });
+    writeFileSync(join(generatedImages, "img-a.png"), "image");
+    (worker as unknown as { codexHome: string }).codexHome = codexHome;
+
+    try {
+      await worker.executeTurn({
+        input: [{ type: "text", text: "two images", text_elements: [] }],
+        imageGeneration: true,
+      });
+
+      expect(existsSync(join(codexHome, "generated_images"))).toBe(false);
+    } finally {
+      rmSync(codexHome, { recursive: true, force: true });
+    }
+  });
+
   it("treats status='generating' completed item with valid base64 as a finished image", async () => {
     const { worker } = createWorkerWithNotificationRpc(async (method, _params, handlers) => {
       if (method === "thread/start") return { thread: { id: "t1" }, model: "gpt-test" };
@@ -488,6 +526,37 @@ describe("CodexAppServerWorker image generation capture", () => {
   });
 });
 
+describe("CodexAppServerWorker CODEX_HOME artifacts", () => {
+  it("disables bundled system skills in the generated Codex config", () => {
+    expect(CODEX_CONFIG_TOML).toContain("[skills.bundled]");
+    expect(CODEX_CONFIG_TOML).toContain("enabled = false");
+  });
+
+  it("removes the generated_images directory without touching other worker files", () => {
+    const worker = new CodexAppServerWorker({
+      tokenId: 1,
+      tokenName: "token",
+      accessToken: "access",
+      accountId: "account",
+    });
+    const codexHome = mkdtempSync(join(tmpdir(), "qgrid-codex-worker-test-"));
+    const generatedImages = join(codexHome, "generated_images", "session");
+    mkdirSync(generatedImages, { recursive: true });
+    writeFileSync(join(generatedImages, "img-a.png"), "image");
+    writeFileSync(join(codexHome, "state_5.sqlite"), "state");
+    (worker as unknown as { codexHome: string }).codexHome = codexHome;
+
+    try {
+      (worker as unknown as { cleanupGeneratedImages(): void }).cleanupGeneratedImages();
+
+      expect(existsSync(join(codexHome, "generated_images"))).toBe(false);
+      expect(existsSync(join(codexHome, "state_5.sqlite"))).toBe(true);
+    } finally {
+      rmSync(codexHome, { recursive: true, force: true });
+    }
+  });
+});
+
 describe("CodexAppServerWorker image generation thread", () => {
   type WorkerInternals = {
     createThread(req: unknown): Promise<{ threadId: string; model: string }>;

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

@@ -3,6 +3,11 @@ import { mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 
 import { getLogger } from "@logtape/logtape";
 
+import {
+  CODEX_IMAGE_GENERATION_MODEL,
+  resolveImageGenerationOptions,
+} from "../../../application/qgrid/qgrid-image-generation";
+import { type ImageGenerationOptions } from "../../../application/qgrid/qgrid.types";
 import { type Model } from "../../../codex-protocol/v2/Model";
 import { type ModelListResponse } from "../../../codex-protocol/v2/ModelListResponse";
 import { type ModelProviderCapabilitiesReadResponse } from "../../../codex-protocol/v2/ModelProviderCapabilitiesReadResponse";
@@ -12,11 +17,6 @@ import { type ThreadStartResponse } from "../../../codex-protocol/v2/ThreadStart
 import { type TokenUsageBreakdown } from "../../../codex-protocol/v2/TokenUsageBreakdown";
 import { type TurnStartParams } from "../../../codex-protocol/v2/TurnStartParams";
 import { type TurnStartResponse } from "../../../codex-protocol/v2/TurnStartResponse";
-import {
-  CODEX_IMAGE_GENERATION_MODEL,
-  resolveImageGenerationOptions,
-} from "../../../application/qgrid/qgrid-image-generation";
-import { type ImageGenerationOptions } from "../../../application/qgrid/qgrid.types";
 import { type StreamCallbacks as CommonStreamCallbacks } from "../common/provider-dispatcher";
 import { createTtftTracker } from "../common/ttft";
 import { CodexRpcClient } from "./codex-rpc";
@@ -115,7 +115,7 @@ function isCompletedImageResult(result: unknown): result is string {
 // instruction 블록(permissions/environment_context/skills, ~10KB)을 비활성화
 // $CODEX_HOME/config.toml 로 써넣으면 codex 부팅 시 scan
 // 통제불가: update_plan/request_user_input
-const CODEX_CONFIG_TOML = `web_search = "disabled"
+export const CODEX_CONFIG_TOML = `web_search = "disabled"
 include_permissions_instructions = false
 include_apps_instructions = false
 include_environment_context = false
@@ -134,6 +134,9 @@ view_image = false
 
 [skills]
 include_instructions = false
+
+[skills.bundled]
+enabled = false
 `;
 
 // ── Worker ──────────────────────────────────────────────────────────
@@ -179,6 +182,7 @@ export class CodexAppServerWorker {
     this.cachedCapabilities = undefined;
     this.cachedModels = undefined;
     const cwd = `${this.codexHome}/cwd`;
+    rmSync(this.codexHome, { recursive: true, force: true });
     mkdirSync(cwd, { recursive: true });
     // codex 내장 tool/web_search/instruction 블록 비활성화
     writeFileSync(`${this.codexHome}/config.toml`, CODEX_CONFIG_TOML);
@@ -583,6 +587,12 @@ export class CodexAppServerWorker {
     abort?.(error);
   }
 
+  private cleanupGeneratedImages(): void {
+    try {
+      rmSync(`${this.codexHome}/generated_images`, { recursive: true, force: true });
+    } catch {}
+  }
+
   private consumeTurnNotifications(
     threadId: string,
     model: string,
@@ -633,6 +643,7 @@ export class CodexAppServerWorker {
         if (settled) return;
         settled = true;
         cleanup();
+        if (result.imageAttempted) this.cleanupGeneratedImages();
         resolve(result);
       };
 
@@ -751,6 +762,7 @@ export class CodexAppServerWorker {
         if (settled) return;
         settled = true;
         cleanup();
+        if (result.imageAttempted) this.cleanupGeneratedImages();
         cb.onComplete(result);
         resolve();
       };

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

@@ -112,6 +112,9 @@ function fakeWorker(
     get isReady() {
       return options.ready ?? true;
     },
+    get hasCapacity() {
+      return !busy;
+    },
     tryAcquireTurn: vi.fn(() => {
       if (busy) return false;
       busy = true;
@@ -195,7 +198,7 @@ describe("OpenAIDispatcher token updates", () => {
     await dispatcher.onTokenUpdated(1, "token", changedIdentity, null);
 
     expect(worker.kill).toHaveBeenCalledTimes(1);
-    expect(spawnWorkers).toHaveBeenCalledWith(1, "token", changedIdentity, null);
+    expect(spawnWorkers).toHaveBeenCalledWith(1, "token", changedIdentity, null, 1);
   });
 
   it("uses tokenId keyed rate-limit cache", async () => {
@@ -227,7 +230,7 @@ describe("OpenAIDispatcher token updates", () => {
     addWorkers(dispatcher, [workerA, workerB]);
 
     await dispatcher.replaceTokens([
-      { id: 1, name: "tok-A", credentials: credentials(), quotaThreshold: 80 },
+      { id: 1, name: "tok-A", credentials: credentials(), quotaThreshold: 80, weight: 1 },
     ]);
     readOpenAIQuotaUsageMock.mockResolvedValueOnce(quotaOk(85));
 
@@ -238,6 +241,106 @@ describe("OpenAIDispatcher token updates", () => {
   });
 });
 
+describe("OpenAIDispatcher weighted routing", () => {
+  it("routes cold OpenAI requests by token weight instead of worker count", async () => {
+    const dispatcher = new OpenAIDispatcher();
+    const a0 = fakeWorker({ tokenId: 1, tokenName: "tok-A", workerIndex: 0 });
+    const a1 = fakeWorker({ tokenId: 1, tokenName: "tok-A", workerIndex: 1 });
+    const b0 = fakeWorker({ tokenId: 2, tokenName: "tok-B", workerIndex: 0 });
+    addWorkers(dispatcher, [a0, a1, b0]);
+    await dispatcher.onTokenUpdated(1, "tok-A", credentials(), null, 3);
+    await dispatcher.onTokenUpdated(2, "tok-B", credentials(), null, 1);
+
+    const names: string[] = [];
+    for (let i = 0; i < 4; i++) {
+      const worker = await dispatcher.acquireIdleWorker();
+      names.push(worker!.tokenName);
+      worker!.releaseTurn();
+    }
+
+    expect(names.filter((name) => name === "tok-A")).toHaveLength(3);
+    expect(names.filter((name) => name === "tok-B")).toHaveLength(1);
+  });
+
+  it("does not give a token extra cold turns for having more workers", async () => {
+    const dispatcher = new OpenAIDispatcher();
+    addWorkers(dispatcher, [
+      fakeWorker({ tokenId: 1, tokenName: "tok-A", workerIndex: 0 }),
+      fakeWorker({ tokenId: 1, tokenName: "tok-A", workerIndex: 1 }),
+      fakeWorker({ tokenId: 2, tokenName: "tok-B", workerIndex: 0 }),
+    ]);
+    await dispatcher.onTokenUpdated(1, "tok-A", credentials(), null, 1);
+    await dispatcher.onTokenUpdated(2, "tok-B", credentials(), null, 1);
+
+    const names: string[] = [];
+    for (let i = 0; i < 4; i++) {
+      const worker = await dispatcher.acquireIdleWorker();
+      names.push(worker!.tokenName);
+      worker!.releaseTurn();
+    }
+
+    expect(names).toEqual(["tok-A", "tok-B", "tok-A", "tok-B"]);
+  });
+
+  it("skips a high-weight token when all of its workers are busy", async () => {
+    const dispatcher = new OpenAIDispatcher();
+    addWorkers(dispatcher, [
+      fakeWorker({ tokenId: 1, tokenName: "tok-A", busy: true }),
+      fakeWorker({ tokenId: 2, tokenName: "tok-B" }),
+    ]);
+    await dispatcher.onTokenUpdated(1, "tok-A", credentials(), null, 100);
+    await dispatcher.onTokenUpdated(2, "tok-B", credentials(), null, 1);
+
+    await expect(dispatcher.acquireIdleWorker()).resolves.toMatchObject({ tokenName: "tok-B" });
+  });
+
+  it("uses weighted selection when draining after a worker release", async () => {
+    const dispatcher = new OpenAIDispatcher();
+    const workerA = fakeWorker({ tokenId: 1, tokenName: "tok-A", busy: true });
+    const workerB = fakeWorker({ tokenId: 2, tokenName: "tok-B", busy: true });
+    addWorkers(dispatcher, [workerA, workerB]);
+    await dispatcher.onTokenUpdated(1, "tok-A", credentials(), null, 1);
+    await dispatcher.onTokenUpdated(2, "tok-B", credentials(), null, 3);
+
+    const queued = dispatcher.enqueue(async (worker) => worker.tokenName);
+    await waitForQueue(dispatcher);
+    workerA.releaseTurn();
+    workerB.releaseTurn();
+
+    await dispatcher.drainQueue();
+    await expect(queued).resolves.toBe("tok-B");
+  });
+
+  it("does not advance weighted state for successful thread reuse", async () => {
+    const dispatcher = new OpenAIDispatcher();
+    const workerA = fakeWorker({ tokenId: 1, tokenName: "tok-A" });
+    const workerB = fakeWorker({
+      tokenId: 2,
+      tokenName: "tok-B",
+      threads: ["thread-B"],
+    });
+    addWorkers(dispatcher, [workerA, workerB]);
+    await dispatcher.onTokenUpdated(1, "tok-A", credentials(), null, 1);
+    await dispatcher.onTokenUpdated(2, "tok-B", credentials(), null, 1);
+    vi.spyOn(dispatcher, "executeTurn").mockImplementation(
+      async (worker, _req, reuseThreadId) =>
+        resultFor(worker, reuseThreadId ?? "thread-new"),
+    );
+
+    const cold1 = await dispatcher.generate(baseReq());
+    const reused = await dispatcher.generate(
+      baseReq({ reuse: { workerId: 20, threadId: "thread-B", epoch: 1 } }),
+    );
+    const cold2 = await dispatcher.generate(baseReq());
+
+    expect([cold1.tokenName, cold2.tokenName]).toEqual(["tok-A", "tok-B"]);
+    expect(reused).toMatchObject({
+      tokenName: "tok-B",
+      threadCoord: { threadId: "thread-B" },
+    });
+  });
+});
+
 describe("OpenAIDispatcher quota threshold gate", () => {
   it("excludes over-threshold tokenIds before idle selection", async () => {
     const dispatcher = new OpenAIDispatcher();
@@ -280,7 +383,7 @@ describe("OpenAIDispatcher quota threshold gate", () => {
     await waitForQueue(dispatcher);
 
     worker.releaseTurn();
-    await dispatcher.drainQueue(worker);
+    await dispatcher.drainQueue();
     await expect(queued).resolves.toBe("tok-A");
   });
 
@@ -310,11 +413,10 @@ describe("OpenAIDispatcher quota threshold gate", () => {
     await waitForQueue(dispatcher);
     readOpenAIQuotaUsageMock.mockReset();
     readOpenAIQuotaUsageMock
-      .mockResolvedValueOnce(quotaOk(90))
       .mockResolvedValueOnce(quotaOk(90))
       .mockResolvedValueOnce(quotaOk(10));
 
-    await dispatcher.drainQueue(workerA);
+    await dispatcher.drainQueue();
 
     await expect(queued).resolves.toBe("tok-B");
   });
@@ -323,11 +425,12 @@ describe("OpenAIDispatcher quota threshold gate", () => {
     const dispatcher = new OpenAIDispatcher();
     const worker = fakeWorker({ tokenId: 1, tokenName: "tok-A" });
     addWorkers(dispatcher, [worker]);
+    await dispatcher.onTokenUpdated(1, "tok-A", credentials(), null, 1);
     const execute = vi.fn(async (w: CodexAppServerWorker) => w.tokenName);
     const queued = dispatcher.enqueue(execute);
     await waitForQueue(dispatcher);
 
-    await Promise.all([dispatcher.drainQueue(worker), dispatcher.drainQueue(worker)]);
+    await Promise.all([dispatcher.drainQueue(), dispatcher.drainQueue()]);
 
     await expect(queued).resolves.toBe("tok-A");
     expect(execute).toHaveBeenCalledTimes(1);