@cartanova/qgrid-cli 2.3.2 → 2.3.4

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

@@ -4,20 +4,17 @@ import { type AnthropicCredentials } from "../../../application/token/token.type
 import { type GenerateRequest } from "../common/provider-dispatcher";
 import { ANTHROPIC_DEFAULT_MODEL } from "./anthropic-constants";
 import { AnthropicDispatcher } from "./anthropic-dispatcher";
-import { withSessionLock } from "./claude-session";
 
-// runClaudeSession 은 실제 claude 프로세스를 spawn 하므로 모킹.
-// compatibilityKey / makeAnthropicWorkerId / withSessionLock 은 순수 함수라 실제 구현 사용.
-// vi.hoisted 로 mock fn 을 호이스트해 vi.mock 팩토리에서 참조한다.
 const { runClaudeSessionMock, refreshTokenMock } = vi.hoisted(() => ({
   runClaudeSessionMock: vi.fn(),
   refreshTokenMock: vi.fn(),
 }));
+
 vi.mock("./claude-session", async (importActual) => {
   const actual = await importActual<typeof import("./claude-session")>();
   return { ...actual, runClaudeSession: runClaudeSessionMock };
 });
-// run() 이 동적 import 하는 QgridFrame.refreshToken 을 모킹(만료 임박 토큰 preemptive refresh 경로).
+
 vi.mock("../../../application/qgrid/qgrid.frame", () => ({
   QgridFrame: { refreshToken: refreshTokenMock },
 }));
