@cartanova/qgrid-cli 2.10.2 → 2.10.3

package/bundle/src/application/monit/log-buffer.ts

@@ -1,12 +1,6 @@
 /**
- * Monit 로그 ring buffer — 프로세스 생존 기간 동안 최근 로그를 구조화 레코드로 보관한다.
- *
- * 콘솔 sink 와 병렬로 등록되는 두 번째 logtape sink 가 이 버퍼를 채우고,
- * monit.frame 이 커서 기반으로 읽어 대시보드 Monit 탭에 제공한다.
- * 재시작하면 리셋된다 — 영속 기록은 request_log 의 몫.
- *
- * timestamp/processStartedAt 은 epoch ms 숫자로 유지한다. web 의 전역 dateReviver 가
- * ISO 문자열을 Date 로 바꿔버리므로, 숫자만이 재시작 감지의 동등성 비교를 보존한다.
+ * 재시작하면 초기화되는 Monit 로그 버퍼.
+ * timestamp/processStartedAt은 web의 dateReviver 변환을 피하고 동등성 비교를 유지하도록 epoch ms를 쓴다.
  */
 import { type LogRecord, type Sink } from "@logtape/logtape";
 
@@ -48,16 +42,14 @@ function renderValue(value: unknown): string {
 
 export class MonitLogBuffer {
   readonly processStartedAt = Date.now();
-  private entries: MonitLogEntry[] = [];
-  private nextSeq = 1;
+  entries: MonitLogEntry[] = [];
+  nextSeq = 1;
 
   constructor(
-    private readonly capacity = DEFAULT_CAPACITY,
-    private readonly maxTextLength = DEFAULT_MAX_TEXT_LENGTH,
+    readonly capacity = DEFAULT_CAPACITY,
+    readonly maxTextLength = DEFAULT_MAX_TEXT_LENGTH,
   ) {}
 
-  // logtape sink 본체. logtape 가 sink 오류를 격리하지만, 버퍼 버그가
-  // meta logger 소음을 만들지 않도록 방어적으로 한 번 더 감싼다.
   push(record: LogRecord): void {
     try {
       let text = flattenMessage(record.message);
@@ -79,31 +71,25 @@ export class MonitLogBuffer {
     }
   }
 
-  get oldestSeq(): number {
-    return this.entries[0]?.seq ?? this.nextSeq;
-  }
-
-  get latestSeq(): number {
-    return this.nextSeq - 1;
-  }
-
-  // cursor 이후의 엔트리를 최대 limit 개 반환한다. cursor 미지정이면 tail.
+  // cursor 미지정이면 최근 엔트리부터 반환한다.
   after(cursor: number | undefined, limit: number): MonitLogChunk {
+    const latestSeq = this.nextSeq - 1;
+    const oldestSeq = this.entries[0]?.seq ?? this.nextSeq;
     if (cursor === undefined) {
       const entries = this.entries.slice(-limit);
       return {
         entries,
-        nextCursor: entries.at(-1)?.seq ?? this.latestSeq,
+        nextCursor: entries.at(-1)?.seq ?? latestSeq,
         dropped: 0,
       };
     }
 
     // 이전 프로세스의 커서 등 미래 커서는 방어적으로 현재 tail 로 재동기화한다.
-    if (cursor > this.latestSeq) {
-      return { entries: [], nextCursor: this.latestSeq, dropped: 0 };
+    if (cursor > latestSeq) {
+      return { entries: [], nextCursor: latestSeq, dropped: 0 };
     }
 
-    const dropped = Math.max(this.oldestSeq - cursor - 1, 0);
+    const dropped = Math.max(oldestSeq - cursor - 1, 0);
     const startIndex = this.entries.findIndex((entry) => entry.seq > cursor);
     const entries = startIndex === -1 ? [] : this.entries.slice(startIndex, startIndex + limit);
     return {

package/bundle/src/application/monit/monit.frame.test.ts

@@ -36,12 +36,12 @@ describe("MonitFrame.monitLogs", () => {
     const chunk = await MonitFrame.monitLogs();
     expect(chunk.processStartedAt).toBe(monitLogBuffer.processStartedAt);
     expect(chunk.dropped).toBe(0);
-    expect(chunk.nextCursor).toBe(monitLogBuffer.latestSeq);
+    expect(chunk.nextCursor).toBe(monitLogBuffer.after(undefined, 1).nextCursor);
     expect(chunk.entries.at(-1)?.text).toBe("second line");
   });
 
   it("returns only entries newer than the cursor with no boundary duplicates", async () => {
-    const baseline = monitLogBuffer.latestSeq;
+    const baseline = monitLogBuffer.after(undefined, 1).nextCursor;
     push("after baseline 1");
     push("after baseline 2");
 
@@ -50,7 +50,7 @@ describe("MonitFrame.monitLogs", () => {
       "after baseline 1",
       "after baseline 2",
     ]);
-    expect(chunk.nextCursor).toBe(monitLogBuffer.latestSeq);
+    expect(chunk.nextCursor).toBe(monitLogBuffer.after(undefined, 1).nextCursor);
 
     const followUp = await MonitFrame.monitLogs(chunk.nextCursor);
     expect(followUp.entries).toEqual([]);
@@ -90,7 +90,7 @@ describe("MonitFrame.monitLogs", () => {
       properties: { accessToken: "forbidden-property-secret", refreshToken: "also-forbidden" },
     });
 
-    const chunk = await MonitFrame.monitLogs(monitLogBuffer.latestSeq - 1);
+    const chunk = await MonitFrame.monitLogs(monitLogBuffer.after(undefined, 1).nextCursor - 1);
     const serialized = JSON.stringify(chunk);
     expect(serialized).not.toContain("forbidden-property-secret");
     expect(serialized).not.toContain("also-forbidden");
@@ -115,14 +115,13 @@ describe("MonitFrame.monitLogs", () => {
   it("piggybacks live vitals on every chunk, zeroed before dispatchers boot", async () => {
     QgridDispatcher.openaiDispatcher = {
       inFlight: 3,
-      quotaByToken: [
+      getQuotaSnapshot: () => [
         { name: "openai/haze", usedPercent: 41, threshold: 80, blocked: false, resetsAt: null },
         { name: "openai/nk", usedPercent: null, threshold: null, blocked: false, resetsAt: null },
       ],
     } as never;
     QgridDispatcher.anthropicDispatcher = {
-      tokenCount: 8,
-      tokenNames: ["anthropic/haze", "anthropic/noa"],
+      tokenPool: new Map([[1, {name: "anthropic/noa"}], [2, {name: "anthropic/haze"}]]),
       inFlight: 2,
     } as never;
     try {
@@ -133,7 +132,7 @@ describe("MonitFrame.monitLogs", () => {
           { name: "openai/haze", usedPercent: 41, threshold: 80, blocked: false, resetsAt: null },
           { name: "openai/nk", usedPercent: null, threshold: null, blocked: false, resetsAt: null },
         ],
-        anthropicTokenCount: 8,
+        anthropicTokenCount: 2,
         anthropicTokenNames: ["anthropic/haze", "anthropic/noa"],
         anthropicInFlight: 2,
       });

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

@@ -1,9 +1,4 @@
-/**
- * Monit — 대시보드 Monit 탭용 프로세스 로그 관측 API.
- *
- * 읽기 전용. ring buffer 를 얇게 직접 읽으며(범용 쿼리 기계 없이),
- * request log 를 남기지 않는다. 접근 경계는 다른 대시보드 API 와 동일하다.
- */
+// 읽기 전용 모니터링 API. 조회 자체는 request log에 남기지 않는다.
 import { api, BaseFrameClass, DB } from "sonamu";
 
 import { resolveOpenAITransportKind } from "../../utils/providers/openai/openai-transport-config";
@@ -49,9 +44,7 @@ class MonitFrameClass extends BaseFrameClass {
     };
   }
 
-  // 최근 1시간 provider 별 요청/오류/캐시 통계. vitals 와 달리 request_logs 를 타므로
-  // 분리된 endpoint 로 두고 웹에서 더 느슨한 주기로 폴링한다. 읽기 전용이며 request log 를
-  // 남기지 않는 monit 경계는 동일하다.
+  // DB를 조회하므로 메모리 기반 vitals보다 느린 주기로 폴링한다.
   @api({ httpMethod: "GET", clients: ["axios", "tanstack-query"] })
   async monitStats(): Promise<MonitStats> {
     const windowMinutes = 60;
@@ -60,14 +53,16 @@ class MonitFrameClass extends BaseFrameClass {
   }
 }
 
-// dispatcher 미초기화(부팅 직후) 시 0 으로 응답한다 — 가벼운 스냅샷이라 오류로 만들지 않는다.
 function currentVitals(): MonitVitals {
+  const anthropic = QgridDispatcher.anthropicDispatcher;
   return {
     openaiInFlight: QgridDispatcher.openaiDispatcher?.inFlight ?? 0,
-    openaiQuotaByToken: QgridDispatcher.openaiDispatcher?.quotaByToken ?? [],
-    anthropicTokenCount: QgridDispatcher.anthropicDispatcher?.tokenCount ?? 0,
-    anthropicTokenNames: QgridDispatcher.anthropicDispatcher?.tokenNames ?? [],
-    anthropicInFlight: QgridDispatcher.anthropicDispatcher?.inFlight ?? 0,
+    openaiQuotaByToken: QgridDispatcher.openaiDispatcher?.getQuotaSnapshot() ?? [],
+    anthropicTokenCount: anthropic?.tokenPool.size ?? 0,
+    anthropicTokenNames: anthropic
+      ? [...anthropic.tokenPool.values()].map((token) => token.name).toSorted()
+      : [],
+    anthropicInFlight: anthropic?.inFlight ?? 0,
   };
 }
 

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

@@ -132,7 +132,7 @@ export class RefreshFailedError extends Error {
   }
 
   /** 재로그인 외 복구 불가한 인증 실패인지. 일시 오류(5xx·네트워크)는 제외된다. */
-  get isAuthDead(): boolean {
+  isAuthDead(): boolean {
     return this.status === 400 || this.status === 401;
   }
 }

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

@@ -122,6 +122,13 @@ describe("qgrid run lifecycle start", () => {
     });
   });
 
+  it.each([false, true, undefined])("does not log ignored effort when thinking is %s", async (thinking) => {
+    await beforeQuery({ prompt: "hi", model: "openai/gpt-6-sol", thinking, effort: "high" });
+    expect(createRunMock).toHaveBeenCalledWith(expect.objectContaining({
+      effort: thinking === false ? undefined : "high",
+    }));
+  });
+
   it.each([false, true])("classifies automatic image output only when produced (%s)", async (hasImage) => {
     const args = { prompt: "chat", model: "openai/gpt-6-astra", imageGeneration: "auto" as const };
     const run = await beforeQuery(args);

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

@@ -131,7 +131,7 @@ export async function beforeQuery(args: QueryInput): Promise<{
       user_prompt: args.prompt,
       system_prompt: args.system,
       requested_model_name: args.model,
-      effort: args.effort,
+      effort: args.thinking === false ? undefined : args.effort,
       project_name: args.projectName,
       history: filterHistoryForStorage(args.history),
       tools: args.tools?.length ? args.tools : undefined,

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

@@ -6,8 +6,10 @@ import {
   type GenerateStreamCallbacks,
 } from "../../utils/providers/common/provider-dispatcher";
 import { systemHash } from "./conv-routing";
+import { OpenAIDispatcher } from "../../utils/providers/openai/openai-dispatcher";
+import { normalizeOpenAIEvent } from "../../utils/providers/openai/openai-backend-protocol";
 import { buildStrictOutputSchema, QgridDispatcherClass } from "./qgrid.dispatcher";
-import { type QueryOutput } from "./qgrid.types";
+import { QueryInput, type QueryOutput } from "./qgrid.types";
 import { type TokenSubsetA } from "../sonamu.generated";
 
 function providerResult(overrides: Partial<GenerateResult> = {}): GenerateResult {
@@ -34,6 +36,65 @@ function deeplyNestedOutputSchema(depth: number): string {
 }
 
 describe("QgridDispatcherClass", () => {
+  it.each(["generate", "stream"])("%s yields a completed tool-call message before a speculative later answer", async (mode) => {
+    const tool = JSON.stringify({result: {action: "tool_call", answer: null, toolCalls: [{toolName: "lookupMarker", args: "{}"}]}});
+    const answer = JSON.stringify({result: {action: "answer", answer: {marker: ""}, toolCalls: null}});
+    const provider = new OpenAIDispatcher("https", {clientFactory: () => ({
+      async *responses() {
+        yield normalizeOpenAIEvent({type: "response.output_item.added", item: {id: "preamble", type: "message", phase: "commentary", content: []}})!;
+        yield normalizeOpenAIEvent({type: "response.output_text.delta", item_id: "preamble", delta: "We need request tool structured."})!;
+        yield normalizeOpenAIEvent({type: "response.output_item.done", item: {id: "preamble", type: "message", phase: "commentary", content: [{type: "output_text", text: "We need request tool structured."}]}})!;
+        for (const [id, phase, text] of [["tool", "commentary", tool], ["answer", "final_answer", answer]]) {
+          yield normalizeOpenAIEvent({type: "response.output_item.added", item: {id, type: "message", role: "assistant", phase, content: []}})!;
+          yield normalizeOpenAIEvent({type: "response.output_text.delta", item_id: id, delta: text})!;
+          yield normalizeOpenAIEvent({type: "response.output_item.done", item: {id, type: "message", role: "assistant", phase, content: [{type: "output_text", text}]}})!;
+        }
+        yield normalizeOpenAIEvent({type: "response.completed", response: {id: "r", model: "gpt-6-luna", usage: {input_tokens: 10, output_tokens: 30, total_tokens: 40}}})!;
+      },
+    })});
+    await provider.onTokenAdded(1, "test", {accessToken: "unused", refreshToken: "", accountId: "unused", accessTokenExpiresAt: Date.now()+60000});
+    const dispatcher = new QgridDispatcherClass();
+    dispatcher.openaiDispatcher = provider;
+    const input = {model: "openai/gpt-6-luna", prompt: "lookup", tools: [{name: "lookupMarker", inputSchema: {type: "object"}}], jsonSchema: JSON.stringify({type: "object",properties: {marker: {type: "string"}}})};
+    const deltas: string[] = [];
+    let result: QueryOutput | undefined;
+    if (mode === "generate") result = await dispatcher.query(input);
+    else await dispatcher.queryStream(input, {onDelta: text => deltas.push(text), onComplete: value => {result = value;}, onError: error => {throw error;}});
+    expect(result?.finishReason).toBe("tool-calls");
+    expect(result?.content[0]).toMatchObject({type: "tool-call", toolName: "lookupMarker", input: "{}"});
+    expect(result?.usage.output_tokens).toBe(30); // Drain through completion; don't undercount discarded text.
+    if (mode === "stream") expect(deltas.join("")).toBe(tool);
+    await provider.stop();
+  });
+
+  it("accepts only boolean thinking values on both query and prepareStream's shared input", () => {
+    for (const thinking of [true, false, undefined]) {
+      expect(QueryInput.parse({ prompt: "hi", thinking }).thinking).toBe(thinking);
+    }
+    expect(QueryInput.safeParse({ prompt: "hi", thinking: "false" }).success).toBe(false);
+  });
+
+  it.each(["openai/gpt-6-sol", "anthropic/claude-sonnet-4-6"])(
+    "forwards thinking on generate and stream, suppressing effort only for explicit off (%s)",
+    async (model) => {
+      const dispatcher = new QgridDispatcherClass();
+      const generate = vi.fn(async () => providerResult());
+      const generateStream = vi.fn(async (_req: GenerateRequest, cb: GenerateStreamCallbacks) => {
+        cb.onComplete(providerResult());
+      });
+      dispatcher.openaiDispatcher = { generate, generateStream } as never;
+      dispatcher.anthropicDispatcher = { generate, generateStream } as never;
+      for (const thinking of [false, true, undefined]) {
+        const input = { prompt: "hi", model, thinking, effort: "high" };
+        await dispatcher.query(input);
+        await dispatcher.queryStream(input, { onDelta: vi.fn(), onComplete: vi.fn(), onError: vi.fn() });
+        const expected = { thinking, effort: thinking === false ? undefined : "high" };
+        expect(generate).toHaveBeenLastCalledWith(expect.objectContaining(expected));
+        expect(generateStream).toHaveBeenLastCalledWith(expect.objectContaining(expected), expect.any(Object));
+      }
+    },
+  );
+
   it("counts completed query and stream generations separately for providers sharing a token name", async () => {
     const dispatcher = new QgridDispatcherClass();
     dispatcher.replaceCache(

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

@@ -1,11 +1,4 @@
-/**
- * QgridDispatcher — provider dispatcher 라우팅 + 토큰 캐시/통계 싱글턴.
- *
- * - 메모리 캐시 (Map<id, TokenSubsetA>) 는 TokenSubscriber 가 pg LISTEN/NOTIFY 로 갱신
- * - OpenAI/Anthropic 요청은 각 provider dispatcher 로만 실행
- * - QuotaError 는 그대로 상위 전파
- * - dispatcher 미준비는 기동 중(503)/초기화 실패(500)로 구분해 던진다
- */
+// provider 라우팅과 토큰 캐시·통계. 캐시는 TokenSubscriber가 갱신한다.
 
 import { InternalServerErrorException, ServiceUnavailableException } from "sonamu";
 
@@ -37,7 +30,7 @@ import {
 } from "./qgrid.types";
 import { composeSystemWithSchemaContract } from "./schema-prompt";
 import { type TokenSubscriber } from "./token-subscriber";
-import { applyToolCallEmulation } from "./tool-emulation";
+import { applyToolCallEmulation, isToolCallEnvelope } from "./tool-emulation";
 import { buildToolCallSchema } from "./tool-emulation-schema";
 
 export type InternalQueryInput = QueryInput & {
@@ -50,55 +43,31 @@ export class QgridDispatcherClass {
 
   // 프로세스 시작 이후 완료된 provider generation 수. 실패/중간 시도는 제외하며,
   // 후속 tool turn도 한 generation으로 센다. 동명 토큰은 provider별로 분리한다.
-  private requestCounts = new Map<string, number>();
+  requestCounts = new Map<string, number>();
 
-  // sonamu.config onStart 에서 처리하는 변수
   subscriber: TokenSubscriber | null = null;
   openaiDispatcher: OpenAIDispatcher | null = null;
   anthropicDispatcher: AnthropicDispatcher | null = null;
 
-  /**
-   * provider 별 기동 상태. dispatcher 가 없는 이유를 구분하기 위해 필요하다 —
-   * HTTP 리스닝은 dispatcher 준비보다 먼저 열리므로(sonamu.config onStart),
-   * 그 사이 들어온 요청은 "잠시 후 되는" 상태와 "재시도해도 안 되는" 상태가 다르다.
-   *
-   * - `starting`: provider 토큰·런타임 초기화 중 → 재시도 가능
-   * - `ready`: 정상
-   * - `failed`: start() 가 예외로 끝남 → 재시도해도 같은 결과
-   */
+  // HTTP가 dispatcher보다 먼저 열리므로 초기화 중과 초기화 실패를 구분한다.
   startupState: Record<"openai" | "anthropic", ProviderStartupState> = {
     openai: "starting",
     anthropic: "starting",
   };
 
-  /**
-   * dispatcher 가 준비되지 않았을 때 던질 예외를 만든다.
-   *
-   * 기동 중이면 503(+Retry-After) 으로 재시도 가능함을 알리고, 초기화가 실패로 끝났으면
-   * 500 으로 재시도가 무의미함을 알린다. 이전에는 둘 다 QuotaError 였는데, 쿼터 소진이
-   * 아닌 상태를 그렇게 표현하면 호출자가 토큰 문제로 오해하고 재시도 판단도 못 한다.
-   */
-  private notReadyError(provider: "openai" | "anthropic"): Error {
+  // 초기화 중에는 503 + Retry-After, 초기화 실패에는 500을 반환한다.
+  notReadyError(provider: "openai" | "anthropic"): Error {
     const label = provider === "openai" ? "OpenAI" : "Anthropic";
     return this.startupState[provider] === "failed"
       ? new InternalServerErrorException(SD("qgrid.dispatcherFailed")(label))
       : new ServiceUnavailableException(SD("qgrid.dispatcherStarting")(label));
   }
 
-  private recordCompleted(provider: string, tokenName: string): void {
+  recordCompleted(provider: string, tokenName: string): void {
     const key = `${provider}\0${tokenName}`;
     this.requestCounts.set(key, (this.requestCounts.get(key) ?? 0) + 1);
   }
 
-  // TokenSubscriber 콜백 — 캐시 mutation
-  upsertCache(id: number, row: TokenSubsetA): void {
-    this.tokens.set(id, row);
-  }
-
-  removeCache(id: number): void {
-    this.tokens.delete(id);
-  }
-
   replaceCache(rows: TokenSubsetA[]): void {
     this.tokens = new Map(rows.map((r) => [r.id, r]));
   }
@@ -115,10 +84,8 @@ export class QgridDispatcherClass {
   async query(input: InternalQueryInput, abortSignal?: AbortSignal): Promise<QueryOutput> {
     const route = parseProviderRoute(input.model);
     const outputSchema = buildAndValidateStrictOutputSchema(input, route.provider);
-    // answer 인코딩 판정: jsonSchema 있으면 사용자 스키마 JSON, 없으면 평문 string. 4개 방출 지점이 공유.
     const answerKind = input.jsonSchema ? ("json" as const) : ("text" as const);
 
-    // provider prefix routing: 'openai/gpt-5.4' → OpenAIDispatcher
     if (route.provider === "openai") {
       if (!this.openaiDispatcher) throw this.notReadyError("openai");
 
@@ -130,7 +97,11 @@ export class QgridDispatcherClass {
         model: route.model,
         systemPrompt: input.system,
         outputSchema,
-        effort: input.effort,
+        stopAfterOutputMessage: input.tools?.length
+          ? (text, phase) => isToolCallEnvelope(text, input.tools!, answerKind, phase)
+          : undefined,
+        thinking: input.thinking,
+        effort: input.thinking === false ? undefined : input.effort,
         verbosity: input.verbosity,
         reasoningSummary: input.reasoningSummary,
         serviceTier: input.serviceTier,
@@ -163,13 +134,10 @@ export class QgridDispatcherClass {
 
       const decision = decideConvRouting(input);
       const result = await this.anthropicDispatcher.generate({
-        // AnthropicDispatcher 내부에서 알아서 provider prefix 를 canonical model 로 정규화함
         model: input.model,
-        // 스키마/envelope 계약은 --json-schema 대신 system 말미의 텍스트로 안내한다(SON-532).
-        // outputSchema 는 전달하지 않는다 — anthropic 에서 항상 undefined(U1)이며,
-        // CC 로 가는 --json-schema 채널 자체가 닫혀 있음을 여기서 명시한다.
         systemPrompt: composeSystemWithSchemaContract(input.system, input),
-        effort: input.effort,
+        thinking: input.thinking,
+        effort: input.thinking === false ? undefined : input.effort,
         timeoutMs: input.timeout,
         abortSignal,
         coldInput: decision.coldInput,
@@ -196,7 +164,6 @@ export class QgridDispatcherClass {
   ): Promise<void> {
     const route = parseProviderRoute(input.model);
     const outputSchema = buildAndValidateStrictOutputSchema(input, route.provider);
-    // answer 인코딩 판정: jsonSchema 있으면 사용자 스키마 JSON, 없으면 평문 string. 4개 방출 지점이 공유.
     const answerKind = input.jsonSchema ? ("json" as const) : ("text" as const);
 
     if (route.provider === "openai") {
@@ -211,7 +178,11 @@ export class QgridDispatcherClass {
           model: route.model,
           systemPrompt: input.system,
           outputSchema,
-          effort: input.effort,
+          stopAfterOutputMessage: input.tools?.length
+            ? (text, phase) => isToolCallEnvelope(text, input.tools!, answerKind, phase)
+            : undefined,
+          thinking: input.thinking,
+          effort: input.thinking === false ? undefined : input.effort,
           verbosity: input.verbosity,
           reasoningSummary: input.reasoningSummary,
           serviceTier: input.serviceTier,
@@ -222,7 +193,6 @@ export class QgridDispatcherClass {
           preferredTokenId: input.preferredTokenId ?? decision.preferredTokenId,
           requirePreferredToken: input.requirePreferredToken,
           abortSignal,
-          // 이미지 플래그를 전달해야 generateStream 의 non-stream 전용 거부(R2)가 발동한다.
           imageGeneration: input.imageGeneration,
           imageGenerationOptions: input.imageGenerationOptions,
         },
@@ -250,9 +220,7 @@ export class QgridDispatcherClass {
     } else if (route.provider === "anthropic") {
       if (!this.anthropicDispatcher) throw this.notReadyError("anthropic");
 
-      // 계약(스키마/envelope)이 주입된 요청의 델타에서 코드펜스를 벗긴다(SON-532).
-      // 비스트림 최종 텍스트는 stream-json-adapter 의 stripFences 가 같은 시맨틱으로
-      // 처리하므로 델타 연결과 done.text 가 어긋나지 않는다. 일반 텍스트 요청은 무변경.
+      // 구조화 응답은 최종 텍스트와 델타 모두 코드펜스를 제거한다.
       const hasSchemaContract = input.jsonSchema !== undefined || Boolean(input.tools?.length);
       const fenceStrip = hasSchemaContract ? createFenceStripTransform() : undefined;
       const emitDelta = fenceStrip
@@ -266,9 +234,9 @@ export class QgridDispatcherClass {
       await this.anthropicDispatcher.generateStream(
         {
           model: input.model,
-          // 스키마/envelope 계약은 --json-schema 대신 system 말미의 텍스트로 안내한다(SON-532)
           systemPrompt: composeSystemWithSchemaContract(input.system, input),
-          effort: input.effort,
+          thinking: input.thinking,
+          effort: input.thinking === false ? undefined : input.effort,
           coldInput: decision.coldInput,
           coldHistory: decision.coldHistory,
           preferredTokenId: input.preferredTokenId,
@@ -282,8 +250,7 @@ export class QgridDispatcherClass {
           onThreadId: cb.onThreadId,
           onComplete: (turnResult) => {
             this.recordCompleted("anthropic", turnResult.tokenName);
-            // 홀드백 잔여(닫는 펜스가 아니었던 tail)를 done 전에 마저 방출한다 —
-            // 델타를 조립하는 클라이언트(EnvelopeStreamParser 등)의 무손실 보장.
+            // 닫는 펜스 판정 때문에 보류한 텍스트를 완료 전에 방출한다.
             const rest = fenceStrip?.flush();
             if (rest) cb.onDelta(rest);
 
@@ -315,19 +282,12 @@ function parseProviderRoute(model: string | undefined): { provider?: string; mod
   return { provider, model: routedModel };
 }
 
-// qgrid provider dispatcher 에서 처리하지 않는 모델은 향후 직접 LLM API 호출 지점으로 보낸다.
 function directLlmApiFallbackNotImplemented(input: QueryInput): ProcessError {
   return new ProcessError(
     `Direct LLM API fallback not implemented for model: ${input.model ?? "<default>"}`,
   );
 }
 
-// 모든 provider(OpenAI/Anthropic)가 동일하게 strict output schema 를 쓴다.
-//
-// SON-495 교훈: 한때 Anthropic route 만 required 를 제거(optionalize)해 partial/rejected attempt 가
-// 섞여도 통과하게 했으나, 실측 결과 그게 오히려 "모델이 비는 필드를 키째 생략"하도록 유도했다
-// (required 살린 schema 는 누락 0, loose 는 누락 다발). strict 로 두면 모델이 빠짐없이 채우고,
-// 드물게 어겨 provider retry 예산을 소진한 비정상 종료도 정직한 에러로 받아준다.
 export function buildStrictOutputSchema(
   input: Pick<QueryInput, "tools" | "jsonSchema">,
   provider?: string,
@@ -343,11 +303,8 @@ export function buildAndValidateStrictOutputSchema(
   input: Pick<QueryInput, "model" | "tools" | "jsonSchema">,
   provider = parseProviderRoute(input.model).provider,
 ): JsonValue | undefined {
-  // anthropic(SON-532): CC 에 --json-schema 를 전달하지 않는다 — 강제 없는 사후 채점이
-  // 소비자 의도(nullish 생략 등)와 충돌해 CC 내부 재시도 루프를 발화시켰다(왕복 2~4회,
-  // 4.7~9.1배 출력 청구 실측). 스키마/envelope 계약은 프롬프트 텍스트로 안내하고 판정은
-  // 소비자(zod)/parseEnvelope 가 맡는다. 따라서 strict 변환·argv 64KiB 제한 없이 수신
-  // 원형의 구문·복잡도(전역 512KiB 한도)만 검증해 caller-fault 를 조기에 돌려준다.
+  // Claude Code의 --json-schema는 불필요한 내부 재시도를 유발한다.
+  // Anthropic은 원본 스키마를 검증한 뒤 프롬프트로 전달하고, 응답 검증은 소비자에 맡긴다.
   if (provider === "anthropic") {
     parseAndValidateCallerSchemas(input);
     return undefined;
@@ -368,10 +325,7 @@ function buildRawOutputSchema(
     : callerOutputSchema;
 }
 
-// GenerateResult(provider dispatcher 응답)를 applyToolCallEmulation 입력 shape 로 매핑한다.
-// OpenAI/Anthropic, query/queryStream 4 경로가 동일하게 쓴다.
 // Anthropic adapter 는 cache creation 을 inputTokens 에 포함해 표준화하고, 별도 필드에도 보존한다.
-// per-request cost 는 provider 가 준 값을 우선 사용하고, 없으면 공통 cost 함수를 쓴다.
 function toEmulationResult(
   result: GenerateResult,
 ): Omit<QueryOutput, "content" | "finishReason" | "runContext"> {

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

@@ -630,11 +630,7 @@ class QgridFrameClass extends BaseFrameClass {
   }
 
   // 교환 + 계정 중복 제거 + 저장 — redirect 콜백과 코드 붙여넣기 플로우가 공유한다.
-  private async completeAnthropicLogin(
-    code: string,
-    state: string,
-    pending: PendingOAuth,
-  ): Promise<void> {
+  async completeAnthropicLogin(code: string, state: string, pending: PendingOAuth): Promise<void> {
     const tokens = await exchangeCodeForTokens(
       code,
       pending.codeVerifier,
@@ -656,7 +652,7 @@ class QgridFrameClass extends BaseFrameClass {
     notifyTokenAdded(pending.name, "anthropic");
   }
 
-  private async completeOpenAILogin(code: string, pending: PendingOAuth): Promise<void> {
+  async completeOpenAILogin(code: string, pending: PendingOAuth): Promise<void> {
     const creds = await exchangeOpenAICode(code, pending.codeVerifier, pending.redirectUri);
     await TokenModel.replaceByAccount("openai", creds.accountId, {
       provider: "openai",
@@ -801,7 +797,7 @@ class QgridFrameClass extends BaseFrameClass {
     }
   }
 
-  private async doRefreshToken(token: TokenSubsetA): Promise<string> {
+  async doRefreshToken(token: TokenSubsetA): Promise<string> {
     const creds = token.credentials;
     const rt = getRefreshToken(creds);
     if (!rt) throw new Error("No refresh token");
@@ -810,7 +806,7 @@ class QgridFrameClass extends BaseFrameClass {
     try {
       refreshed = await refreshAccessToken(rt);
     } catch (e) {
-      if (e instanceof RefreshFailedError && e.isAuthDead) {
+      if (e instanceof RefreshFailedError && e.isAuthDead()) {
         await deactivateAuthDeadToken(token, `anthropic:${e.status}`);
       }
       throw e;

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

@@ -150,6 +150,8 @@ export const QueryInput = z.looseObject({
   timeout: QueryTimeoutMs.optional(),
   jsonSchema: z.string().optional(),
   tools: z.array(QgridTool).optional(),
+  // Boolean literals keep Sonamu's HTTP caster from accepting "true"/"false" strings.
+  thinking: z.union([z.literal(true), z.literal(false)]).optional(),
   effort: z.string().optional(),
   verbosity: Verbosity.optional(),
   reasoningSummary: ReasoningSummary.optional(),