@cartanova/qgrid-cli 2.3.2 → 2.3.4

package/bundle/src/utils/providers/anthropic/claude-session.ts

@@ -1,27 +1,21 @@
 /**
  * claude-session — Claude CLI 세션 spawn + QgridThreadCoord 매핑 + per-session 락.
  *
- * 멀티턴: 첫 호출 `--session-id <uuid>`, 후속 `--resume <uuid>`. 입력은 U2 어댑터가 만든
- * JSONL 을 stdin 으로 흘리고(`--input-format stream-json`), 출력은 U3 파서로 처리한다.
+ * 멀티턴: 매 호출 fresh `--session-id <uuid>`로 실행한다. 입력은 어댑터가 만든 JSONL 을
+ * stdin 으로 흘리고(`--input-format stream-json`), 출력은 파서로 처리한다.
  *
  * 핵심 계약:
  *  - coord 는 임의 저장이 아니라 기존 QgridThreadCoord{workerId,threadId,epoch,systemHash} 에
  *    매핑한다. threadId=세션 uuid, epoch=0 고정(worker restart 개념 없음), workerId=token 기반
  *    안정 합성, systemHash=요청 system 해시. issueConvContext/decideConvRouting 과 round-trip.
- *  - resume eligibility 는 systemHash 만으로 부족 → 확장 호환키(system+model+structured 모드)로
- *    판정. 불일치면 cold fallback.
- *  - 같은 세션의 동시 turn 은 per-session 락(session-id 단위 직렬화)으로 transcript 오염 방지.
+ *  - withSessionLock 은 exported primitive 로 유지한다. 기본 경로에서는 매 호출 새 session-id 라
+ *    사실상 no-contention 이지만, 직접 호출자/테스트의 직렬화 보장은 보존한다.
  *  - stream-json 직렬화 시 SDK envelope(uuid/session_id/parent_tool_use_id) decorate.
  *  - structured output 일 때 출력 파서에 { structuredOutput: true } 전달(없으면 streamObject 깨짐).
- *
- * ⚠️ 첫 호출 동시성: resume 가 아닌 "첫 호출"은 여기서 새 랜덤 session-id 를 발급하므로, 같은
- *    qgrid sessionKey 에 대한 두 동시 첫 호출은 서로 다른 id 로 둘 다 실행된다. 현재 IF/owner scope 는
- *    LLM 호출을 순차 실행하고 sessionKey 를 서버로 보내지 않으므로, dispatcher 는 cold 락을 두지 않는다.
- *    병렬 첫 호출을 서버가 지원하게 되면 sessionKey 전달/락 설계부터 다시 잡아야 한다.
  */
 
 import { spawn } from "node:child_process";
-import { createHash, randomUUID } from "node:crypto";
+import { randomUUID } from "node:crypto";
 import { mkdirSync, writeFileSync } from "node:fs";
 
 import { type JsonValue } from "../../../codex-protocol/serde_json/JsonValue";