@@ -75,211 +72,77 @@ describe("AnthropicDispatcher", () => {
   it("happy: generate → GenerateResult (threadCoord 조립, systemHash 없음)", async () => {
     const d = new AnthropicDispatcher();
     d.onTokenAdded(1, "tok-A", creds());
+
     const result = await d.generate(baseReq());
+
     expect(result.text).toBe("hello");
     expect(result.tokenName).toBe("tok-A");
     expect(result.model).toBe("claude-sonnet-4-6");
-    // threadCoord: threadId=session-id, epoch=0, workerId=tokenId
     expect(result.threadCoord).toEqual({ workerId: 1, threadId: "sess-generated", epoch: 0 });
   });
 
-  it("cold 호출: resumeSessionId 없음, coldInput/coldHistory 전달", async () => {
+  it("cold 호출: coldInput/coldHistory 를 그대로 전달하고 continuation session id 는 없다", async () => {
     const d = new AnthropicDispatcher();
     d.onTokenAdded(1, "tok-A", creds());
+
     await d.generate(
       baseReq({ coldHistory: [{ type: "message", role: "assistant", content: [] }] }),
     );
+
     const call = runClaudeSessionMock.mock.calls[0]![0];
-    expect(call.resumeSessionId).toBeUndefined();
+    expect(call).not.toHaveProperty("resumeSessionId");
     expect(call.coldHistory).toBeDefined();
     expect(call.input).toEqual([{ type: "text", text: "hi", text_elements: [] }]);
   });
 
-  it("resume eligible: 같은 호환키의 reuse.threadId → resume (reuseInput, history 미전달)", async () => {
+  it("reuse/reuseInput 이 실려 와도 무시하고 coldInput/coldHistory 로 실행한다", async () => {
     const d = new AnthropicDispatcher();
     d.onTokenAdded(1, "tok-A", creds());
-    // 1st 호출: session "S1" 발급 + 호환키 저장
-    runClaudeSessionMock.mockResolvedValueOnce(sessionResult({ sessionId: "S1" }));
-    const first = await d.generate(baseReq());
-    expect(first.threadCoord.threadId).toBe("S1");
 
-    // 2nd 호출: 같은 system/model 로 reuse.threadId=S1 → eligible
-    runClaudeSessionMock.mockResolvedValueOnce(sessionResult({ sessionId: "S1" }));
     await d.generate(
       baseReq({
+        coldHistory: [{ type: "message", role: "assistant", content: [] }],
         reuse: { workerId: 1, threadId: "S1", epoch: 0 },
         reuseInput: [{ type: "text", text: "delta", text_elements: [] }],
       }),
     );
-    const call2 = runClaudeSessionMock.mock.calls[1]![0];
-    expect(call2.resumeSessionId).toBe("S1");
-    expect(call2.coldHistory).toBeUndefined(); // resume 이면 history 미전달
-    expect(call2.input).toEqual([{ type: "text", text: "delta", text_elements: [] }]);
-  });
-
-  it("resume 토큰 소유권 고정: 다른 토큰이 idle 이어도 세션을 만든 토큰으로 resume (codex P0)", async () => {
-    const d = new AnthropicDispatcher();
-    d.onTokenAdded(1, "tok-A", creds());
-    d.onTokenAdded(2, "tok-B", creds());
-
-    // 1st cold: RR 로 tok-A(id 1) 가 뽑히도록 — 첫 호출은 rrIndex=0 → idle[0]=id1.
-    runClaudeSessionMock.mockResolvedValueOnce(sessionResult({ sessionId: "S1", workerId: 1 }));
-    const first = await d.generate(baseReq());
-    expect(first.threadCoord.workerId).toBe(1); // tok-A 가 S1 소유
-
-    // 이제 tok-A 는 count=1, tok-B 는 count=0 → least-used RR 이면 tok-B 를 고를 차례.
-    // 하지만 reuse.threadId=S1 의 소유 토큰은 tok-A 이므로 반드시 tok-A 로 resume 해야 한다.
-    runClaudeSessionMock.mockResolvedValueOnce(sessionResult({ sessionId: "S1", workerId: 1 }));
-    const second = await d.generate(
-      baseReq({
-        reuse: { workerId: 1, threadId: "S1", epoch: 0 },
-        reuseInput: [{ type: "text", text: "delta", text_elements: [] }],
-      }),
-    );
-    const call2 = runClaudeSessionMock.mock.calls[1]![0];
-    expect(call2.tokenId).toBe(1); // RR 로 tok-B(2) 가 아니라 소유 토큰 tok-A(1)
-    expect(call2.resumeSessionId).toBe("S1");
-    expect(second.tokenName).toBe("tok-A");
-  });
-
-  it("resume 소유권 불일치: stored.tokenId != reuse.workerId → resume 불가, cold (codex P0)", async () => {
-    const d = new AnthropicDispatcher();
-    d.onTokenAdded(1, "tok-A", creds());
-    d.onTokenAdded(2, "tok-B", creds());
-    runClaudeSessionMock.mockResolvedValueOnce(sessionResult({ sessionId: "S1", workerId: 1 }));
-    await d.generate(baseReq()); // tok-A(1) 가 S1 소유
 
-    // reuse.threadId=S1 은 맞지만 workerId 를 2 로 위조 → 소유권 불일치 → cold fallback.
-    runClaudeSessionMock.mockResolvedValueOnce(sessionResult({ sessionId: "S2" }));
-    await d.generate(
-      baseReq({
-        reuse: { workerId: 2, threadId: "S1", epoch: 0 },
-        reuseInput: [{ type: "text", text: "x", text_elements: [] }],
-      }),
-    );
-    const call2 = runClaudeSessionMock.mock.calls[1]![0];
-    expect(call2.resumeSessionId).toBeUndefined(); // 소유권 불일치라 cold
+    const call = runClaudeSessionMock.mock.calls[0]![0];
+    expect(call).not.toHaveProperty("resumeSessionId");
+    expect(call.coldHistory).toBeDefined();
+    expect(call.input).toEqual([{ type: "text", text: "hi", text_elements: [] }]);
   });
 
-  it("resume ineligible: 다른 model 이면 호환키 불일치 → cold (새 session)", async () => {
+  it("structured(outputSchema): jsonSchema 로 직렬화되어 전달", async () => {
     const d = new AnthropicDispatcher();
     d.onTokenAdded(1, "tok-A", creds());
-    runClaudeSessionMock.mockResolvedValueOnce(sessionResult({ sessionId: "S1" }));
-    await d.generate(baseReq()); // model sonnet 으로 S1 발급
+    await d.generate(baseReq({ outputSchema: { type: "object", properties: {} } }));
 
-    // reuse.threadId=S1 이지만 model 이 다름 → 호환키 불일치 → cold
-    runClaudeSessionMock.mockResolvedValueOnce(sessionResult({ sessionId: "S2" }));
-    await d.generate(
-      baseReq({
-        model: "claude-opus-4-8",
-        reuse: { workerId: 1, threadId: "S1", epoch: 0 },
-        reuseInput: [{ type: "text", text: "x", text_elements: [] }],
-      }),
-    );
-    const call2 = runClaudeSessionMock.mock.calls[1]![0];
-    expect(call2.resumeSessionId).toBeUndefined(); // cold fallback (P1-5 오염 방지)
+    const call = runClaudeSessionMock.mock.calls[0]![0];
+    expect(call.jsonSchema).toBe(JSON.stringify({ type: "object", properties: {} }));
   });
 
-  it("resume ineligible: schema 호환키 불일치로 cold fallback 해도 continuation input 을 전달한다", async () => {
+  it("quota 소진 → 에러", async () => {
     const d = new AnthropicDispatcher();
     d.onTokenAdded(1, "tok-A", creds());
-    runClaudeSessionMock.mockResolvedValueOnce(sessionResult({ sessionId: "S1" }));
-    await d.generate(
-      baseReq({ outputSchema: { type: "object", properties: { a: { type: "string" } } } }),
-    );
-
-    runClaudeSessionMock.mockResolvedValueOnce(sessionResult({ sessionId: "S2" }));
-    await d.generate(
-      baseReq({
-        outputSchema: { type: "object", properties: { b: { type: "string" } } },
-        coldHistory: [{ type: "function_call_output", call_id: "call_1", output: "ok" }],
-        coldInput: [
-          {
-            type: "text",
-            text: "Tool result for call call_1: ok\n\nNow continue answering the user's request using these results.",
-            text_elements: [],
-          },
-        ],
-        reuse: { workerId: 1, threadId: "S1", epoch: 0 },
-        reuseInput: [
-          {
-            type: "text",
-            text: "Tool result for call call_1: ok\n\nNow continue answering the user's request using these results.",
-            text_elements: [],
-          },
-        ],
-      }),
-    );
+    runClaudeSessionMock.mockResolvedValueOnce(sessionResult({ quotaExhausted: true }));
 
-    const call2 = runClaudeSessionMock.mock.calls[1]![0];
-    expect(call2.resumeSessionId).toBeUndefined();
-    expect(call2.coldHistory).toBeDefined();
-    expect(call2.input[0]?.text).toContain("Now continue answering");
-    expect(call2.input[0]?.text).not.toBe("");
+    await expect(d.generate(baseReq())).rejects.toThrow(/quota exhausted/);
   });
 
-  it("resume transcript/session failure: 죽은 compat 삭제 후 cold 로 1회 retry 한다", async () => {
+  it("claude 에러 → 에러", async () => {
     const d = new AnthropicDispatcher();
     d.onTokenAdded(1, "tok-A", creds());
-    runClaudeSessionMock.mockResolvedValueOnce(sessionResult({ sessionId: "S1", workerId: 1 }));
-    await d.generate(baseReq());
-
-    runClaudeSessionMock
-      .mockRejectedValueOnce(
-        new Error("Claude session closed without result — stderr: failed to resume transcript"),
-      )
-      .mockResolvedValueOnce(sessionResult({ sessionId: "S2", workerId: 1 }));
-
-    const result = await d.generate(
-      baseReq({
-        coldHistory: [{ type: "function_call_output", call_id: "call_1", output: "ok" }],
-        coldInput: [
-          {
-            type: "text",
-            text: "Tool result for call call_1: ok\n\nNow continue answering the user's request using these results.",
-            text_elements: [],
-          },
-        ],
-        reuse: { workerId: 1, threadId: "S1", epoch: 0 },
-        reuseInput: [{ type: "text", text: "delta", text_elements: [] }],
-      }),
-    );
-
-    expect(result.threadCoord.threadId).toBe("S2");
-    const resumeCall = runClaudeSessionMock.mock.calls[1]![0];
-    expect(resumeCall.resumeSessionId).toBe("S1");
-    expect(resumeCall.coldHistory).toBeUndefined();
-    expect(resumeCall.input).toEqual([{ type: "text", text: "delta", text_elements: [] }]);
-
-    const retryCall = runClaudeSessionMock.mock.calls[2]![0];
-    expect(retryCall.resumeSessionId).toBeUndefined();
-    expect(retryCall.coldHistory).toBeDefined();
-    expect(retryCall.input[0]?.text).toContain("Now continue answering");
+    runClaudeSessionMock.mockResolvedValueOnce(sessionResult({ isError: true, text: "boom" }));
 
-    runClaudeSessionMock.mockResolvedValueOnce(sessionResult({ sessionId: "S3", workerId: 1 }));
-    await d.generate(
-      baseReq({
-        reuse: { workerId: 1, threadId: "S1", epoch: 0 },
-        reuseInput: [{ type: "text", text: "should not resume S1", text_elements: [] }],
-      }),
-    );
-    const postRetryCall = runClaudeSessionMock.mock.calls[3]![0];
-    expect(postRetryCall.resumeSessionId).toBeUndefined();
+    await expect(d.generate(baseReq())).rejects.toThrow(/claude error/);
   });
 
-  it.each([
-    ["timeout", "Claude session timeout after 120s"],
-    ["abort", "aborted"],
-    ["spawn", "Claude session spawn error: ENOENT"],
-    ["schema", "Claude session closed without result — stderr: schema validation failed"],
-    ["session-only", "Claude session failed before result"],
-  ])("resume %s failure 는 cold retry 하지 않는다", async (_label, message) => {
+  it("cold 실패는 resume retry 없이 그대로 전파한다", async () => {
     const d = new AnthropicDispatcher();
     d.onTokenAdded(1, "tok-A", creds());
-    runClaudeSessionMock.mockResolvedValueOnce(sessionResult({ sessionId: "S1", workerId: 1 }));
-    await d.generate(baseReq());
+    runClaudeSessionMock.mockRejectedValueOnce(new Error("closed without result"));
 
-    runClaudeSessionMock.mockRejectedValueOnce(new Error(message));
     await expect(
       d.generate(
         baseReq({
@@ -287,233 +150,103 @@ describe("AnthropicDispatcher", () => {
           reuseInput: [{ type: "text", text: "delta", text_elements: [] }],
         }),
       ),
-    ).rejects.toThrow(message);
-
-    expect(runClaudeSessionMock).toHaveBeenCalledTimes(2);
-  });
-
-  it("quota 소진 → 에러", async () => {
-    const d = new AnthropicDispatcher();
-    d.onTokenAdded(1, "tok-A", creds());
-    runClaudeSessionMock.mockResolvedValueOnce(sessionResult({ quotaExhausted: true }));
-    await expect(d.generate(baseReq())).rejects.toThrow(/quota exhausted/);
-  });
-
-  it("claude 에러 → 에러", async () => {
-    const d = new AnthropicDispatcher();
-    d.onTokenAdded(1, "tok-A", creds());
-    runClaudeSessionMock.mockResolvedValueOnce(sessionResult({ isError: true, text: "boom" }));
-    await expect(d.generate(baseReq())).rejects.toThrow(/claude error/);
-  });
-
-  it("structured(outputSchema): jsonSchema 로 직렬화되어 전달", async () => {
-    const d = new AnthropicDispatcher();
-    d.onTokenAdded(1, "tok-A", creds());
-    await d.generate(baseReq({ outputSchema: { type: "object", properties: {} } }));
-    const call = runClaudeSessionMock.mock.calls[0]![0];
-    expect(call.jsonSchema).toBe(JSON.stringify({ type: "object", properties: {} }));
+    ).rejects.toThrow("closed without result");
+    expect(runClaudeSessionMock).toHaveBeenCalledTimes(1);
   });
 
   it("least-used RR: 두 토큰 번갈아 분배", async () => {
     const d = new AnthropicDispatcher();
     d.onTokenAdded(1, "tok-A", creds());
     d.onTokenAdded(2, "tok-B", creds());
+
     const names = new Set<string>();
-    runClaudeSessionMock.mockResolvedValue(sessionResult());
     const r1 = await d.generate(baseReq());
     const r2 = await d.generate(baseReq());
     names.add(r1.tokenName);
     names.add(r2.tokenName);
-    expect(names.size).toBe(2); // 서로 다른 토큰
+
+    expect(names.size).toBe(2);
   });
 
   it("onTokenRemoved 후 그 토큰 미선택", async () => {
     const d = new AnthropicDispatcher();
     d.onTokenAdded(1, "tok-A", creds());
     d.onTokenRemoved(1);
-    await expect(d.generate(baseReq())).rejects.toThrow(/No anthropic tokens/);
-  });
-
-  it("onTokenRemoved: 그 토큰으로 만든 session compat 정리 → 이후 같은 reuse.threadId 도 cold", async () => {
-    const d = new AnthropicDispatcher();
-    d.onTokenAdded(1, "tok-A", creds());
-    runClaudeSessionMock.mockResolvedValueOnce(sessionResult({ sessionId: "S1" }));
-    await d.generate(baseReq()); // S1 발급(token 1)
 
-    // 토큰 1 제거 → S1 compat 도 정리됨. 다시 토큰 추가 후 reuse.threadId=S1 시도 → eligible 아님(cold)
-    d.onTokenRemoved(1);
-    d.onTokenAdded(1, "tok-A", creds());
-    runClaudeSessionMock.mockResolvedValueOnce(sessionResult({ sessionId: "S2" }));
-    await d.generate(
-      baseReq({
-        reuse: { workerId: 1, threadId: "S1", epoch: 0 },
-        reuseInput: [{ type: "text", text: "x", text_elements: [] }],
-      }),
-    );
-    const call2 = runClaudeSessionMock.mock.calls[1]![0];
-    expect(call2.resumeSessionId).toBeUndefined(); // compat 정리돼 cold
+    await expect(d.generate(baseReq())).rejects.toThrow(/No anthropic tokens/);
   });
 
-  it("onTokenUpdated: 같은 accountUuid 의 토큰 rotation 은 기존 session resume 유지 (codex P1)", async () => {
+  it("onTokenUpdated 는 토큰 credentials 를 in-place 갱신한다", async () => {
     const d = new AnthropicDispatcher();
     d.onTokenAdded(1, "tok-A", creds(3_600_000, "acc-1"));
-    runClaudeSessionMock.mockResolvedValueOnce(sessionResult({ sessionId: "S1", workerId: 1 }));
-    await d.generate(baseReq()); // S1 발급(token 1, acc-1)
+    d.onTokenUpdated(1, "tok-A", creds(7_200_000, "acc-2"));
 
-    // access/refresh/expiresAt 만 바뀐 rotation (accountUuid 동일) → 세션 유지.
-    d.onTokenUpdated(1, "tok-A", creds(7_200_000, "acc-1"));
-    runClaudeSessionMock.mockResolvedValueOnce(sessionResult({ sessionId: "S1", workerId: 1 }));
-    await d.generate(
-      baseReq({
-        reuse: { workerId: 1, threadId: "S1", epoch: 0 },
-        reuseInput: [{ type: "text", text: "x", text_elements: [] }],
-      }),
-    );
-    const call2 = runClaudeSessionMock.mock.calls[1]![0];
-    expect(call2.resumeSessionId).toBe("S1"); // rotation 이라 resume 유지
-  });
-
-  it("onTokenUpdated: accountUuid 변경(재로그인)이면 그 토큰 session compat 폐기 → cold (codex P1 격리)", async () => {
-    const d = new AnthropicDispatcher();
-    d.onTokenAdded(1, "tok-A", creds(3_600_000, "acc-1"));
-    runClaudeSessionMock.mockResolvedValueOnce(sessionResult({ sessionId: "S1", workerId: 1 }));
-    await d.generate(baseReq()); // S1 발급(token 1, acc-1)
+    await d.generate(baseReq());
 
-    // 다른 accountUuid 로 재로그인 → S1 은 옛 계정 세션이므로 새 계정으로 resume 하면 안 됨.
-    d.onTokenUpdated(1, "tok-A", creds(3_600_000, "acc-2"));
-    runClaudeSessionMock.mockResolvedValueOnce(sessionResult({ sessionId: "S2" }));
-    await d.generate(
-      baseReq({
-        reuse: { workerId: 1, threadId: "S1", epoch: 0 },
-        reuseInput: [{ type: "text", text: "x", text_elements: [] }],
-      }),
-    );
-    const call2 = runClaudeSessionMock.mock.calls[1]![0];
-    expect(call2.resumeSessionId).toBeUndefined(); // identity 변경으로 compat 폐기 → cold
+    const call = runClaudeSessionMock.mock.calls[0]![0];
+    expect(call.tokenId).toBe(1);
   });
 
-  it("TTL 만료: 오래된 session compat 은 sweep 되어 resume 불가 → cold", async () => {
-    vi.useFakeTimers();
-    try {
-      const d = new AnthropicDispatcher();
-      d.onTokenAdded(1, "tok-A", creds());
-      runClaudeSessionMock.mockResolvedValueOnce(sessionResult({ sessionId: "S1" }));
-      await d.generate(baseReq()); // S1 발급 + compat 저장
+  it("model prefix 정규화: 'anthropic/claude-opus-4-8' → canonical 로 세션/result.model", async () => {
+    const d = new AnthropicDispatcher();
+    d.onTokenAdded(1, "tok-A", creds());
 
-      // 10분 + 1초 경과 → 다음 generate 진입 시 sweep 으로 S1 폐기
-      vi.advanceTimersByTime(10 * 60 * 1000 + 1000);
+    const result = await d.generate(baseReq({ model: "anthropic/claude-opus-4-8" }));
 
-      runClaudeSessionMock.mockResolvedValueOnce(sessionResult({ sessionId: "S2" }));
-      await d.generate(
-        baseReq({
-          reuse: { workerId: 1, threadId: "S1", epoch: 0 },
-          reuseInput: [{ type: "text", text: "x", text_elements: [] }],
-        }),
-      );
-      const call2 = runClaudeSessionMock.mock.calls[1]![0];
-      expect(call2.resumeSessionId).toBeUndefined(); // TTL 만료로 cold fallback
-    } finally {
-      vi.useRealTimers();
-    }
+    const call = runClaudeSessionMock.mock.calls[0]![0];
+    expect(call.model).toBe("claude-opus-4-8");
+    expect(result.model).toBe("claude-opus-4-8");
   });
 
-  it("model prefix 정규화: 'anthropic/claude-opus-4-8' → canonical 로 세션/result.model (codex P2)", async () => {
+  it("[1m] suffix 정규화: result/runClaudeSession 에는 base canonical 만 전달", async () => {
     const d = new AnthropicDispatcher();
     d.onTokenAdded(1, "tok-A", creds());
-    const result = await d.generate(baseReq({ model: "anthropic/claude-opus-4-8" }));
-    // runClaudeSession 과 GenerateResult 둘 다 prefix 없는 canonical id 를 써야 cost/compat 정합.
+
+    const result = await d.generate(baseReq({ model: "anthropic/claude-sonnet-4-6[1m]" }));
+
     const call = runClaudeSessionMock.mock.calls[0]![0];
-    expect(call.model).toBe("claude-opus-4-8");
-    expect(result.model).toBe("claude-opus-4-8");
+    expect(call.model).toBe("claude-sonnet-4-6");
+    expect(result.model).toBe("claude-sonnet-4-6");
   });
 
-  it("model prefix 유무가 같은 호환키 → resume 유지 (codex P2: prefix 가 compat 오염 안 함)", async () => {
+  it("unsupported alias + [1m] 은 조용히 다운그레이드하지 않는다", async () => {
     const d = new AnthropicDispatcher();
     d.onTokenAdded(1, "tok-A", creds());
-    // 1st: prefix 있는 model 로 S1 발급
-    runClaudeSessionMock.mockResolvedValueOnce(sessionResult({ sessionId: "S1", workerId: 1 }));
-    await d.generate(baseReq({ model: "anthropic/claude-sonnet-4-6" }));
 
-    // 2nd: prefix 없는 동일 모델로 reuse → canonical 이 같으니 compat 일치 → resume
-    runClaudeSessionMock.mockResolvedValueOnce(sessionResult({ sessionId: "S1", workerId: 1 }));
-    await d.generate(
-      baseReq({
-        model: "claude-sonnet-4-6",
-        reuse: { workerId: 1, threadId: "S1", epoch: 0 },
-        reuseInput: [{ type: "text", text: "x", text_elements: [] }],
-      }),
+    await expect(d.generate(baseReq({ model: "sonnet[1m]" }))).rejects.toThrow(
+      /Unsupported Anthropic 1M model suffix/,
     );
-    const call2 = runClaudeSessionMock.mock.calls[1]![0];
-    expect(call2.resumeSessionId).toBe("S1");
   });
 
-  it("model 미지정 → ANTHROPIC_DEFAULT_MODEL 적용 (codex P3: sonnet 별칭 우회 차단)", async () => {
+  it("model 미지정 → ANTHROPIC_DEFAULT_MODEL 적용", async () => {
     const d = new AnthropicDispatcher();
     d.onTokenAdded(1, "tok-A", creds());
+
     const result = await d.generate(baseReq({ model: undefined }));
+
     const call = runClaudeSessionMock.mock.calls[0]![0];
     expect(call.model).toBe(ANTHROPIC_DEFAULT_MODEL);
     expect(result.model).toBe(ANTHROPIC_DEFAULT_MODEL);
   });
 
-  it("replaceTokens: DB 기준 풀 재동기화 — 없는 토큰 제거(+compat 정리), 새 토큰 추가 (codex P1)", async () => {
+  it("replaceTokens: DB 기준 풀 재동기화 — 없는 토큰 제거, 새 토큰 추가", async () => {
     const d = new AnthropicDispatcher();
     d.onTokenAdded(1, "tok-A", creds());
-    runClaudeSessionMock.mockResolvedValueOnce(sessionResult({ sessionId: "S1", workerId: 1 }));
-    await d.generate(baseReq()); // tok-A(1) 가 S1 소유 + compat 저장
 
-    // reconcile: DB 에는 tok-B(2)만 active. tok-A(1) 는 사라짐 → 제거 + S1 compat 정리.
     d.replaceTokens([{ id: 2, name: "tok-B", credentials: creds() }]);
+    const result = await d.generate(baseReq());
 
-    // 이제 tok-A(1) 미선택 + S1 resume 시도해도 compat 없어서 cold.
-    runClaudeSessionMock.mockResolvedValueOnce(sessionResult({ sessionId: "S2", workerId: 2 }));
-    const r = await d.generate(
-      baseReq({
-        reuse: { workerId: 1, threadId: "S1", epoch: 0 },
-        reuseInput: [{ type: "text", text: "x", text_elements: [] }],
-      }),
-    );
-    expect(r.tokenName).toBe("tok-B"); // tok-A 제거됨 → tok-B 만 남음
-    const call2 = runClaudeSessionMock.mock.calls[1]![0];
-    expect(call2.resumeSessionId).toBeUndefined(); // S1 compat 정리됨 → cold
-  });
-
-  it("resume deadlock 회귀: runClaudeSession 이 내부 락을 잡아도 dispatcher 가 중첩 락을 안 건다 (codex U5 P0)", async () => {
-    const d = new AnthropicDispatcher();
-    d.onTokenAdded(1, "tok-A", creds());
-    // 1st cold → S1 발급 (mock 도 실제 runClaudeSession 처럼 sessionId 단위 락을 잡게 한다)
-    runClaudeSessionMock.mockImplementationOnce(async (req: { resumeSessionId?: string }) =>
-      withSessionLock(req.resumeSessionId ?? "S1", async () =>
-        sessionResult({ sessionId: "S1", workerId: 1 }),
-      ),
-    );
-    await d.generate(baseReq());
-
-    // 2nd resume(S1): mock 이 실제 withSessionLock("S1") 재진입. dispatcher 가 outer withSessionLock("S1")
-    // 으로 또 감쌌다면 같은 sessionId 비-reentrant 락이 자기 자신을 기다려 deadlock → 이 await 가 영구 정지.
-    // dispatcher 가 락을 안 거므로 정상 완료돼야 한다.
-    runClaudeSessionMock.mockImplementationOnce(async (req: { resumeSessionId?: string }) =>
-      withSessionLock(req.resumeSessionId ?? "S1", async () =>
-        sessionResult({ sessionId: "S1", workerId: 1 }),
-      ),
-    );
-    const second = await d.generate(
-      baseReq({
-        reuse: { workerId: 1, threadId: "S1", epoch: 0 },
-        reuseInput: [{ type: "text", text: "x", text_elements: [] }],
-      }),
-    );
-    expect(second.threadCoord.threadId).toBe("S1"); // deadlock 없이 완료
+    expect(result.tokenName).toBe("tok-B");
   });
 
   it("generateStream: onDelta/onComplete 호출", async () => {
     const d = new AnthropicDispatcher();
     d.onTokenAdded(1, "tok-A", creds());
-    // runClaudeSession 이 onDelta 를 호출하도록 모킹
     runClaudeSessionMock.mockImplementationOnce(async (_req, onDelta: (t: string) => void) => {
       onDelta("부분");
       return sessionResult({ text: "부분완성" });
     });
+
     const deltas: Array<string> = [];
     let completed: unknown = null;
     await d.generateStream(baseReq(), {
@@ -521,44 +254,63 @@ describe("AnthropicDispatcher", () => {
       onComplete: (r) => (completed = r),
       onError: () => {},
     });
+
     expect(deltas).toEqual(["부분"]);
     expect(completed).not.toBeNull();
+    expect(runClaudeSessionMock.mock.calls[0]![0].includePartialMessages).toBe(true);
+  });
+
+  it("generateStream: Claude server error 는 onError 로 전달하고 complete 하지 않는다", async () => {
+    const d = new AnthropicDispatcher();
+    d.onTokenAdded(1, "tok-A", creds());
+    const serverError = new Error(
+      "claude error (anthropic/yds): API Error: 529 Overloaded. This is a server-side issue",
+    );
+    runClaudeSessionMock.mockRejectedValueOnce(serverError);
+
+    const onDelta = vi.fn();
+    const onComplete = vi.fn();
+    const onError = vi.fn();
+    await d.generateStream(baseReq(), { onDelta, onComplete, onError });
+
+    expect(onDelta).not.toHaveBeenCalled();
+    expect(onComplete).not.toHaveBeenCalled();
+    expect(onError).toHaveBeenCalledWith(serverError);
+    expect(runClaudeSessionMock.mock.calls[0]![0].includePartialMessages).toBe(true);
   });
 
-  it("refresh: 만료 임박 토큰은 provider 포함해 refreshToken 호출, 새 access token 으로 세션 진행 (codex P1)", async () => {
+  it("refresh: 만료 임박 토큰은 provider 포함해 refreshToken 호출, 새 access token 으로 세션 진행", async () => {
     const d = new AnthropicDispatcher();
-    // 만료까지 30초 → REFRESH_SAFETY_MS(60s) 안쪽이라 preemptive refresh 발동.
     d.onTokenAdded(1, "tok-A", creds(30_000));
     refreshTokenMock.mockResolvedValueOnce("sk-ant-oat01-refreshed");
+
     await d.generate(baseReq());
 
-    // refreshToken 은 provider 를 반드시 포함해 호출돼야 함(없으면 TokenModel.save 실패).
     expect(refreshTokenMock).toHaveBeenCalledTimes(1);
     const refreshArg = refreshTokenMock.mock.calls[0]![0];
     expect(refreshArg.provider).toBe("anthropic");
     expect(refreshArg.id).toBe(1);
-    // refresh 된 access token 이 claude 세션으로 전달돼야 함.
-    const sessionArg = runClaudeSessionMock.mock.calls[0]![0];
-    expect(sessionArg.token).toBe("sk-ant-oat01-refreshed");
+    expect(runClaudeSessionMock.mock.calls[0]![0].token).toBe("sk-ant-oat01-refreshed");
   });
 
   it("refresh: 만료 여유 있으면 refresh 안 함, 기존 access token 사용", async () => {
     const d = new AnthropicDispatcher();
-    d.onTokenAdded(1, "tok-A", creds(3_600_000)); // 1시간 여유
+    d.onTokenAdded(1, "tok-A", creds(3_600_000));
+
     await d.generate(baseReq());
+
     expect(refreshTokenMock).not.toHaveBeenCalled();
-    const sessionArg = runClaudeSessionMock.mock.calls[0]![0];
-    expect(sessionArg.token).toBe("sk-ant-oat01-test");
+    expect(runClaudeSessionMock.mock.calls[0]![0].token).toBe("sk-ant-oat01-test");
   });
 
-  it("refresh 실패해도(throw) 기존 access token 으로 진행 — 요청을 죽이지 않음 (codex P1)", async () => {
+  it("refresh 실패해도 기존 access token 으로 진행 — 요청을 죽이지 않음", async () => {
     const d = new AnthropicDispatcher();
     d.onTokenAdded(1, "tok-A", creds(30_000));
     refreshTokenMock.mockRejectedValueOnce(new Error("refresh boom"));
+
     const result = await d.generate(baseReq());
-    // refresh 가 throw 해도 catch 후 만료 임박 access token 으로 진행.
+
     expect(result.text).toBe("hello");
-    const sessionArg = runClaudeSessionMock.mock.calls[0]![0];
-    expect(sessionArg.token).toBe("sk-ant-oat01-test");
+    expect(runClaudeSessionMock.mock.calls[0]![0].token).toBe("sk-ant-oat01-test");
   });
 });