@cartanova/qgrid-cli 2.10.1 → 2.10.3

package/bundle/src/application/qgrid/token-subscriber.test.ts

@@ -32,8 +32,7 @@ function subscriberWith(openaiDispatcher: Record<string, unknown>) {
   return new TokenSubscriber(
     {} as never,
     {
-      removeCache: vi.fn(),
-      upsertCache: vi.fn(),
+      tokens: new Map(),
       replaceCache: vi.fn(),
       openaiDispatcher,
       anthropicDispatcher: null,
@@ -82,8 +81,7 @@ describe("TokenSubscriber OpenAI notifications", () => {
     const subscriber = new TokenSubscriber(
       {} as never,
       {
-        removeCache: vi.fn(),
-        upsertCache: vi.fn(),
+        tokens: new Map(),
         replaceCache: vi.fn(),
         openaiDispatcher: null,
         anthropicDispatcher,
@@ -112,15 +110,13 @@ describe("TokenSubscriber OpenAI notifications", () => {
       {} as never,
       {
         tokens: new Map(),
-        removeCache: vi.fn(),
-        upsertCache: vi.fn(),
         replaceCache: vi.fn(),
         openaiDispatcher: null,
         anthropicDispatcher,
       } as never,
     );
     const onTokensChanged = vi.fn();
-    subscriber.setTokenChangeHandler(onTokensChanged);
+    subscriber.tokenChangeHandler = onTokensChanged;
     findOneMock.mockResolvedValueOnce({
       ...openaiToken(true),
       provider: "anthropic",
@@ -143,15 +139,13 @@ describe("TokenSubscriber OpenAI notifications", () => {
       {} as never,
       {
         tokens: new Map([[previous.id, previous]]),
-        removeCache: vi.fn(),
-        upsertCache: vi.fn(),
         replaceCache: vi.fn(),
         openaiDispatcher: null,
         anthropicDispatcher,
       } as never,
     );
     const onTokensChanged = vi.fn();
-    subscriber.setTokenChangeHandler(onTokensChanged);
+    subscriber.tokenChangeHandler = onTokensChanged;
     findOneMock.mockResolvedValueOnce({
       ...previous,
       credentials: { accessToken: "new", refreshToken: "refresh" },
@@ -173,15 +167,13 @@ describe("TokenSubscriber OpenAI notifications", () => {
       {} as never,
       {
         tokens: new Map([[previous.id, previous]]),
-        removeCache: vi.fn(),
-        upsertCache: vi.fn(),
         replaceCache: vi.fn(),
         openaiDispatcher: null,
         anthropicDispatcher: { onTokenRemoved: vi.fn() },
       } as never,
     );
     const onTokensChanged = vi.fn();
-    subscriber.setTokenChangeHandler(onTokensChanged);
+    subscriber.tokenChangeHandler = onTokensChanged;
     findOneMock.mockResolvedValueOnce({ ...previous, active: false });
 
     await subscriber.handleNotification(JSON.stringify({ op: "UPDATE", id: previous.id }));
@@ -198,8 +190,7 @@ describe("TokenSubscriber OpenAI notifications", () => {
     const subscriber = new TokenSubscriber(
       {} as never,
       {
-        removeCache: vi.fn(),
-        upsertCache: vi.fn(),
+        tokens: new Map(),
         replaceCache: vi.fn(),
         openaiDispatcher: null,
         anthropicDispatcher,
@@ -243,8 +234,7 @@ describe("TokenSubscriber OpenAI notifications", () => {
     const subscriber = new TokenSubscriber(
       {} as never,
       {
-        removeCache: vi.fn(),
-        upsertCache: vi.fn(),
+        tokens: new Map(),
         replaceCache: vi.fn(),
         openaiDispatcher,
         anthropicDispatcher,
@@ -290,7 +280,7 @@ describe("TokenSubscriber OpenAI notifications", () => {
     };
     const subscriber = new TokenSubscriber({} as never, dispatcher as never);
     const onTokensChanged = vi.fn();
-    subscriber.setTokenChangeHandler(onTokensChanged);
+    subscriber.tokenChangeHandler = onTokensChanged;
     findActiveMock
       .mockResolvedValueOnce([currentAnthropic])
       .mockResolvedValueOnce([

package/bundle/src/application/qgrid/token-subscriber.ts

@@ -25,19 +25,15 @@ export class TokenSubscriber {
   attempt = 0;
   connectedAt: Date | null = null;
   lastReconcileAt: Date | null = null;
-  private operationChain: Promise<void> = Promise.resolve();
-  private tokenChangeHandler: (() => void) | null = null;
+  operationChain: Promise<void> = Promise.resolve();
+  tokenChangeHandler: (() => void) | null = null;
 
   constructor(
     public connConfig: ClientConfig,
     public dispatcher: QgridDispatcherClass,
   ) {}
 
-  setTokenChangeHandler(handler: (() => void) | null): void {
-    this.tokenChangeHandler = handler;
-  }
-
-  private notifyTokensChanged(): void {
+  notifyTokensChanged(): void {
     try {
       this.tokenChangeHandler?.();
     } catch (error) {
@@ -168,18 +164,18 @@ export class TokenSubscriber {
     return this.enqueueOperation(() => this.handleNotificationNow(payloadJson));
   }
 
-  private async handleNotificationNow(payloadJson: string): Promise<void> {
+  async handleNotificationNow(payloadJson: string): Promise<void> {
     const payload = JSON.parse(payloadJson) as Payload;
     const previousRow = this.tokenChangeHandler
       ? this.dispatcher.tokens.get(payload.id)
       : undefined;
     const wasKeepaliveTarget = previousRow?.active === true && previousRow.provider === "anthropic";
     if (payload.op === "DELETE") {
-      this.dispatcher.removeCache(payload.id);
+      this.dispatcher.tokens.delete(payload.id);
       await this.dispatcher.openaiDispatcher
         ?.onTokenRemoved(payload.id)
         .catch((e) => logger.warn(`openai token remove failed: ${(e as Error).message}`));
-      // anthropic 토큰 이벤트는 동기(void) — provider 를 모르므로 무해하게 항상 제거 시도.
+      // 삭제된 토큰의 provider를 모를 수 있으므로 양쪽 풀에서 제거한다.
       this.dispatcher.anthropicDispatcher?.onTokenRemoved(payload.id);
       logger.info(`NOTIFY ${payload.op} id=${payload.id} → removed from cache`);
       if (previousRow === undefined || wasKeepaliveTarget) this.notifyTokensChanged();
@@ -187,7 +183,7 @@ export class TokenSubscriber {
     }
     const row = await TokenModel.findOne("A", { id: payload.id });
     if (!row) {
-      this.dispatcher.removeCache(payload.id);
+      this.dispatcher.tokens.delete(payload.id);
       await this.dispatcher.openaiDispatcher
         ?.onTokenRemoved(payload.id)
         .catch((e) => logger.warn(`openai token remove failed: ${(e as Error).message}`));
@@ -197,7 +193,7 @@ export class TokenSubscriber {
       return;
     }
 
-    this.dispatcher.upsertCache(payload.id, row);
+    this.dispatcher.tokens.set(payload.id, row);
 
     if (row.provider === "openai") {
       const creds = row.credentials as Record<string, unknown>;
@@ -229,9 +225,6 @@ export class TokenSubscriber {
         openaiDispatcher?.onTokenDeactivated(payload.id);
       }
     } else if (row.provider === "anthropic") {
-      // anthropic 토큰 이벤트는 동기(void). worker 가 없고 풀(Map)만 관리하므로 단순:
-      //  INSERT → 추가, active 면 갱신(onTokenUpdated 가 identity 변경도 처리), inactive 면 풀에서 제거.
-      //  (별도 activate/deactivate 콜백이 없어 active 토글을 add/remove 로 매핑.)
       const creds = row.credentials as AnthropicCredentials;
       if (payload.op === "INSERT" && row.active) {
         this.dispatcher.anthropicDispatcher?.onTokenAdded(
@@ -250,7 +243,6 @@ export class TokenSubscriber {
           row.weight,
         );
       } else {
-        // inactive 면 INSERT 든 UPDATE 든 풀에 넣지 않는다.
         this.dispatcher.anthropicDispatcher?.onTokenRemoved(payload.id);
       }
     }
@@ -263,7 +255,7 @@ export class TokenSubscriber {
     return this.enqueueOperation(() => this.reconcileNow());
   }
 
-  private async reconcileNow(): Promise<void> {
+  async reconcileNow(): Promise<void> {
     const previousAnthropicIds = this.tokenChangeHandler
       ? new Set(
           [...this.dispatcher.tokens.values()]
@@ -274,8 +266,6 @@ export class TokenSubscriber {
     await TokenModel.deactivateExpiredTokens();
     const rows = await TokenModel.findActive("A");
     this.dispatcher.replaceCache(rows);
-    // NOTIFY 유실 대비: AnthropicDispatcher 풀도 DB active anthropic 토큰 기준으로 재동기화.
-    // (rows 는 active 만 — inactive/삭제된 토큰은 여기 없으므로 replaceTokens 가 풀에서 제거한다.)
     const anthropicRows = rows
       .filter((r) => r.provider === "anthropic")
       .map((r) => ({
@@ -308,7 +298,7 @@ export class TokenSubscriber {
     }
   }
 
-  private enqueueOperation(operation: () => Promise<void>): Promise<void> {
+  enqueueOperation(operation: () => Promise<void>): Promise<void> {
     const next = this.operationChain.then(operation, operation);
     this.operationChain = next.catch(() => {});
     return next;

package/bundle/src/application/qgrid/token-window-keepalive.test.ts

@@ -1,7 +1,6 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 
 import {
-  KEEPALIVE_MODEL,
   KEEPALIVE_PROJECT_NAME,
   POST_KEEPALIVE_USAGE_DELAY_MS,
   rescheduleTokenWindowKeepalive,
@@ -76,7 +75,8 @@ describe("token window keepalive", () => {
 
     expect(dispatch).toHaveBeenCalledWith({
       prompt: "Reply OK.",
-      model: KEEPALIVE_MODEL,
+      model: "anthropic/claude-haiku-5-5",
+      thinking: false,
       effort: "low",
       projectName: KEEPALIVE_PROJECT_NAME,
       preferredTokenId: 1,

package/bundle/src/application/qgrid/token-window-keepalive.ts

@@ -15,7 +15,7 @@ const RESET_GRACE_MS = 1_000;
 // usage API 성공 응답은 1분 캐시된다. keepalive 직후 즉시 재조회하면 이전 윈도우를
 // 다시 보므로 캐시가 지난 뒤 한 번 확인하고, 그때도 새 윈도우가 없으면 다음 5h까지 기다린다.
 export const POST_KEEPALIVE_USAGE_DELAY_MS = 61_000;
-export const KEEPALIVE_MODEL = "anthropic/claude-haiku-4-5";
+export const KEEPALIVE_MODEL = "anthropic/claude-haiku-5-5";
 export const KEEPALIVE_PROJECT_NAME = "qgrid-token-window-keepalive";
 export const KEEPALIVE_SETTING_KEY = "qgrid.tokenWindowKeepaliveEnabled";
 export const KEEPALIVE_ENV_KEY = TOKEN_WINDOW_KEEPALIVE_RUNNER_ENV_KEY;
@@ -163,6 +163,7 @@ async function inspectToken(
     await deps.dispatch({
       prompt: "Reply OK.",
       model: KEEPALIVE_MODEL,
+      thinking: false,
       effort: "low",
       projectName: KEEPALIVE_PROJECT_NAME,
       preferredTokenId: token.id,

package/bundle/src/application/qgrid/tool-emulation-schema.test.ts

@@ -23,16 +23,16 @@ describe("buildToolCallSchema", () => {
     },
   ];
 
-  it("documents that emulated tools must be requested through StructuredOutput", () => {
+  it("requests tools in the response body and ends the turn until the client returns results", () => {
     const schema = buildToolCallSchema(tools);
 
     expect(schema).toHaveProperty(
       "description",
-      expect.stringContaining("Do not invoke listed client tools as native Claude Code tools"),
+      expect.stringContaining("then end your turn"),
     );
     expect(schema).toHaveProperty(
       ["properties", "result", "anyOf", 1, "description"],
-      expect.stringContaining("Do not call these tools as native"),
+      expect.stringContaining("wait for the next request containing tool results"),
     );
     expect(schema).toHaveProperty(
       [
@@ -49,6 +49,9 @@ describe("buildToolCallSchema", () => {
       ],
       expect.stringContaining("getWeather"),
     );
+    expect(JSON.stringify(schema)).not.toContain("StructuredOutput");
+    expect(JSON.stringify(schema)).not.toContain("Claude Code");
+    expect(schema).toHaveProperty("description", expect.stringContaining("Do not invent tool results"));
   });
 
   it("makes degenerate combinations grammatically impossible", () => {

package/bundle/src/application/qgrid/tool-emulation-schema.ts

@@ -54,7 +54,7 @@ export function buildToolCallSchema(tools: QgridTool[], answerSchema?: JsonValue
   return {
     type: "object",
     description:
-      "Use this schema only through StructuredOutput. Do not invoke listed client tools as native Claude Code tools. To request client-side tool execution, set result.action to tool_call and include result.toolCalls. Use action answer only when no further client tool result is needed.",
+      "Return exactly one JSON object matching this schema as your final response, including when requesting a tool. This object is the response body, not a call to a built-in tool. To request client-side tools, set result.action to tool_call and include result.toolCalls, then end your turn. The client executes those tools and supplies their results in a later request. Do not invent tool results or emit an answer before receiving the required results.",
     properties: {
       result: {
         anyOf: [
@@ -75,7 +75,7 @@ export function buildToolCallSchema(tools: QgridTool[], answerSchema?: JsonValue
           {
             type: "object",
             description:
-              "Request client-side tool execution through this structured output. Do not call these tools as native Claude Code tools.",
+              "Request client-side tool execution. Return this object as the complete response, then wait for the next request containing tool results.",
             properties: {
               action: { type: "string", enum: ["tool_call"] },
               answer: { type: "null" },
@@ -88,7 +88,7 @@ export function buildToolCallSchema(tools: QgridTool[], answerSchema?: JsonValue
                     toolName: {
                       type: "string",
                       enum: tools.map((tool) => tool.name),
-                      description: `Client-side tool name to request through structured output. Do not call this as a native Claude Code tool.\n${toolDescriptions}`,
+                      description: `Client-side tool name. The caller executes these tools after receiving your JSON response.\n${toolDescriptions}`,
                     },
                     args: {
                       type: "string",

package/bundle/src/application/qgrid/tool-emulation.test.ts

@@ -2,7 +2,7 @@ import { describe, expect, it } from "vitest";
 
 import { CALLER_SCHEMA_LIMITS } from "../../utils/providers/common/schema-validation";
 import { type QgridTool } from "./qgrid.types";
-import { applyToolCallEmulation, ToolCallEmulationError } from "./tool-emulation";
+import { applyToolCallEmulation, isToolCallEnvelope, ToolCallEmulationError } from "./tool-emulation";
 
 const baseResult = {
   text: "",
@@ -84,6 +84,13 @@ describe("applyToolCallEmulation image parts", () => {
 });
 
 describe("applyToolCallEmulation envelope validation", () => {
+  it("ignores intermediate prose but never repairs malformed final JSON or accepts an unknown control tool", () => {
+    const tool = JSON.stringify({result: {action: "tool_call", answer: null, toolCalls: [{toolName: "notAllowed", args: "{}"}]}});
+    const allowed = [{name: "lookup", inputSchema: {type: "object"}}];
+    expect(isToolCallEnvelope("Checking the source.", allowed, "json", "commentary")).toBe(false);
+    expect(() => isToolCallEnvelope(tool, allowed, "json", "commentary")).toThrow("unknown emulated tool");
+    expect(() => isToolCallEnvelope(tool + tool, allowed, "json", "final_answer")).toThrow("response is not JSON");
+  });
   const tools: QgridTool[] = [
     {
       name: "lookup",

package/bundle/src/application/qgrid/tool-emulation.ts

@@ -111,6 +111,35 @@ export function applyToolCallEmulation(
   );
 }
 
+export function isToolCallEnvelope(
+  text: string,
+  tools: QgridTool[],
+  answerKind: AnswerKind,
+  phase?: string,
+): boolean {
+  if (phase === "commentary") {
+    // Commentary is not the structured answer. Only an explicit tool control
+    // object is eligible, and that object must still pass the strict parser.
+    let value: unknown;
+    try {
+      value = JSON.parse(text);
+    } catch {
+      return false;
+    }
+    if (
+      !value ||
+      typeof value !== "object" ||
+      !("result" in value) ||
+      !value.result ||
+      typeof value.result !== "object" ||
+      !("action" in value.result) ||
+      value.result.action !== "tool_call"
+    )
+      return false;
+  }
+  return parseEnvelope(text, tools, answerKind).action === "tool_call";
+}
+
 function parseEnvelope(text: string, tools: QgridTool[], answerKind: AnswerKind) {
   if (Buffer.byteLength(text, "utf8") > STRUCTURED_ENVELOPE_LIMITS.maxUtf8Bytes) {
     throw new ToolCallEmulationError(

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

@@ -257,7 +257,7 @@ class RequestLogModelClass extends BaseModelClass<
    * 화면에서 필터를 걸면 행 수와 비용이 함께 좁혀져야 하는데, 두 쿼리가 각자 필터를
    * 구현하면 한쪽에 축을 추가할 때 조용히 어긋난다.
    */
-  private applyListFilters(
+  applyListFilters(
     qb: ReturnType<RequestLogModelClass["getSubsetQueries"]>["qb"],
     params: RequestLogListParams,
   ): void {
@@ -378,7 +378,7 @@ class RequestLogModelClass extends BaseModelClass<
       string,
       { requests: number; errors: number; inputTokens: number; cacheReadTokens: number }
     >();
-    for (const row of rows) {
+    rows.forEach((row) => {
       const model = row.requested_model_name ?? "";
       const provider = model.startsWith("openai/")
         ? "openai"
@@ -396,7 +396,7 @@ class RequestLogModelClass extends BaseModelClass<
       agg.inputTokens += row.input_tokens;
       agg.cacheReadTokens += row.cache_read_tokens;
       byProvider.set(provider, agg);
-    }
+    });
     return [...byProvider.entries()]
       .map(([provider, agg]) => ({ provider, ...agg }))
       .toSorted((a, b) => a.provider.localeCompare(b.provider));
@@ -584,9 +584,9 @@ class RequestLogModelClass extends BaseModelClass<
       "is_image_generation",
       "response_json_ok",
     ] as const;
-    for (const key of fields) {
+    fields.forEach((key) => {
       if (params[key] !== undefined) update[key] = params[key];
-    }
+    });
     if (params.history !== undefined) update.history = params.history;
     update.ttft_ms = (await this.firstGenerateStepTtft(requestLogId)) ?? 0;
 

package/bundle/src/application/setting/setting.model.ts

@@ -251,7 +251,7 @@ class SettingModelClass extends BaseModelClass<
     };
   }
 
-  private runtimeInfo(): RuntimeInfoItem[] {
+  runtimeInfo(): RuntimeInfoItem[] {
     const env = process.env;
     const password = env.QGRID_DB_PASSWORD ?? env.SONAMU_DB_PASSWORD ?? "";
     return [

package/bundle/src/sonamu.config.ts

@@ -195,14 +195,14 @@ export default defineConfig({
           log.warn(`anthropic dispatcher failed: ${(e as Error).message}`);
         }
 
-        subscriber.setTokenChangeHandler(() => {
+        subscriber.tokenChangeHandler = () => {
           void rescheduleTokenWindowKeepalive();
-        });
+        };
         startExpiredTokenReminder();
         void startTokenWindowKeepalive();
 
-        const anthropicCount = QgridDispatcher.anthropicDispatcher?.tokenCount ?? 0;
-        const openaiCount = QgridDispatcher.openaiDispatcher?.tokenCount ?? 0;
+        const anthropicCount = QgridDispatcher.anthropicDispatcher?.tokenPool.size ?? 0;
+        const openaiCount = QgridDispatcher.openaiDispatcher?.countActiveTokens() ?? 0;
 
         log.info(`listening on http://${host}:${port}`);
         log.info(`anthropic: ${anthropicCount} tokens ready`);
@@ -217,7 +217,7 @@ export default defineConfig({
         stopTokenWindowKeepalive();
         stopOpenAICallbackRelay();
         setSettingChangeHandler(null);
-        QgridDispatcher.subscriber?.setTokenChangeHandler(null);
+        if (QgridDispatcher.subscriber) QgridDispatcher.subscriber.tokenChangeHandler = null;
         if (QgridDispatcher.openaiDispatcher) {
           await QgridDispatcher.openaiDispatcher.stop();
         }

package/bundle/src/utils/providers/anthropic/anthropic-constants.ts

@@ -58,12 +58,9 @@ const ONE_MILLION_CONTEXT_MODELS = new Set([
 ]);
 
 const CLI_ONE_MILLION_SUFFIX_MODELS = new Set(["claude-sonnet-4-6", "claude-opus-4-6"]);
-// Fable 5/5.1, Opus 5.5, Sonnet 5.5, Haiku 5.5 는 thinking disabled 를 거부한다(Fable: CLI 카탈로그 `rejects_disabled_thinking`,
-// Opus 5.5: 공식 사양 "can't be turned off", 2026-09-22 출시. Sonnet 5.5: API `{type: "disabled"}` 400, CLI 카탈로그 `rejects_disabled_thinking`, 2026-09-28 출시.
-// Haiku 5.5: API 는 high 이하에서만 disabled 허용·xhigh/max 400, Claude Code 2.1.293 카탈로그는 `rejects_disabled_thinking`, 2026-10-07 출시). Opus 5 는
-// disabled 를 high 이하에서 지원하지만, 공식 기본값·권장 동작인 adaptive thinking 을 유지한다. qgrid
-// 기본 effort=low 가 비용/지연 제어를 맡으며, 이 정책은 disabled+xhigh/max 400 오류와 disabled 시
-// tool/XML 출력 오염도 피한다.
+// Preserve these defaults when thinking is omitted. This is not an off-capability list:
+// explicit false supports Opus 5, and native extra-body delivery supports Haiku 5.5
+// (disabled) and Sonnet 5.5 (between_tools). See anthropic-thinking.ts.
 const ADAPTIVE_THINKING_MODELS = new Set([
   "claude-fable-5-1",
   "claude-fable-5",

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

@@ -123,6 +123,32 @@ describe("AnthropicDispatcher", () => {
   it("토큰 없으면 에러", async () => {
     const d = new AnthropicDispatcher();
     await expect(d.generate(baseReq())).rejects.toThrow(/No anthropic tokens/);
+    expect(d.inFlight).toBe(0);
+  });
+
+  it.each([false, true])("releases the in-flight count after a session (fails=%s)", async (fails) => {
+    const d = new AnthropicDispatcher();
+    d.onTokenAdded(1, "tok-A", creds(), null, 1);
+    runClaudeSessionMock.mockImplementationOnce(async () => {
+      expect(d.inFlight).toBe(1);
+      if (fails) throw new Error("session failed");
+      return sessionResult();
+    });
+    if (fails) await expect(d.generate(baseReq())).rejects.toThrow("session failed");
+    else await expect(d.generate(baseReq())).resolves.toMatchObject({text: "hello"});
+    expect(d.inFlight).toBe(0);
+  });
+
+  it("rejects unsupported thinking:false before selecting a token or spawning", async () => {
+    const d = new AnthropicDispatcher();
+    const req = baseReq({model: "anthropic/claude-fable-5-1", thinking: false});
+    await expect(d.generate(req)).rejects.toMatchObject({statusCode: 400});
+    const cb = {onDelta: vi.fn(), onComplete: vi.fn(), onError: vi.fn()};
+    await d.generateStream(req, cb);
+    expect(cb.onError).toHaveBeenCalledWith(expect.objectContaining({statusCode: 400}));
+    expect(cb.onComplete).not.toHaveBeenCalled();
+    expect(runClaudeSessionMock).not.toHaveBeenCalled();
+    expect(readAnthropicQuotaUsageMock).not.toHaveBeenCalled();
   });
 
   it("happy: generate → GenerateResult (threadCoord 조립, systemHash 없음)", async () => {