@cartanova/qgrid-cli 2.3.2 → 2.3.4

package/bundle/src/utils/providers/anthropic/stream-json-adapter.ts

@@ -1,27 +1,11 @@
 /**
- * stream-json 어댑터 — Anthropic(Claude) provider 의 입력/출력 변환.
+ * Claude CLI stream-json adapter.
  *
- * 이 모듈은 부활의 유일한 본질적 신규 코드다. 두 방향을 분리된 순수 함수로 둔다:
- *  - 입력: 서버 GenerateRequest payload(coldInput/coldHistory/reuseInput)
- *          → `claude -p --input-format stream-json` 의 JSONL 라인.
- *  - 출력: `claude -p --output-format stream-json --verbose` 의 JSONL 라인
- *          → qgrid 서버 delta(onDelta) + 최종 result. (U3, 같은 파일 하단)
+ * Input: qgrid history/input -> Claude JSONL stdin.
+ * Output: Claude JSONL stdout -> qgrid deltas + final result metadata.
  *
- * 중요한 계약:
- *  - 입력은 AI SDK LanguageModelV3Message[] 가 아니라 **서버측 GenerateRequest** 다.
- *    ai-sdk 가 이미 QueryInput.history(JsonValue[]) 로 변환했고, decideConvRouting 이
- *    coldInput/coldHistory/reuseInput 으로 만든 뒤 dispatcher 에 도달한다.
- *  - content 는 user/assistant 모두 block 배열 `[{type:"text",text}]` 로 정규화한다.
- *    문자열 content 는 일부 user 단발만 통과하고 history replay 에서 깨진다
- *    (`W is not an Object (evaluating '"tool_use_id" in W')`).
- *  - stream-json 의 user/assistant 는 비대칭이다: assistant 는 history context 로 push 되고
- *    **user 는 새 prompt 로 enqueue(=실행)된다.** 따라서 cold 경로에서 과거 대화(user/assistant/
- *    tool)를 그대로 줄로 늘어놓으면 과거 user/tool-output 이 실행 prompt 로 재실행된다. 이를 피하려
- *    cold history 는 **단일 assistant context 텍스트로 평탄화**하고, 실행 가능한 `type:"user"` 줄은
- *    **마지막 input 하나뿐**이 되도록 한다. full-fidelity role replay 가 필요하면 session resume
- *    (reuseInput) 또는 JSONL backstop 으로 간다.
- *  - tool 결과는 native Anthropic tool_result 블록을 새로 만들지 않고, 기존 OpenAI 와
- *    동일하게 평탄화된 text 로 처리한다(emulation 공통 계약).
+ * Previous conversation items are flattened into one assistant context line.
+ * The only executable user line is the current input.
  */
 
 import { type JsonValue } from "../../../codex-protocol/serde_json/JsonValue";
@@ -30,11 +14,7 @@ import { type ProviderTokenUsageBreakdown } from "../common/provider-dispatcher"
 
 // ── 입력 어댑터 ────────────────────────────────────────────────────
 