@@ -32,7 +26,10 @@ import {
   anthropicConfigDir,
   ANTHROPIC_DEFAULT_EFFORT,
   ANTHROPIC_DISALLOWED_TOOLS,
+  assertSupportedOneMillionSuffix,
   canonicalAnthropicModel,
+  needsCli1mSuffix,
+  supports1MContext,
 } from "./anthropic-constants";
 import {
   buildStreamJsonInput,
@@ -42,26 +39,10 @@ import {
   handleStreamJsonLine,
 } from "./stream-json-adapter";
 
-// ── 호환키 ──────────────────────────────────────────────────────────
-
-// resume 가능 여부를 가르는 키. systemHash 만으로는 같은 sessionKey 를 다른 model/schema 로
-// 재사용할 때 context 오염 → system + model + structured 모드까지 묶는다.
-export function compatibilityKey(opts: {
-  system?: string;
-  model: string;
-  // structured output schema 문자열. 없으면 text 모드. 내용이 다르면 다른 키.
-  outputSchema?: string;
-}): string {
-  const schemaPart = opts.outputSchema && opts.outputSchema.length > 0 ? opts.outputSchema : "text";
-  return createHash("sha256")
-    .update(`${opts.system ?? ""}\0${opts.model}\0${schemaPart}`)
-    .digest("hex")
-    .slice(0, 16);
-}
-
 // ── per-session 락 ─────────────────────────────────────────────────
 
-// session-id 단위 직렬화. 같은 세션의 동시 turn 이 같은 transcript 에 동시 resume·append 하는 것 방지.
+// session-id 단위 직렬화 primitive. 기본 경로에서는 매 호출 새 uuid 라 사실상 no-op 이지만,
+// 같은 session-id 를 직접 쓰는 호출자는 여전히 직렬화 보장을 받는다.
 const sessionChains = new Map<string, Promise<unknown>>();
 
 export async function withSessionLock<T>(sessionId: string, fn: () => Promise<T>): Promise<T> {
@@ -93,7 +74,10 @@ export function makeAnthropicWorkerId(tokenId: number): number {
 // ── envelope decorate ──────────────────────────────────────────────
 
 // stream-json 입력 라인에 SDK envelope 부착 후 직렬화. session 소유자인 여기서 한다.
-export function decorateAndSerialize(lines: Array<ClaudeStreamJsonLine>, sessionId: string): string {
+export function decorateAndSerialize(
+  lines: Array<ClaudeStreamJsonLine>,
+  sessionId: string,
+): string {
   return (
     lines
       .map((line) =>
@@ -118,12 +102,10 @@ export interface ClaudeSessionRequest {
   jsonSchema?: string; // 있으면 structured output
   effort?: string;
   timeoutMs: number;
-  // 입력: cold(coldHistory+coldInput) 또는 resume(reuseInput).
   coldHistory?: Array<JsonValue>;
   input: Array<UserInput>;
-  // resume 경로면 기존 session-id, cold 면 undefined(새로 발급).
-  resumeSessionId?: string;
   abortSignal?: AbortSignal;
+  includePartialMessages?: boolean;
 }
 
 export interface ClaudeSessionResult extends ClaudeStreamResult {
@@ -152,13 +134,36 @@ function ensureCwd(): void {
 }
 
 // spawn args 구성. 멀티턴/격리/structured 모드 반영.
+export function applyOneMillionSuffix(model: string, needsSuffix: boolean): string {
+  const base = canonicalAnthropicModel(model);
+  return needsSuffix ? `${base}[1m]` : base;
+}
+
+export function oneMillionEnv(supported: boolean): { CLAUDE_CODE_DISABLE_1M_CONTEXT?: "1" } {
+  return supported ? {} : { CLAUDE_CODE_DISABLE_1M_CONTEXT: "1" };
+}
+
+// SON-495: structured output retry 를 1 로 고정한다. CC 가 attempt 를 reject 하고 retry 하면
+// `{rejected}{accepted}` 누적이 AI-SDK 의 JSON.parse 를 깨뜨리므로, retry 자체를 막아 그 경로를
+// 원천 차단한다. `0` 은 CC query loop(`callsThisQuery >= maxRetries`)가 첫 attempt emit 전에
+// 실패시키므로(`error_max_structured_output_retries`) 외부 값이 1 미만이어도 1 로 클램프한다.
+export function structuredOutputRetriesEnv(raw = process.env.MAX_STRUCTURED_OUTPUT_RETRIES): {
+  MAX_STRUCTURED_OUTPUT_RETRIES: string;
+} {
+  if (!raw) return { MAX_STRUCTURED_OUTPUT_RETRIES: "1" };
+  const parsed = Number.parseInt(raw, 10);
+  if (!Number.isFinite(parsed)) return { MAX_STRUCTURED_OUTPUT_RETRIES: "1" };
+  return { MAX_STRUCTURED_OUTPUT_RETRIES: String(Math.max(parsed, 1)) };
+}
+
 export function buildClaudeArgs(opts: {
   model: string;
   system?: string;
   effort?: string;
   jsonSchema?: string;
   sessionId: string;
-  isResume: boolean;
+  needsOneMillionSuffix?: boolean;
+  includePartialMessages?: boolean;
 }): Array<string> {
   const useStructured = Boolean(opts.jsonSchema && opts.jsonSchema.length > 0);
   // --tools "" 로 전체 차단, structured(jsonSchema 있음) 면 StructuredOutput 만 허용.
@@ -176,14 +181,13 @@ export function buildClaudeArgs(opts: {
     "--output-format",
     "stream-json",
     "--verbose",
-    "--max-turns",
-    useStructured ? "2" : "1",
+    ...(opts.includePartialMessages ? ["--include-partial-messages"] : []),
     "--permission-mode",
     "bypassPermissions",
     "--setting-sources",
     "project",
     "--model",
-    opts.model,
+    applyOneMillionSuffix(opts.model, opts.needsOneMillionSuffix ?? false),
     // inline [System] 금지 — 정식 채널만(R7). 생략 시 CC default(23k) 주입되므로 반드시 명시.
     "--system-prompt",
     opts.system ?? "",
@@ -192,8 +196,8 @@ export function buildClaudeArgs(opts: {
     "--effort",
     opts.effort ?? ANTHROPIC_DEFAULT_EFFORT,
     "--disable-slash-commands",
-    // 멀티턴: 첫 호출은 session-id 발급, 후속은 resume. --no-session-persistence 는 쓰지 않는다.
-    ...(opts.isResume ? ["--resume", opts.sessionId] : ["--session-id", opts.sessionId]),
+    "--session-id",
+    opts.sessionId,
   ];
   if (useStructured) args.push("--json-schema", opts.jsonSchema!);
   return args;
@@ -209,9 +213,11 @@ export function runClaudeSession(
 ): Promise<ClaudeSessionResult> {
   // 정규화 규칙은 canonicalAnthropicModel 이 단독 소유 — dispatcher 가 이미 canonical 을 넘기지만,
   // 직접 호출(테스트/미래 caller) 대비 방어적으로 한 번 더 통과시킨다(이미 canonical 이면 no-op).
+  assertSupportedOneMillionSuffix(req.model);
   const model = canonicalAnthropicModel(req.model);
-  const isResume = Boolean(req.resumeSessionId);
-  const sessionId = req.resumeSessionId ?? randomUUID();
+  const supportsOneMillion = supports1MContext(model);
+  const needsOneMillionSuffix = needsCli1mSuffix(model);
+  const sessionId = randomUUID();
   const useStructured = Boolean(req.jsonSchema && req.jsonSchema.length > 0);
   const workerId = makeAnthropicWorkerId(req.tokenId);
 
@@ -225,17 +231,22 @@ export function runClaudeSession(
       effort: req.effort,
       jsonSchema: req.jsonSchema,
       sessionId,
-      isResume,
+      needsOneMillionSuffix,
+      includePartialMessages: req.includePartialMessages,
     });
 
     const inputLines = buildStreamJsonInput({
       coldHistory: req.coldHistory,
       input: req.input,
-      isResume,
     });
     const stdinPayload = decorateAndSerialize(inputLines, sessionId);
 
     return new Promise<ClaudeSessionResult>((resolve, reject) => {
+      if (req.abortSignal?.aborted) {
+        reject(new Error("aborted"));
+        return;
+      }
+
       const child = spawn("claude", args, {
         // stderr 도 캡처: invalid OAuth / 잘못된 플래그 / CLI 검증 실패가
         // "closed without result" 로 뭉개지지 않게 close/error 에 stderr 를 실어 보낸다.
@@ -248,9 +259,15 @@ export function runClaudeSession(
           CLAUDE_CONFIG_DIR: configDir,
           CLAUDE_CODE_DISABLE_AUTO_MEMORY: "1",
           CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING: "1",
-          CLAUDE_CODE_DISABLE_1M_CONTEXT: "1",
+          ...oneMillionEnv(supportsOneMillion),
           CLAUDE_CODE_DISABLE_CLAUDE_MDS: "1",
+          CLAUDE_CODE_DISABLE_TERMINAL_TITLE: "1",
+          CLAUDE_CODE_DISABLE_BUNDLED_SKILLS: "1",
+          CLAUDE_CODE_DISABLE_WORKFLOWS: "1",
           CLAUDE_CODE_ATTRIBUTION_HEADER: "0",
+          MAX_THINKING_TOKENS: "0",
+          // structured output 일 때만 retry 를 고정한다(SON-495). text 모드는 영향 없음.
+          ...(useStructured ? structuredOutputRetriesEnv() : {}),
         },
       });
 
@@ -264,9 +281,11 @@ export function runClaudeSession(
         stderrBuf = (stderrBuf + d.toString()).slice(-STDERR_CAP);
       });
       const stderrSuffix = () => (stderrBuf.trim() ? ` — stderr: ${stderrBuf.trim()}` : "");
+      let cleanupAbort: (() => void) | undefined;
       const timer = setTimeout(() => {
         if (settled) return;
         settled = true;
+        cleanupAbort?.();
         child.kill();
         reject(new Error(`Claude session timeout after ${req.timeoutMs / 1000}s`));
       }, req.timeoutMs);
@@ -275,16 +294,20 @@ export function runClaudeSession(
         if (settled) return;
         settled = true;
         clearTimeout(timer);
+        cleanupAbort?.();
         resolve({ ...result, sessionId, workerId });
       };
 
-      req.abortSignal?.addEventListener("abort", () => {
+      const onAbort = () => {
         if (settled) return;
         settled = true;
         clearTimeout(timer);
+        cleanupAbort?.();
         child.kill();
         reject(new Error("aborted"));
-      });
+      };
+      cleanupAbort = () => req.abortSignal?.removeEventListener("abort", onAbort);
+      req.abortSignal?.addEventListener("abort", onAbort, { once: true });
 
       child.stdout?.on("data", (d: Buffer) => {
         if (settled) return;
@@ -307,12 +330,14 @@ export function runClaudeSession(
         if (settled) return;
         settled = true;
         clearTimeout(timer);
+        cleanupAbort?.();
         reject(new Error(`Claude session closed without result${stderrSuffix()}`));
       });
       child.on("error", (err) => {
         if (settled) return;
         settled = true;
         clearTimeout(timer);
+        cleanupAbort?.();
         reject(new Error(`Claude session spawn error: ${err.message}`));
       });
 

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

@@ -21,7 +21,7 @@ function userLineCount(lines: Array<ClaudeStreamJsonLine>): number {
 
 describe("buildStreamJsonInput", () => {
   it("happy: 단일 user input → user 1줄", () => {
-    const lines = buildStreamJsonInput({ input: userText("안녕"), isResume: false });
+    const lines = buildStreamJsonInput({ input: userText("안녕") });
     expect(lines).toHaveLength(1);
     expect(userLineCount(lines)).toBe(1);
     expect(lines[0]).toEqual({
@@ -42,7 +42,6 @@ describe("buildStreamJsonInput", () => {
     const lines = buildStreamJsonInput({
       coldHistory,
       input: userText("비밀번호 뭐였지?"),
-      isResume: false,
     });
     // assistant context 1줄 + 실행 user 1줄
     expect(lines).toHaveLength(2);
@@ -57,28 +56,8 @@ describe("buildStreamJsonInput", () => {
     });
   });
 
-  it("resume: reuseInput(delta) user 1줄만, history 미포함", () => {
-    const lines = buildStreamJsonInput({
-      coldHistory: [
-        {
-          type: "message",
-          role: "assistant",
-          content: [{ type: "output_text", text: "이전 답변" }],
-        },
-      ],
-      input: userText("다음 질문"),
-      isResume: true,
-    });
-    expect(lines).toHaveLength(1);
-    expect(userLineCount(lines)).toBe(1);
-    expect(lines[0]).toEqual({
-      type: "user",
-      message: { role: "user", content: [{ type: "text", text: "다음 질문" }] },
-    });
-  });
-
   it("정규화: content 는 항상 block 배열 (KTD5 구현계약)", () => {
-    const lines = buildStreamJsonInput({ input: userText("x"), isResume: false });
+    const lines = buildStreamJsonInput({ input: userText("x") });
     expect(Array.isArray(lines[0]!.message.content)).toBe(true);
     expect(lines[0]!.message.content[0]).toHaveProperty("type", "text");
   });
@@ -91,7 +70,6 @@ describe("buildStreamJsonInput", () => {
     const lines = buildStreamJsonInput({
       coldHistory,
       input: userText("결과는?"),
-      isResume: false,
     });
     // assistant context 1줄 + 실행 user 1줄
     expect(lines).toHaveLength(2);
@@ -110,7 +88,6 @@ describe("buildStreamJsonInput", () => {
     const lines = buildStreamJsonInput({
       coldHistory: [],
       input: userText("단발"),
-      isResume: false,
     });
     expect(lines).toHaveLength(1);
     expect(lines[0]!.type).toBe("user");
@@ -122,7 +99,7 @@ describe("buildStreamJsonInput", () => {
       { type: "message", role: "assistant", content: [{ type: "output_text", text: "a1" }] },
       { type: "message", role: "assistant", content: [{ type: "output_text", text: "a2" }] },
     ];
-    const lines = buildStreamJsonInput({ coldHistory, input: userText("q"), isResume: false });
+    const lines = buildStreamJsonInput({ coldHistory, input: userText("q") });
     expect(lines).toHaveLength(2);
     expect(userLineCount(lines)).toBe(1);
     expect(lines[0]!.type).toBe("assistant");
@@ -137,7 +114,7 @@ describe("buildStreamJsonInput", () => {
       { type: "message", role: "user", content: [{ type: "input_text", text: "u2" }] },
       { type: "function_call_output", call_id: "x", output: "out" },
     ];
-    const lines = buildStreamJsonInput({ coldHistory, input: userText("final"), isResume: false });
+    const lines = buildStreamJsonInput({ coldHistory, input: userText("final") });
     expect(userLineCount(lines)).toBe(1);
     expect(lines[lines.length - 1]!.message.content[0]!.text).toBe("final");
   });
@@ -145,7 +122,7 @@ describe("buildStreamJsonInput", () => {
 
 describe("serializeStreamJsonInput", () => {
   it("JSONL 한 줄당 하나 + 마지막 개행", () => {
-    const lines = buildStreamJsonInput({ input: userText("hi"), isResume: false });
+    const lines = buildStreamJsonInput({ input: userText("hi") });
     const out = serializeStreamJsonInput(lines);
     expect(out.endsWith("\n")).toBe(true);
     const parsed = out
@@ -230,7 +207,7 @@ describe("handleStreamJsonLine (출력 어댑터)", () => {
     expect(deltas).not.toContain(" (thinking)");
   });
 
-  it("structured tool-call: 첫 StructuredOutput을 보존하고 max_turns result를 성공 처리", () => {
+  it("structured tool-call: 첫 StructuredOutput은 보존하되 max_turns result는 error 유지", () => {
     const first = {
       action: "tool_call",
       answer: null,
@@ -249,6 +226,18 @@ describe("handleStreamJsonLine (출력 어댑터)", () => {
             content: [{ type: "tool_use", name: "StructuredOutput", input: first }],
           },
         }),
+        JSON.stringify({
+          type: "user",
+          message: {
+            content: [
+              {
+                type: "tool_result",
+                is_error: true,
+                content: "Output does not match required schema",
+              },
+            ],
+          },
+        }),
         JSON.stringify({
           type: "assistant",
           message: {
@@ -269,13 +258,68 @@ describe("handleStreamJsonLine (출력 어댑터)", () => {
     );
 
     expect(JSON.parse(result!.text)).toEqual(first);
-    expect(result!.isError).toBe(false);
+    expect(result!.isError).toBe(true);
     expect(result!.usage.inputTokens).toBe(30);
     expect(result!.usage.outputTokens).toBe(30);
     expect(result!.durationMs).toBe(1234);
     expect(result!.costUsd).toBe(0.0042);
   });
 
+  // SON-495: error_max_structured_output_retries 는 모델이 schema 를 못 맞춘 비정상 종료다.
+  // CC structured output 은 constrained decoding 이 아니라 사후 AJV 검증이라, 모델이 가끔
+  // placeholder($PARAMETER_NAME)·거부("just kidding")·필드 누락 같은 발작/불완전 출력을 낸다.
+  // 이를 "거의 맞았으니 살리자"고 흘리면 클라이언트 검증이 깨지거나 쓰레기가 샌다(실측 11674/11675).
+  // 그래서 보존 출력 유무·내용과 무관하게 항상 에러로 처리한다(알려진 best practice: refusal/degenerate
+  // output 은 graceful error). 보존 출력은 진단용 text 로는 남기되 isError 는 true.
+  it("error_max_structured_output_retries: 보존 출력이 valid JSON 이어도 에러로 처리", () => {
+    const attempt = {
+      scenes: [{ visual: { backgroundId: "IL-LOC-02" }, contents: [], advance: "choice" }],
+    };
+    const { result } = runLines(
+      [
+        JSON.stringify({
+          type: "assistant",
+          message: { content: [{ type: "tool_use", name: "StructuredOutput", input: attempt }] },
+        }),
+        JSON.stringify({
+          type: "result",
+          subtype: "error_max_structured_output_retries",
+          is_error: true,
+          usage: { input_tokens: 10, output_tokens: 20 },
+          duration_ms: 100,
+          total_cost_usd: 0.001,
+        }),
+      ],
+      { structuredOutput: true },
+    );
+
+    expect(result!.isError).toBe(true);
+    expect(result!.subtype).toBe("error_max_structured_output_retries");
+  });
+
+  it("error_max_structured_output_retries: placeholder 쓰레기 출력도 에러로 처리", () => {
+    const garbage = { $PARAMETER_NAME: "" };
+    const { result } = runLines(
+      [
+        JSON.stringify({
+          type: "assistant",
+          message: { content: [{ type: "tool_use", name: "StructuredOutput", input: garbage }] },
+        }),
+        JSON.stringify({
+          type: "result",
+          subtype: "error_max_structured_output_retries",
+          is_error: true,
+          usage: { input_tokens: 10, output_tokens: 0 },
+          duration_ms: 100,
+          total_cost_usd: 0.001,
+        }),
+      ],
+      { structuredOutput: true },
+    );
+
+    expect(result!.isError).toBe(true);
+  });
+
   it("text 모드: partial_json 이 와도 무시, text_delta 만", () => {
     const { deltas } = runLines(
       [