@cartanova/qgrid-cli 2.7.0 → 2.7.2

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

@@ -5,7 +5,9 @@ import {
   type GenerateResult,
   type GenerateStreamCallbacks,
 } from "../../utils/providers/common/provider-dispatcher";
+import { systemHash } from "./conv-routing";
 import { buildStrictOutputSchema, QgridDispatcherClass } from "./qgrid.dispatcher";
+import { type QueryOutput } from "./qgrid.types";
 
 function providerResult(overrides: Partial<GenerateResult> = {}): GenerateResult {
   return {
@@ -175,7 +177,7 @@ describe("QgridDispatcherClass", () => {
     expect(onError).toHaveBeenCalledWith(serverError);
   });
 
-  it("OpenAI query 는 reuse/reuseInput 을 provider 로 계속 전달한다", async () => {
+  it("OpenAI query 는 thread reuse 대신 full-history cache affinity 를 전달한다", async () => {
     const dispatcher = new QgridDispatcherClass();
     const generate = vi.fn(async (_req: GenerateRequest) => providerResult({ model: "gpt-5.5" }));
     dispatcher.openaiDispatcher = { generate } as never;
@@ -184,19 +186,48 @@ describe("QgridDispatcherClass", () => {
       prompt: "next",
       model: "openai/gpt-5.5",
       system: "same-system",
+      history: JSON.stringify([{ role: "user", content: "first" }]),
+      cacheAffinityKey: "a".repeat(64),
       runContext: {
         threadCoord: {
           workerId: 1,
-          threadId: "thread-1",
-          epoch: 0,
-          systemHash: "800ddd9ba811b821",
+          threadId: "a".repeat(64),
+          epoch: -1,
+          systemHash: systemHash("same-system", "openai/gpt-5.5"),
         },
       },
     });
 
     const req = generate.mock.calls[0]![0];
-    expect(req.reuse).toEqual({ workerId: 1, threadId: "thread-1", epoch: 0 });
-    expect(req.reuseInput).toEqual([{ type: "text", text: "next", text_elements: [] }]);
+    expect(req).not.toHaveProperty("reuse");
+    expect(req).not.toHaveProperty("reuseInput");
+    expect(req.coldHistory).toEqual([{ role: "user", content: "first" }]);
+    expect(req.coldInput).toEqual([{ type: "text", text: "next", text_elements: [] }]);
+    expect(req.promptCacheKey).toBe("a".repeat(64));
+    expect(req.preferredTokenId).toBe(1);
+  });
+
+  it("OpenAI response issues a four-field epoch=-1 affinity coord", async () => {
+    const dispatcher = new QgridDispatcherClass();
+    dispatcher.openaiDispatcher = {
+      generate: vi.fn(async () =>
+        providerResult({ threadCoord: { workerId: 137, threadId: "ignored", epoch: -1 } }),
+      ),
+    } as never;
+
+    const result = await dispatcher.query({
+      prompt: "first",
+      model: "openai/gpt-5.5",
+      system: "system",
+      cacheAffinityKey: "c".repeat(64),
+    });
+
+    expect(result.runContext?.threadCoord).toEqual({
+      workerId: 137,
+      threadId: "c".repeat(64),
+      epoch: -1,
+      systemHash: expect.any(String),
+    });
   });
 
   it("Anthropic query 는 reuse/reuseInput 을 provider 로 전달하지 않는다", async () => {
@@ -397,9 +428,12 @@ describe("QgridDispatcherClass", () => {
     },
   );
 
-  // SON-495: anthropic route 도 strict(required 유지)를 쓴다 — required 를 살려야 모델이 필드를
-  // 빠짐없이 채운다(실측 확정). optionalize 는 제거됨.
-  it("Anthropic route 에 strict(required 유지) outputSchema 를 전달한다", async () => {
+  // SON-532: anthropic route 는 --json-schema 를 쓰지 않는다 — CC 의 강제 없는 사후 채점이
+  // 소비자 의도와 충돌해 내부 재시도 루프를 발화시켰다. 스키마는 프롬프트로 안내되고
+  // 판정은 소비자(zod)가 맡으므로 provider 로는 outputSchema 를 보내지 않는다.
+  // (SON-495 의 "required 유지" 교훈은 채점 전제의 규칙이었다 — 안내문에는 소비자가
+  // 선언한 required 가 원형 그대로 남는다.)
+  it("Anthropic route 는 outputSchema 를 provider 로 전달하지 않는다", async () => {
     const dispatcher = new QgridDispatcherClass();
     const generate = vi.fn(
       async (_req: GenerateRequest): Promise<GenerateResult> => ({
@@ -429,13 +463,219 @@ describe("QgridDispatcherClass", () => {
       }),
     });
 
-    const outputSchema = generate.mock.calls[0]![0].outputSchema as {
-      required?: string[];
-      additionalProperties?: boolean;
-    };
-    // anthropic 도 OpenAI 와 동일하게 strictify — required 살아있음
-    expect(outputSchema.required).toEqual(["contents"]);
-    expect(outputSchema.additionalProperties).toBe(false);
+    expect(generate.mock.calls[0]![0].outputSchema).toBeUndefined();
+  });
+
+  it("Anthropic route 도 원형 스키마의 구문·복잡도는 계속 검증한다", async () => {
+    const dispatcher = new QgridDispatcherClass();
+    dispatcher.anthropicDispatcher = { generate: vi.fn() } as never;
+
+    // 구문 오류는 provider 실행 전에 caller-fault 로 거절된다.
+    await expect(
+      dispatcher.query({
+        prompt: "hi",
+        model: "anthropic/claude-sonnet-4-6",
+        jsonSchema: "{not json",
+      }),
+    ).rejects.toThrow("jsonSchema must contain valid JSON");
+
+    // 복잡도 한도(depth)도 그대로 산다.
+    await expect(
+      dispatcher.query({
+        prompt: "hi",
+        model: "anthropic/claude-sonnet-4-6",
+        jsonSchema: deeplyNestedOutputSchema(5_000),
+      }),
+    ).rejects.toThrow("exceeds depth limit");
+  });
+
+  // SON-532: 계약은 --json-schema 대신 system 말미에 텍스트로 주입된다.
+  it.each(["query", "queryStream"] as const)(
+    "Anthropic %s 는 스키마 계약을 system prompt 말미에 합성해 전달한다",
+    async (method) => {
+      const dispatcher = new QgridDispatcherClass();
+      let request: GenerateRequest | undefined;
+
+      if (method === "query") {
+        const generate = vi.fn(async (req: GenerateRequest) => {
+          request = req;
+          return providerResult();
+        });
+        dispatcher.anthropicDispatcher = { generate } as never;
+        await dispatcher.query({
+          prompt: "hi",
+          system: "You are helpful.",
+          model: "anthropic/claude-sonnet-4-6",
+          jsonSchema: JSON.stringify({ type: "object", properties: { a: { type: "string" } } }),
+        });
+      } else {
+        const generateStream = vi.fn(async (req: GenerateRequest, cb: GenerateStreamCallbacks) => {
+          request = req;
+          cb.onComplete(providerResult());
+        });
+        dispatcher.anthropicDispatcher = { generateStream } as never;
+        await dispatcher.queryStream(
+          {
+            prompt: "hi",
+            system: "You are helpful.",
+            model: "anthropic/claude-sonnet-4-6",
+            jsonSchema: JSON.stringify({ type: "object", properties: { a: { type: "string" } } }),
+          },
+          { onDelta: vi.fn(), onComplete: vi.fn(), onError: vi.fn() },
+        );
+      }
+
+      // 원래 system 이 앞, 계약이 말미 — 스키마 원문이 그대로 들어간다.
+      expect(request?.systemPrompt).toMatch(/^You are helpful\.\n\n## Output Format/);
+      expect(request?.systemPrompt).toContain('"a":{"type":"string"}');
+    },
+  );
+
+  it("Anthropic tools 요청은 envelope 계약을 system 에 합성한다", async () => {
+    const dispatcher = new QgridDispatcherClass();
+    const generate = vi.fn(async (req: GenerateRequest) => {
+      void req;
+      return providerResult({
+        text: '{"result":{"action":"answer","answer":{"payload":"ok"},"toolCalls":null}}',
+      });
+    });
+    dispatcher.anthropicDispatcher = { generate } as never;
+
+    await dispatcher.query({ prompt: "hi", model: "anthropic/claude-sonnet-4-6", ...toolsAndSchema });
+
+    const request = generate.mock.calls[0]![0];
+    expect(request.systemPrompt).toContain("## Client Tool Protocol");
+    expect(request.systemPrompt).toContain('{"result": ...}');
+    expect(request.systemPrompt).toContain("- lookup");
+  });
+
+  it("스키마 없는 Anthropic 요청은 system 을 그대로 둔다", async () => {
+    const dispatcher = new QgridDispatcherClass();
+    const generate = vi.fn(async (_req: GenerateRequest) => providerResult());
+    dispatcher.anthropicDispatcher = { generate } as never;
+
+    await dispatcher.query({ prompt: "hi", system: "plain", model: "anthropic/claude-sonnet-4-6" });
+    expect(generate.mock.calls[0]![0]!.systemPrompt).toBe("plain");
+
+    await dispatcher.query({ prompt: "hi", model: "anthropic/claude-sonnet-4-6" });
+    expect(generate.mock.calls[1]![0]!.systemPrompt).toBeUndefined();
+  });
+
+  it("OpenAI 요청의 system 에는 계약을 합성하지 않는다", async () => {
+    const dispatcher = new QgridDispatcherClass();
+    const generate = vi.fn(async (_req: GenerateRequest) =>
+      providerResult({ text: '{"a":"ok"}' }),
+    );
+    dispatcher.openaiDispatcher = { generate } as never;
+
+    await dispatcher.query({
+      prompt: "hi",
+      system: "plain",
+      model: "openai/gpt-5.5",
+      jsonSchema: JSON.stringify({ type: "object", properties: { a: { type: "string" } } }),
+    });
+
+    expect(generate.mock.calls[0]![0]!.systemPrompt).toBe("plain");
+  });
+
+  // SON-532: 계약 주입 스트림의 델타에서 펜스를 벗긴다. 클라이언트(EnvelopeStreamParser,
+  // partialOutputStream)는 펜스를 처리하지 못하므로 서버 책임이다.
+  it("Anthropic 스트림은 계약 주입 시 델타의 코드펜스를 벗겨 방출한다", async () => {
+    const dispatcher = new QgridDispatcherClass();
+    const generateStream = vi.fn(async (_req: GenerateRequest, cb: GenerateStreamCallbacks) => {
+      cb.onDelta("```json\n");
+      cb.onDelta('{"a"');
+      cb.onDelta(":1}");
+      cb.onDelta("\n```");
+      cb.onComplete(providerResult({ text: '{"a":1}' }));
+    });
+    dispatcher.anthropicDispatcher = { generateStream } as never;
+
+    const deltas: string[] = [];
+    let completed: QueryOutput | undefined;
+    await dispatcher.queryStream(
+      {
+        prompt: "hi",
+        model: "anthropic/claude-sonnet-4-6",
+        jsonSchema: JSON.stringify({ type: "object", properties: { a: { type: "number" } } }),
+      },
+      {
+        onDelta: (t) => deltas.push(t),
+        onComplete: (output) => {
+          completed = output;
+        },
+        onError: vi.fn(),
+      },
+    );
+
+    // 델타 연결 == 펜스 벗긴 전체 텍스트 == done.text (adapter 의 stripFences 와 동일 시맨틱)
+    expect(deltas.join("")).toBe('{"a":1}');
+    expect(completed?.text).toBe('{"a":1}');
+  });
+
+  it("Anthropic 스트림의 홀드백 잔여는 done 전에 방출된다 (내용 무손실)", async () => {
+    const dispatcher = new QgridDispatcherClass();
+    const events: string[] = [];
+    const generateStream = vi.fn(async (_req: GenerateRequest, cb: GenerateStreamCallbacks) => {
+      cb.onDelta('{"a":1}\n``'); // 미완성 펜스로 종료 — 닫는 펜스가 아니다
+      cb.onComplete(providerResult({ text: '{"a":1}\n``' }));
+    });
+    dispatcher.anthropicDispatcher = { generateStream } as never;
+
+    await dispatcher.queryStream(
+      {
+        prompt: "hi",
+        model: "anthropic/claude-sonnet-4-6",
+        jsonSchema: JSON.stringify({ type: "object" }),
+      },
+      {
+        onDelta: (t) => events.push(`delta:${t}`),
+        onComplete: () => events.push("complete"),
+        onError: vi.fn(),
+      },
+    );
+
+    expect(events.join("|")).toBe('delta:{"a":1}|delta:\n``|complete');
+  });
+
+  it("계약 없는 Anthropic 스트림 델타는 무변경 통과한다", async () => {
+    const dispatcher = new QgridDispatcherClass();
+    const generateStream = vi.fn(async (_req: GenerateRequest, cb: GenerateStreamCallbacks) => {
+      cb.onDelta("```python\ncode\n```");
+      cb.onComplete(providerResult({ text: "```python\ncode\n```" }));
+    });
+    dispatcher.anthropicDispatcher = { generateStream } as never;
+
+    const deltas: string[] = [];
+    await dispatcher.queryStream(
+      { prompt: "hi", model: "anthropic/claude-sonnet-4-6" },
+      { onDelta: (t) => deltas.push(t), onComplete: vi.fn(), onError: vi.fn() },
+    );
+
+    expect(deltas.join("")).toBe("```python\ncode\n```");
+  });
+
+  it("Anthropic route 는 strict 전용 argv 64KiB 제한을 적용하지 않는다", async () => {
+    const dispatcher = new QgridDispatcherClass();
+    const generate = vi.fn(async (): Promise<GenerateResult> => providerResult());
+    dispatcher.anthropicDispatcher = { generate } as never;
+
+    // 64KiB(ANTHROPIC_SCHEMA_ARGV_MAX_UTF8_BYTES) 초과, 전역 512KiB 미만 스키마.
+    // structured 시절에는 argv 제한으로 거절됐지만 프롬프트 전달은 system 크기 분기가 흡수한다.
+    const bigSchema = JSON.stringify({
+      type: "object",
+      description: "x".repeat(80 * 1024),
+      properties: { value: { type: "string" } },
+    });
+
+    await expect(
+      dispatcher.query({
+        prompt: "hi",
+        model: "anthropic/claude-sonnet-4-6",
+        jsonSchema: bigSchema,
+      }),
+    ).resolves.toBeDefined();
+    expect(generate).toHaveBeenCalledOnce();
   });
 
   it("OpenAI route 도 strictify(required 유지)한다", async () => {
@@ -660,7 +900,9 @@ describe("QgridDispatcherClass", () => {
     ["anthropic", "query"],
     ["anthropic", "queryStream"],
   ] as const)(
-    "%s %s 모두 tools + jsonSchema composed outputSchema를 provider에 전달한다",
+    // openai 는 composed strict envelope 를 provider 로 보내고, anthropic 은 보내지 않는다
+    // (SON-532 — envelope 계약은 프롬프트로 안내). 응답 해석(emulation)은 양쪽 동일하다.
+    "%s %s tools + jsonSchema 경로: outputSchema 전달 계약과 envelope 해석",
     async (provider, method) => {
       const dispatcher = new QgridDispatcherClass();
       const model =
@@ -709,33 +951,37 @@ describe("QgridDispatcherClass", () => {
         );
       }
 
-      expect(request?.outputSchema).toMatchObject({
-        properties: {
-          result: {
-            anyOf: [
-              {
-                properties: {
-                  action: { enum: ["answer"] },
-                  answer: { $ref: "#/$defs/__qgrid_user_output" },
+      if (provider === "openai") {
+        expect(request?.outputSchema).toMatchObject({
+          properties: {
+            result: {
+              anyOf: [
+                {
+                  properties: {
+                    action: { enum: ["answer"] },
+                    answer: { $ref: "#/$defs/__qgrid_user_output" },
+                  },
                 },
-              },
-              {
-                properties: {
-                  action: { enum: ["tool_call"] },
-                  toolCalls: { minItems: 1 },
+                {
+                  properties: {
+                    action: { enum: ["tool_call"] },
+                    toolCalls: { minItems: 1 },
+                  },
                 },
-              },
-            ],
+              ],
+            },
           },
-        },
-        $defs: {
-          __qgrid_user_output: {
-            type: "object",
-            required: ["result"],
-            additionalProperties: false,
+          $defs: {
+            __qgrid_user_output: {
+              type: "object",
+              required: ["result"],
+              additionalProperties: false,
+            },
           },
-        },
-      });
+        });
+      } else {
+        expect(request?.outputSchema).toBeUndefined();
+      }
       expect(mappedText).toBe('{"payload":"ok"}');
     },
   );

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

@@ -9,15 +9,16 @@
 
 import { InternalServerErrorException, ServiceUnavailableException } from "sonamu";
 
-import { type JsonValue } from "../../codex-protocol/serde_json/JsonValue";
 import { SD } from "../../i18n/sd.generated";
 import { type AnthropicDispatcher } from "../../utils/providers/anthropic/anthropic-dispatcher";
+import { createFenceStripTransform } from "../../utils/providers/anthropic/fence-strip";
 import { getAccessToken } from "../../utils/providers/common/credentials";
 import { calculateCostUsd } from "../../utils/providers/common/model-cost";
 import {
   type GenerateResult,
   type StreamCallbacks,
 } from "../../utils/providers/common/provider-dispatcher";
+import { type JsonValue } from "../../utils/providers/common/provider-types";
 import {
   parseAndValidateCallerSchemas,
   serializeAndValidateDispatchSchema,
@@ -34,6 +35,7 @@ import {
   type QueryOutput,
   type TokenStats,
 } from "./qgrid.types";
+import { composeSystemWithSchemaContract } from "./schema-prompt";
 import { type TokenSubscriber } from "./token-subscriber";
 import { applyToolCallEmulation } from "./tool-emulation";
 import { buildToolCallSchema } from "./tool-emulation-schema";
@@ -113,7 +115,10 @@ export class QgridDispatcherClass {
     if (route.provider === "openai") {
       if (!this.openaiDispatcher) throw this.notReadyError("openai");
 
-      const decision = decideConvRouting(input);
+      const decision = decideConvRouting(input, {
+        directOpenAI: true,
+        modelNamespace: `openai/${route.model}`,
+      });
       const result = await this.openaiDispatcher.generate({
         model: route.model,
         systemPrompt: input.system,
@@ -122,10 +127,11 @@ export class QgridDispatcherClass {
         verbosity: input.verbosity,
         reasoningSummary: input.reasoningSummary,
         serviceTier: input.serviceTier,
+        timeoutMs: input.timeout,
         coldInput: decision.coldInput,
         coldHistory: decision.coldHistory,
-        reuse: decision.reuse,
-        reuseInput: decision.reuseInput,
+        promptCacheKey: input.imageGeneration ? undefined : decision.promptCacheKey,
+        preferredTokenId: input.imageGeneration ? undefined : decision.preferredTokenId,
         abortSignal,
         imageGeneration: input.imageGeneration,
         imageGenerationOptions: input.imageGenerationOptions,
@@ -135,7 +141,7 @@ export class QgridDispatcherClass {
       // sessionKey 소비자의 warm 좌표를 죽은 좌표로 덮어써 다음 텍스트 turn 이 cold 로 떨어진다.
       const coord = input.imageGeneration
         ? undefined
-        : issueConvContext(result.threadCoord, decision);
+        : issueConvContext(result.threadCoord, decision, result.threadCoord.workerId);
 
       return applyToolCallEmulation(toEmulationResult(result), input.tools, {
         threadCoord: coord,
@@ -149,8 +155,10 @@ export class QgridDispatcherClass {
       const result = await this.anthropicDispatcher.generate({
         // AnthropicDispatcher 내부에서 알아서 provider prefix 를 canonical model 로 정규화함
         model: input.model,
-        systemPrompt: input.system,
-        outputSchema,
+        // 스키마/envelope 계약은 --json-schema 대신 system 말미의 텍스트로 안내한다(SON-532).
+        // outputSchema 는 전달하지 않는다 — anthropic 에서 항상 undefined(U1)이며,
+        // CC 로 가는 --json-schema 채널 자체가 닫혀 있음을 여기서 명시한다.
+        systemPrompt: composeSystemWithSchemaContract(input.system, input),
         effort: input.effort,
         timeoutMs: input.timeout,
         abortSignal,
@@ -182,7 +190,10 @@ export class QgridDispatcherClass {
     if (route.provider === "openai") {
       if (!this.openaiDispatcher) throw this.notReadyError("openai");
 
-      const decision = decideConvRouting(input);
+      const decision = decideConvRouting(input, {
+        directOpenAI: true,
+        modelNamespace: `openai/${route.model}`,
+      });
       await this.openaiDispatcher.generateStream(
         {
           model: route.model,
@@ -192,10 +203,11 @@ export class QgridDispatcherClass {
           verbosity: input.verbosity,
           reasoningSummary: input.reasoningSummary,
           serviceTier: input.serviceTier,
+          timeoutMs: input.timeout,
           coldInput: decision.coldInput,
           coldHistory: decision.coldHistory,
-          reuse: decision.reuse,
-          reuseInput: decision.reuseInput,
+          promptCacheKey: decision.promptCacheKey,
+          preferredTokenId: decision.preferredTokenId,
           abortSignal,
           // 이미지 플래그를 전달해야 generateStream 의 non-stream 전용 거부(R2)가 발동한다.
           imageGeneration: input.imageGeneration,
@@ -208,7 +220,11 @@ export class QgridDispatcherClass {
           onComplete: (turnResult) => {
             cb.onComplete(
               applyToolCallEmulation(toEmulationResult(turnResult), input.tools, {
-                threadCoord: issueConvContext(turnResult.threadCoord, decision),
+                threadCoord: issueConvContext(
+                  turnResult.threadCoord,
+                  decision,
+                  turnResult.threadCoord.workerId,
+                ),
                 answerKind,
               }),
             );
@@ -220,12 +236,24 @@ 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
+        ? (text: string) => {
+            const safe = fenceStrip.push(text);
+            if (safe) cb.onDelta(safe);
+          }
+        : cb.onDelta;
+
       const decision = decideConvRouting(input);
       await this.anthropicDispatcher.generateStream(
         {
           model: input.model,
-          systemPrompt: input.system,
-          outputSchema,
+          // 스키마/envelope 계약은 --json-schema 대신 system 말미의 텍스트로 안내한다(SON-532)
+          systemPrompt: composeSystemWithSchemaContract(input.system, input),
           effort: input.effort,
           coldInput: decision.coldInput,
           coldHistory: decision.coldHistory,
@@ -235,9 +263,14 @@ export class QgridDispatcherClass {
           imageGenerationOptions: input.imageGenerationOptions,
         },
         {
-          onDelta: cb.onDelta,
+          onDelta: emitDelta,
           onThreadId: cb.onThreadId,
           onComplete: (turnResult) => {
+            // 홀드백 잔여(닫는 펜스가 아니었던 tail)를 done 전에 마저 방출한다 —
+            // 델타를 조립하는 클라이언트(EnvelopeStreamParser 등)의 무손실 보장.
+            const rest = fenceStrip?.flush();
+            if (rest) cb.onDelta(rest);
+
             const issuedCoord = issueConvContext(turnResult.threadCoord, decision);
             cb.onComplete(
               applyToolCallEmulation(toEmulationResult(turnResult), input.tools, {
@@ -294,6 +327,16 @@ 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 를 조기에 돌려준다.
+  if (provider === "anthropic") {
+    parseAndValidateCallerSchemas(input);
+    return undefined;
+  }
+
   const outputSchema = buildStrictOutputSchema(input, provider);
   serializeAndValidateDispatchSchema(outputSchema, provider);
   return outputSchema;
@@ -326,6 +369,7 @@ function toEmulationResult(
     usage: {
       input_tokens: result.usage.inputTokens,
       output_tokens: result.usage.outputTokens,
+      reasoning_tokens: result.usage.reasoningOutputTokens,
       cache_creation_input_tokens: result.usage.cacheCreationInputTokens ?? 0,
       cache_creation_5m_input_tokens: result.usage.cacheCreationInputTokens5m,
       cache_creation_1h_input_tokens: result.usage.cacheCreationInputTokens1h,