-// Claude stream-json 입력 한 줄(JSONL). content 는 항상 block 배열.
-//
-// SDK envelope 필드(uuid / session_id / parent_tool_use_id)는 **여기서 만들지 않는다**.
-// 그 값들은 세션을 발급/소유하는 claude-session 의 책임이다. 이 모듈은 role/content 변환만 하는
-// 순수 함수로 두고, claude-session 이 직렬화 직전에 envelope 를 decorate 한다. 책임 분리.
+// Claude stream-json 입력 한 줄(JSONL). Envelope fields are added in claude-session.
 export interface ClaudeStreamJsonLine {
   type: "user" | "assistant";
   message: {
@@ -43,7 +23,6 @@ export interface ClaudeStreamJsonLine {
   };
 }
 
-// UserInput[] 에서 text 만 뽑아 하나의 문자열로. (image/skill/mention 등은 현재 범위 밖 — text 위주)
 function userInputToText(input: Array<UserInput>): string {
   return input
     .filter((i): i is Extract<UserInput, { type: "text" }> => i.type === "text")
@@ -51,12 +30,11 @@ function userInputToText(input: Array<UserInput>): string {
     .join("\n");
 }
 
-// content 를 항상 block 배열로 정규화(문자열 content 는 history replay 에서 깨짐).
 function textBlock(text: string): Array<{ type: "text"; text: string }> {
   return [{ type: "text", text }];
 }
 
-// codex ResponseItem(coldHistory 의 한 항목) 형태 판별용 최소 shape.
+// codex ResponseItem(coldHistory item) 최소 shape.
 // extractPromptAndHistory(ai-sdk/utils.ts) 가 만드는 형식:
 //   { type:"message", role:"user", content:[{type:"input_text", text}] }
 //   { type:"message", role:"assistant", content:[{type:"output_text", text}] }
@@ -68,8 +46,6 @@ function asObject(v: JsonValue | undefined): ResponseItem | null {
   return typeof v === "object" && v !== null && !Array.isArray(v) ? (v as ResponseItem) : null;
 }
 
-// codex message content([{type:input_text|output_text, text}]) 에서 text 추출.
-// 여러 content 블록은 줄바꿈으로 구분(token-adjacent 붙음 방지).
 function responseItemText(item: ResponseItem): string {
   const content = item.content;
   if (!Array.isArray(content)) return "";
@@ -82,11 +58,6 @@ function responseItemText(item: ResponseItem): string {
     .join("\n");
 }
 
-/**
- * cold history(codex ResponseItem[])를 **단일 평탄 텍스트**로 변환한다.
- * user/assistant/tool 모두 라벨 붙은 한 덩어리로 — 실행되지 않는 assistant context 로 들어간다.
- * (cold 의 user/tool-output 을 type:"user" 로 내보내면 새 prompt 로 재실행되므로 금지.)
- */
 function flattenColdHistory(coldHistory: Array<JsonValue>): string {
   const parts: Array<string> = [];
   for (const raw of coldHistory) {
@@ -111,30 +82,13 @@ function flattenColdHistory(coldHistory: Array<JsonValue>): string {
   return parts.join("\n");
 }
 
-/**
- * 서버 GenerateRequest payload 를 Claude stream-json JSONL 라인 배열로 변환한다.
- *
- * @param opts.coldHistory  cold 경로의 codex ResponseItem 배열(JsonValue[]). resume 경로면 미사용.
- * @param opts.input        실행할 input — cold 면 coldInput, resume 면 reuseInput.
- * @param opts.isResume     resume 경로 여부. true 면 history 재주입 없이 input(delta)만.
- *
- * 출력 규칙:
- *  - 실행 가능한 `type:"user"` 줄은 **항상 정확히 1개** — 마지막 input.
- *  - resume: user(delta) 1줄만. thread 가 이전 turn 을 누적하므로 history 미포함.
- *  - cold: coldHistory 전체를 **단일 assistant context 텍스트**로 평탄화(실행 안 됨) + user(input) 1줄.
- *          user/assistant/tool 모두 평탄화되므로 과거 user/tool-output 이 재실행되지 않는다.
- *          full-fidelity role replay 가 필요하면 session resume 또는 JSONL backstop(범위 밖).
- *  - tool(function_call/output): native 블록 없이 평탄 텍스트로.
- */
 export function buildStreamJsonInput(opts: {
   coldHistory?: Array<JsonValue>;
   input: Array<UserInput>;
-  isResume: boolean;
 }): Array<ClaudeStreamJsonLine> {
   const lines: Array<ClaudeStreamJsonLine> = [];
 
-  // cold 경로: history 를 단일 assistant context 로 평탄화(실행 안 됨).
-  if (!opts.isResume && opts.coldHistory && opts.coldHistory.length > 0) {
+  if (opts.coldHistory && opts.coldHistory.length > 0) {
     const flattened = flattenColdHistory(opts.coldHistory);
     if (flattened) {
       lines.push({
@@ -147,7 +101,6 @@ export function buildStreamJsonInput(opts: {
     }
   }
 
-  // 실행할 input — resume/cold 공통, 항상 마지막의 단일 user 줄.
   lines.push({
     type: "user",
     message: { role: "user", content: textBlock(userInputToText(opts.input)) },
@@ -156,26 +109,14 @@ export function buildStreamJsonInput(opts: {
   return lines;
 }
 
-// JSONL 문자열(claude stdin 으로 흘릴 형태)로 직렬화.
 export function serializeStreamJsonInput(lines: Array<ClaudeStreamJsonLine>): string {
   return lines.map((l) => JSON.stringify(l)).join("\n") + "\n";
 }
 
 // ── 출력 어댑터 ────────────────────────────────────────────────────
 //
-// claude -p --output-format stream-json --verbose 의 stdout(JSONL)을
-// qgrid 서버 delta(onDelta) + 최종 result 로 변환한다.
-//
-// 계약:
-//  - 이 어댑터는 qgrid **서버** 계층이다. AI SDK stream part(text-delta 등)는
-//    packages/ai-sdk(client provider)가 만든다 — 여기서 만들지 않는다.
-//  - text_delta → onDelta(text). structured output 일 때 input_json_delta.partial_json
-//    조각도 onDelta(text) 로 흘린다(client provider 가 partialObjectStream 으로 누적).
-//  - 최종 result → structured_output(우선) 또는 result(폴백, 자연어 가능) + usage + 종료.
-//  - usage 는 input/cache_creation/cache_read/output 4 카테고리를 받아 TokenUsageBreakdown 으로.
-//    payload 크기 비교는 3 카테고리 합으로(과거 학습 — input 단독 비교 무의미).
-
-// claude stream-json 출력에서 우리가 보는 usage shape(부분). Anthropic 네이티브 필드.
+// Claude stdout(JSONL)을 qgrid deltas + final result 로 변환한다.
+
 interface ClaudeUsage {
   input_tokens?: number;
   output_tokens?: number;
@@ -183,7 +124,6 @@ interface ClaudeUsage {
   cache_read_input_tokens?: number;
 }
 
-// 최종 result 파싱 산출물. dispatcher(U1)가 GenerateResult 조립에 쓴다.
 export interface ClaudeStreamResult {
   text: string;
   usage: ProviderTokenUsageBreakdown;
@@ -193,6 +133,10 @@ export interface ClaudeStreamResult {
   quotaExhausted: boolean;
   // result.is_error / terminal model_error 등. dispatcher 가 에러로 변환.
   isError: boolean;
+  // 진단용: CC result 라인의 subtype("success" | "error_max_turns" | ...) 과 terminal_reason.
+  // isError 판정 사유를 에러 메시지에 드러내기 위해 보존한다(SON-495).
+  subtype?: string;
+  terminalReason?: string;
 }
 
 export interface ClaudeStreamJsonState {
@@ -220,8 +164,6 @@ function toUsageBreakdown(u: ClaudeUsage): ProviderTokenUsageBreakdown {
   };
 }
 
-// result.result 의 코드펜스(```json ... ```) 제거. structured_output 이 없을 때만 쓴다.
-// 앞뒤 공백/개행을 먼저 trim 해 `\n```json\n...\n```\n` 같은 형태도 깨끗이 제거.
 function stripCodeFence(s: string): string {
   return s
     .trim()
@@ -237,26 +179,18 @@ function structuredOutputToolUseText(j: ResponseItem): string | undefined {
   for (const raw of content) {
     const block = asObject(raw);
     if (!block) continue;
-    if (block.type === "tool_use" && block.name === "StructuredOutput" && block.input !== undefined) {
+    if (
+      block.type === "tool_use" &&
+      block.name === "StructuredOutput" &&
+      block.input !== undefined
+    ) {
       return JSON.stringify(block.input);
     }
   }
   return undefined;
 }
 
-/**
- * stream-json 출력 라인 하나를 처리한다. 순수 함수 — side effect 는 onDelta 콜백뿐.
- *
- * @param opts.structuredOutput  structured output(jsonSchema) 모드 여부.
- *   structured 모드에서 Claude 는 자연어 text_delta 와 input_json_delta.partial_json 을
- *   **함께** 흘릴 수 있다(PoC 확인). 이때 text_delta 를 그대로 onDelta 로 보내면 client 의
- *   streamObject 파서가 prose 를 JSON 앞에서 만나 깨진다. 그래서:
- *     - structured 모드: text_delta 무시, partial_json 만 onDelta.
- *     - text 모드: text_delta 만 onDelta (partial_json 은 안 옴).
- *
- * @returns result 이벤트면 ClaudeStreamResult, 그 외(delta/system 등)면 null.
- *          호출부는 라인 스트림을 돌며 이 함수를 호출하고, non-null 이 나오면 종료.
- */
+// Processes one Claude stdout JSONL line. Returns final result on result event.
 export function handleStreamJsonLine(
   line: string,
   onDelta: (text: string) => void,
@@ -271,23 +205,19 @@ export function handleStreamJsonLine(
   try {
     j = JSON.parse(trimmed) as { [key: string]: JsonValue | undefined };
   } catch {
-    // 깨진 JSON 라인은 graceful skip.
     return null;
   }
 
-  // 점진 delta: stream_event > content_block_delta > {text_delta | input_json_delta}.
   if (j.type === "stream_event") {
     const event = asObject(j.event);
     if (event && event.type === "content_block_delta") {
       const delta = asObject(event.delta);
       if (delta) {
         if (structuredOutput) {
-          // structured: JSON 조각만. 자연어 text_delta 는 버린다(streamObject 파서 보호).
           if (delta.type === "input_json_delta" && typeof delta.partial_json === "string") {
             onDelta(delta.partial_json);
           }
         } else {
-          // text: 자연어 delta 만.
           if (delta.type === "text_delta" && typeof delta.text === "string") {
             onDelta(delta.text);
           }
@@ -297,13 +227,17 @@ export function handleStreamJsonLine(
     return null;
   }
 
-  if (j.type === "assistant" && structuredOutput && state && state.structuredOutputText === undefined) {
+  if (
+    j.type === "assistant" &&
+    structuredOutput &&
+    state &&
+    state.structuredOutputText === undefined
+  ) {
     const text = structuredOutputToolUseText(j);
     if (text !== undefined) state.structuredOutputText = text;
     return null;
   }
 
-  // 최종 result.
   if (j.type === "result") {
     let text: string;
     const preservedStructuredOutput = structuredOutput ? state?.structuredOutputText : undefined;
@@ -317,18 +251,20 @@ export function handleStreamJsonLine(
 
     const usage = toUsageBreakdown((asObject(j.usage) ?? {}) as ClaudeUsage);
     const quotaExhausted = text.startsWith("You've hit");
-    // 에러 판정: is_error true, terminal model_error,
-    // 또는 subtype 이 있고 "success" 가 아니면(error_during_execution / error_max_turns /
-    // error_max_budget_usd / error_max_structured_output_retries 등) 에러로 본다.
     const subtype = typeof j.subtype === "string" ? j.subtype : undefined;
-    const structuredMaxTurnsCompleted =
-      preservedStructuredOutput !== undefined &&
-      (subtype === "error_max_turns" || j.terminal_reason === "max_turns");
+    const terminalReason = typeof j.terminal_reason === "string" ? j.terminal_reason : undefined;
+
+    // SON-495: 비정상 종료(error_max_structured_output_retries 등)는 정직하게 에러로 처리한다.
+    // CC structured output 은 constrained decoding 이 아니라 "tool input 생성 후 사후 AJV 검증"이라
+    // 모델이 가끔 placeholder($PARAMETER_NAME)·거부("just kidding")·필드 누락(advance) 같은 발작/
+    // 불완전 출력을 낸다. 이를 "거의 맞았으니 살리자"고 흘리면 클라이언트 검증에서 깨지거나(필드 누락)
+    // 쓰레기가 새어 나간다(실측 11674/11675). 알려진 best practice(refusal/degenerate output 은 살리지
+    // 말고 graceful error)대로, subtype != success 는 그대로 에러로 둔다. 클라이언트가 그 턴을 실패로
+    // 다루게 한다(스트림이라 자동 재시도 없음 — 시간 2배 방지).
     const isError =
-      !structuredMaxTurnsCompleted &&
-      (j.is_error === true ||
-        j.terminal_reason === "model_error" ||
-        (subtype !== undefined && subtype !== "success"));
+      j.is_error === true ||
+      j.terminal_reason === "model_error" ||
+      (subtype !== undefined && subtype !== "success");
 
     return {
       text,
@@ -337,6 +273,8 @@ export function handleStreamJsonLine(
       costUsd: typeof j.total_cost_usd === "number" ? j.total_cost_usd : 0,
       quotaExhausted,
       isError,
+      subtype,
+      terminalReason,
     };
   }
 

package/bundle/src/utils/providers/common/model-cost.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, it } from "vitest";
 
-import { calculateCostUsd } from "./model-cost";
+import { calculateCostUsd, getModelCosts } from "./model-cost";
 
 describe("calculateCostUsd", () => {
   it("Anthropic cache read/write 를 전체 입력에서 분리해 각각 단가를 적용한다", () => {
@@ -36,4 +36,22 @@ describe("calculateCostUsd", () => {
     expect(cost).toBeGreaterThan(0);
     expect(cost).toBeCloseTo(0.0027222, 10);
   });
+
+  it("[1m] suffix 는 cost lookup 에서 strip 하고 long-context 할증은 붙이지 않는다", () => {
+    const base = getModelCosts("claude-sonnet-4-6");
+    const suffixed = getModelCosts("claude-sonnet-4-6[1m]");
+    expect(suffixed).toBe(base);
+    expect(suffixed.longContext).toBeUndefined();
+
+    const usage = {
+      inputTokens: 250_000,
+      outputTokens: 1_000,
+      cachedInputTokens: 200_000,
+      cacheCreationInputTokens: 0,
+    };
+    expect(calculateCostUsd("claude-sonnet-4-6[1m]", usage)).toBeCloseTo(
+      calculateCostUsd("claude-sonnet-4-6", usage),
+      10,
+    );
+  });
 });

package/bundle/src/utils/providers/common/model-cost.ts

@@ -164,7 +164,8 @@ const ANTHROPIC_COSTS: Record<string, ModelCosts> = {
 const DEFAULT_COSTS: ModelCosts = { inputTokens: 3, outputTokens: 15, cachedInputTokens: 0.3 };
 
 export function getModelCosts(model: string): ModelCosts {
-  return OPENAI_COSTS[model] ?? ANTHROPIC_COSTS[model] ?? DEFAULT_COSTS;
+  const normalizedModel = model.replace(/\[1m\]$/i, "");
+  return OPENAI_COSTS[normalizedModel] ?? ANTHROPIC_COSTS[normalizedModel] ?? DEFAULT_COSTS;
 }
 
 export function calculateCostUsd(

package/bundle/src/utils/providers/common/provider-dispatcher.ts

@@ -57,16 +57,19 @@ export interface GenerateResult {
   threadCoord: ReuseThreadCoord;
 }
 
-// 상위(qgrid.dispatcher)로 가는 스트림 콜백. onComplete 는 non-stream 의 GenerateResult 와
-// 동일 shape(tokenName/threadCoord 포함)를 받아, 두 경로가 같은 일급 타입을 공유한다.
-export interface GenerateStreamCallbacks {
+// 스트림 콜백 컨테이너. 계층별로 onComplete payload 만 다르고, 스트림 이벤트 shape 는 동일하다.
+export interface StreamCallbacks<TComplete> {
   onDelta: (text: string) => void;
-  onComplete: (result: GenerateResult) => void;
+  onComplete: (result: TComplete) => void;
   onError: (error: Error) => void;
   onThreadId?: (threadId: string) => void;
   onTurnId?: (turnId: string) => void;
 }
 
+// 상위(qgrid.dispatcher)로 가는 스트림 콜백. onComplete 는 non-stream 의 GenerateResult 와
+// 동일 shape(tokenName/threadCoord 포함)를 받아, 두 경로가 같은 일급 타입을 공유한다.
+export type GenerateStreamCallbacks = StreamCallbacks<GenerateResult>;
+
 export interface ProviderDispatcher {
   generate(req: GenerateRequest): Promise<GenerateResult>;
   start(): Promise<void>;

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

@@ -9,6 +9,7 @@ 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 { type StreamCallbacks as CommonStreamCallbacks } from "../common/provider-dispatcher";
 import { CodexRpcClient } from "./codex-rpc";
 
 const logger = getLogger(["qgrid", "codex-worker"]);
@@ -46,13 +47,7 @@ export interface TurnResult {
   model: string;
 }
 
-export interface StreamCallbacks {
-  onDelta: (text: string) => void;
-  onComplete: (result: TurnResult) => void;
-  onError: (error: Error) => void;
-  onThreadId?: (threadId: string) => void;
-  onTurnId?: (turnId: string) => void;
-}
+export type StreamCallbacks = CommonStreamCallbacks<TurnResult>;
 
 type RefreshableWorkerCredentials = Pick<WorkerConfig, "accessToken" | "accountId" | "planType">;
 type ActiveTurnAbort = (error: Error) => void;
@@ -191,7 +186,6 @@ export class CodexAppServerWorker {
     await this.waitForLoginCompleted();
     this.ready = true;
     this.restartAttempts = 0;
-    logger.info(`worker ${this.config.tokenName} ready`);
   }
 
   async startBrowserLogin(): Promise<string> {

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

@@ -89,12 +89,16 @@ export class OpenAIDispatcher implements ProviderDispatcher {
 
   async onTokenRemoved(id: number): Promise<void> {
     const workers = this.workerPool.get(id) ?? [];
+    const tokenName = workers[0]?.tokenName;
     this.workerPool.delete(id);
     await Promise.allSettled(workers.map((w) => w.kill()));
     if (this.getAllReadyActiveWorkers().length === 0) {
       this.rejectAllQueued("NO_OPENAI_WORKERS");
     }
-    if (workers.length > 0) logger.info(`workers removed for token ${id}: ${workers.length}`);
+    if (workers.length > 0) {
+      const label = tokenName ?? `token ${id}`;
+      logger.info(`workers removed: ${label} (${workers.length})`);
+    }
   }
 
   async onTokenUpdated(id: number, name: string, credentials: OpenAICredentials): Promise<void> {
@@ -106,7 +110,7 @@ export class OpenAIDispatcher implements ProviderDispatcher {
 
     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})`);
+      logger.info(`workers updated in-place: ${name}`);
       this.drainQueue();
       return;
     }
@@ -117,21 +121,27 @@ export class OpenAIDispatcher implements ProviderDispatcher {
   }
 
   onTokenDeactivated(id: number): void {
-    (this.workerPool.get(id) ?? []).forEach((w) => {
+    const workers = this.workerPool.get(id) ?? [];
+    const tokenName = workers[0]?.tokenName;
+    workers.forEach((w) => {
       w.active = false;
     });
     if (this.getAllReadyActiveWorkers().length === 0) {
       this.rejectAllQueued("NO_ACTIVE_WORKERS");
     }
-    logger.info(`workers deactivated: token ${id}`);
+    const label = tokenName ?? `token ${id}`;
+    logger.info(`workers deactivated: ${label}`);
   }
 
   onTokenActivated(id: number): void {
-    (this.workerPool.get(id) ?? []).forEach((w) => {
+    const workers = this.workerPool.get(id) ?? [];
+    const tokenName = workers[0]?.tokenName;
+    workers.forEach((w) => {
       w.active = true;
     });
     this.drainQueue();
-    logger.info(`workers activated: token ${id}`);
+    const label = tokenName ?? `token ${id}`;
+    logger.info(`workers activated: ${label}`);
   }
 
   // ── Generate ────────────────────────────────────────────────────
@@ -403,10 +413,7 @@ export class OpenAIDispatcher implements ProviderDispatcher {
       const worker = await this.spawnSingleWorker(tokenId, tokenName, credentials, i);
       if (worker) workers.push(worker);
     }
-    if (workers.length > 0) {
-      this.workerPool.set(tokenId, workers);
-      logger.info(`${workers.length}/${WORKERS_PER_TOKEN} workers spawned for ${tokenName}`);
-    }
+    if (workers.length > 0) this.workerPool.set(tokenId, workers);
   }
 
   async spawnSingleWorker(
@@ -435,7 +442,7 @@ export class OpenAIDispatcher implements ProviderDispatcher {
 
     try {
       await worker.initialize();
-      logger.info(`worker spawned: ${tokenName}[${workerIndex}] (id=${tokenId + 1})`);
+      logger.info(`worker spawned: ${tokenName}[${workerIndex}]`);
       return worker;
     } catch (e) {
       logger.warn(`worker spawn failed: ${tokenName}[${workerIndex}]: ${(e as Error).message}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cartanova/qgrid-cli",
-  "version": "2.3.2",
+  "version": "2.3.4",
   "repository": {
     "type": "git",
     "url": "https://github.com/cartanova-ai/qgrid"