deel-local-cli 1.8.0 → 1.12.0

package/src/backend/learn.js

@@ -69,6 +69,30 @@ export function 배울것(message) {
   }
 
   // ── 2) 답 길이 한계 ───────────────────────────────────────────────────
+
+  /*
+   * 「우리가 준 값 > 서버의 한계」 로 말하는 자리부터 본다.
+   *
+   * Anthropic 은 출력 상한을 이렇게 말한다 —
+   *
+   *   "max_tokens: 100000 > 64000, which is the maximum allowed number of
+   *    output tokens for claude-x"
+   *
+   * 숫자가 둘인데 **앞이 우리가 요청한 값**이고 뒤가 한계다. 아래 표는 이름
+   * 뒤의 첫 숫자를 집으므로, 그대로 두면 방금 거절당한 바로 그 값을 한계로
+   * 배운다. 그러면 같은 값으로 곧장 다시 부르고 또 거절당하는데, 그때는 이미
+   * 배운 뒤라 두 번은 못 배우고 턴이 죽는다(loop.js). 게다가 배운 값은
+   * 연결저장() 으로 프로필에 적히므로 **다음에 켤 때도 똑같이 죽는다.**
+   * 사람이 손으로 설정을 고치기 전에는 안 풀린다.
+   *
+   * 표보다 먼저 본다. 표에 한 번 걸리고 나면 되돌릴 자리가 없다.
+   */
+  const 넘김 = /max_(?:completion_)?tokens\s*[:=]?\s*(\d{3,})\s*>\s*(\d{3,})/i.exec(s);
+  if (넘김) {
+    const limit = 성한수(넘김[2]);
+    if (limit) return { kind: 'out', limit, asked: 성한수(넘김[1]), text: 짧게(s) };
+  }
+
   const out표 = [
     // "max_tokens is too large: 200000. This model supports at most 16384 completion tokens"
     /supports? at most\s+(\d+)\s*(?:completion\s*)?tokens?/i,

package/src/backend/mcp.js

@@ -69,6 +69,42 @@ export function 설정읽기(root) {
   return { 서버들, 자리: p, 있음: true };
 }
 
+/*
+ * ── 지금 띄워 둔 서버들 ─────────────────────────────────────────────────
+ *
+ * 여기 왜 명부가 있나. MCP 서버는 붙인 쪽(repl·ACP)이 들고 있을 뿐이라,
+ * 프로그램이 어느 길로든 끝나 버리면 **아무도 안 닫는다.** 그러면 사람
+ * 컴퓨터에 서버 프로세스가 하나씩 쌓인다 — 작업 관리자를 열기 전에는
+ * 모르는 종류의 탈이다.
+ *
+ * 일감(tools/jobs.js)과 언어 서버(lsp/client.js)에는 이미 이 그물이 있는데
+ * 여기만 없었다. 같은 자리, 같은 규칙으로 둔다.
+ */
+const 띄운것들 = new Set();
+
+/** 검사와 진단이 본다. 지금 살아 있는 서버 수. */
+export function 살아있는수() { return 띄운것들.size; }
+
+/**
+ * 다 닫는다. 프로그램이 끝날 때와 검사 뒤에 부른다.
+ * @returns {number} 닫은 개수
+ */
+export function 모두닫기() {
+  const 것들 = [...띄운것들];
+  띄운것들.clear();
+  let n = 0;
+  for (const s of 것들) { try { s.닫기(); n++; } catch { /* 끝나는 중이라 할 수 있는 게 없다 */ } }
+  return n;
+}
+
+/*
+ * 어떤 길로 끝나든 남기지 않는다. 붙인 쪽이 이미 닫았어도 무해하다.
+ *
+ * 이름 있는 함수를 그대로 건다 — 이름 없는 화살표로 걸면 그물이 걸려 있는지
+ * 검사가 밖에서 확인할 길이 없다. 걷어내도 아무도 모르는 그물은 없는 것과 같다.
+ */
+process.once('exit', 모두닫기);
+
 /**
  * 서버 하나와의 연결.
  *
@@ -105,6 +141,9 @@ export class MCP서버 {
       this.죽음 = `띄우지 못했습니다: ${e.message}`;
       return false;
     }
+    // 띄운 순간부터 명부에 든다. 악수(initialize)를 못 마쳐도 아이는 이미
+    // 떠 있으므로, 여기서 안 적으면 그 아이는 아무도 안 거두는 아이가 된다.
+    띄운것들.add(this);
 
     this.kid.on('error', (e) => this.끝냄(`오류: ${e.message}`));
     this.kid.on('exit', (code, sig) => this.끝냄(`끝났습니다 (코드 ${code ?? sig})`));
@@ -163,25 +202,56 @@ export class MCP서버 {
     if (!기다림) return;
     this.기다리는것.delete(j.id);
     clearTimeout(기다림.타이머);
+    // 끝난 자리의 ESC 엿듣기는 떼어 낸다. 안 떼면 한 턴에 도구를 스무 번
+    // 부르는 사이 신호 하나에 스무 개가 매달린다 — 노드가 열 개 넘으면
+    // 「메모리가 새는 것 같다」 고 경고를 찍는데, 실제로 새는 것이 맞다.
+    기다림.끊기그만?.();
     if (j.error) 기다림.실패(new Error(j.error.message ?? '알 수 없는 오류'));
     else 기다림.성공(j.result);
   }
 
-  보내고기다리기(method, params, timeout = 부르기제한) {
+  /**
+   * 한 통 보내고 답을 기다린다.
+   *
+   * signal 은 사람이 누른 ESC 다. 안 받으면 도구 하나 부르는 데 최대 60초
+   * (부르기제한)를 기다리는데, 그 60초 동안 ESC 는 아무것도 안 한다 — 화면은
+   * 「멈추는 중…」 인데 남의 프로세스의 답을 계속 기다리고 있는 상태다.
+   * 그래서 시한과 같은 자리에서 같은 방식으로 푼다: 기다리는 표에서 빼고,
+   * 왜 끝났는지를 말로 남기고 끝낸다.
+   */
+  보내고기다리기(method, params, timeout = 부르기제한, signal = null) {
     return new Promise((성공, 실패) => {
       if (!this.kid || this.kid.exitCode !== null) return 실패(new Error(this.죽음 ?? '연결이 없습니다'));
+      // 이미 멈췄으면 보내지도 않는다. 보내 놓고 버리면 남의 서버는 그 일을 끝까지 한다.
+      if (signal?.aborted) return 실패(new Error('중단했습니다'));
       const id = this.다음번호++;
       const 타이머 = setTimeout(() => {
         this.기다리는것.delete(id);
+        끊기그만();
         실패(new Error(`${Math.round(timeout / 1000)}초 안에 답이 없습니다`));
       }, timeout);
       if (타이머.unref) 타이머.unref();
-      this.기다리는것.set(id, { 성공, 실패, 타이머 });
+      /*
+       * 기다리는 표에서 **반드시** 뺀다.
+       *
+       * 안 빼면 뒤늦게 온 답이 이미 끝난 약속을 또 푼다. 두 번째 풀기는
+       * 조용히 무시되므로 오류는 안 나지만, 표에 죽은 자리가 남아서
+       * 끝냄() 이 그것들을 다시 실패시킨다 — 아무도 안 듣는 실패다.
+       */
+      const 끊겼다 = () => {
+        clearTimeout(타이머);
+        this.기다리는것.delete(id);
+        실패(new Error('중단했습니다'));
+      };
+      signal?.addEventListener?.('abort', 끊겼다, { once: true });
+      const 끊기그만 = () => signal?.removeEventListener?.('abort', 끊겼다);
+      this.기다리는것.set(id, { 성공, 실패, 타이머, 끊기그만 });
       try {
         this.kid.stdin.write(JSON.stringify({ jsonrpc: '2.0', id, method, params }) + '\n');
       } catch (e) {
         clearTimeout(타이머);
         this.기다리는것.delete(id);
+        끊기그만();
         실패(e);
       }
     });
@@ -191,8 +261,8 @@ export class MCP서버 {
     try { this.kid?.stdin?.write(JSON.stringify({ jsonrpc: '2.0', method, params }) + '\n'); } catch { /* 죽었으면 어차피 끝이다 */ }
   }
 
-  async 부르기(도구이름, args, { timeout = 부르기제한 } = {}) {
-    const r = await this.보내고기다리기('tools/call', { name: 도구이름, arguments: args ?? {} }, timeout);
+  async 부르기(도구이름, args, { timeout = 부르기제한, signal = null } = {}) {
+    const r = await this.보내고기다리기('tools/call', { name: 도구이름, arguments: args ?? {} }, timeout, signal);
     // 규격상 결과는 content 배열이다. 글만 뽑아 모델에게 넘긴다.
     const 조각 = Array.isArray(r?.content) ? r.content : [];
     const 글 = 조각
@@ -206,6 +276,7 @@ export class MCP서버 {
     this.죽음 = this.마지막말 ? `${왜} — ${this.마지막말}` : 왜;
     for (const [, 기다림] of this.기다리는것) {
       clearTimeout(기다림.타이머);
+      기다림.끊기그만?.();
       기다림.실패(new Error(this.죽음));
     }
     this.기다리는것.clear();
@@ -213,6 +284,7 @@ export class MCP서버 {
 
   닫기() {
     this.끝냄('닫았습니다');
+    띄운것들.delete(this);
     try {
       this.kid?.stdin?.end();
       this.kid?.kill();
@@ -236,6 +308,25 @@ function 깨끗한환경() {
   return out;
 }
 
+/**
+ * 게이트웨이 열쇠 **하나만** 뺀 환경. Bash 와 Jobs 가 자식에게 넘길 것.
+ *
+ * 위 깨끗한환경 은 남의 프로그램(MCP 서버)에 주는 것이라 통째로 씻는다.
+ * 여기는 다르다 — Bash 로 도는 것은 **사용자 제 프로젝트**다. PATH·NODE_ENV·
+ * DEEL_HOME·사내 프록시 설정이 다 있어야 하고(사용자는 이 프로그램의 검사
+ * 자체를 Bash 로 돌린다), 하나라도 빠지면 「내 터미널에서는 되는데」 가 된다.
+ *
+ * 그래서 딱 하나만 뺀다. 안 빼면 `env` 한 줄로 열쇠가 화면에 찍히고, 그 화면이
+ * 대화에 실려 게이트웨이로 나가고 `.deel/sessions/*.jsonl` 로 디스크에도 남는다 —
+ * 열쇠를 그 열쇠의 주인에게 보내는 셈이다(guard.js 가 막는 것과 같은 길).
+ * 자식이 무엇을 하든 이 값이 필요할 일은 없다. 게이트웨이로 나가는 것은 우리다.
+ */
+export function 열쇠뺀환경(env = process.env) {
+  const out = { ...env };
+  delete out.DEEL_API_KEY;
+  return out;
+}
+
 /** 우리 도구 이름과 안 부딪히게 앞에 서버 이름을 붙인다. Claude Code 와 같은 꼴이다. */
 export const 도구이름 = (서버, 도구) => `mcp__${서버}__${도구}`;
 
@@ -275,7 +366,7 @@ export async function 다붙이기(root, { offline = false, timeout = 붙기제
     const ok = await 서버.붙기({ timeout });
     if (ok) {
       붙은것.push(서버);
-      audit?.note?.('mcp', { 이름: s.이름, command: s.command, 도구: 서버.도구.length });
+      audit?.write?.('mcp', { 이름: s.이름, command: s.command, 도구: 서버.도구.length });
     } else {
       못한것.push({ 이름: s.이름, 왜: 서버.죽음 ?? '알 수 없는 이유' });
       서버.닫기();

package/src/backend/probe.js

@@ -7,7 +7,12 @@
 import { req, headersFor, serverMessage } from './http.js';
 import { probeCtx } from './ctxsize.js';
 import { 눈검사메시지 } from './vision.js';
-import { 주소붙이기 } from './adapter.js';
+import {
+  주소붙이기, endpoint, 더할머리, buildBody, extractMessage,
+  assistantMessage, toolMessage,
+} from './adapter.js';
+import { 벤더 } from './toolfit.js';
+import { 말 } from '../i18n/index.js';
 
 const READ_TOOL = {
   type: 'function',
@@ -22,32 +27,32 @@ const READ_TOOL = {
   },
 };
 
-// 규격별 요청 만들기 — 이 함수 하나가 openai/ollama 차이를 흡수한다.
-function build(shape, { model, messages, tools, stream, json, think, maxTokens = 128 }) {
-  if (shape === 'ollama') {
-    const body = { model, messages, stream: !!stream, options: { num_predict: maxTokens } };
-    if (tools) body.tools = tools;
-    if (json) body.format = json;
-    if (think !== undefined) body.think = think;
-    return { path: '/api/chat', body };
-  }
-  const body = { model, messages, stream: !!stream, max_tokens: maxTokens };
-  if (tools) { body.tools = tools; body.tool_choice = 'auto'; }
-  if (json) {
-    body.response_format = { type: 'json_schema', json_schema: { name: 'probe', schema: json, strict: true } };
-  }
-  if (think !== undefined) body.reasoning_effort = think;
-  return { path: '/chat/completions', body };
-}
+/*
+ * ── 규격 차이는 여기서 흡수하지 않는다 ──────────────────────────────────
+ *
+ * 여기에 build() 와 extract() 가 따로 있었다. 그 둘이 아는 규격은 `ollama` 와
+ * 「나머지 = OpenAI」 **둘뿐**이었고, `anthropic` 은 「나머지」 로 떨어졌다.
+ * 그래서 Claude 를 직접 붙이면 진단이 이렇게 갔다 —
+ *
+ *   · 판 머리(anthropic-version)를 안 얹는다 → 그 하나로 400
+ *   · 문 이름이 /chat/completions (있어야 할 것은 /messages)
+ *   · 시킴말이 messages 안으로 들어간다 → 「모르는 역할」
+ *   · 도구가 {type:'function', function:{…}} 모양으로 간다
+ *   · 답을 choices[0].message 에서 찾는다 (실제로는 content 블록 배열)
+ *
+ * 첫 칸(기본 대화)이 400 으로 죽으면 나머지 일곱 칸은 전부 「확인 불가」 로
+ * 건너뛴다. 그 결과 `deel setup` 이 저장하는 프로필에 streaming·tools·json·
+ * vision 이 **다 false** 로 적힌다 — Claude 를 붙였는데 도구를 아예 안 쓰는
+ * 연결이 만들어진다. 붙기는 붙으니 아무도 고장이라고 생각하지 않는다.
+ *
+ * adapter.js 첫 줄은 처음부터 "진단(probe)과 에이전트 루프가 같은 함수를
+ * 쓴다" 고 적어 두었다. 실제로는 안 썼다. 이제 쓴다 — 규격이 넷째가 되어도
+ * 이 파일은 안 고쳐도 된다.
+ */
 
-// 응답에서 본문과 도구호출을 꺼낸다.
-function extract(shape, json) {
-  if (shape === 'ollama') {
-    const m = json?.message ?? {};
-    return { content: m.content ?? '', toolCalls: m.tool_calls ?? [], thinking: m.thinking ?? '' };
-  }
-  const m = json?.choices?.[0]?.message ?? {};
-  return { content: m.content ?? '', toolCalls: m.tool_calls ?? [], thinking: m.reasoning_content ?? '' };
+/** 이 회사가 무엇을 받는지까지 봐야 몸통이 맞다 (toolfit.js 의 벤더). */
+function 몸통(conn, opts) {
+  return buildBody(conn.kind, { model: conn.model, 회사: 벤더(conn), maxTokens: 128, ...opts });
 }
 
 // 추론 모델일 때 기본 대화 칸에 덧붙일 설명.
@@ -55,6 +60,31 @@ function c_note(retried) {
   return retried ? ' (추론 모델 — 사고를 끄고 다시 물어 확인)' : ' (추론 모델)';
 }
 
+/*
+ * ── 이 문으로는 안 나오는 모델 (Codex 계열) ─────────────────────────────
+ *
+ * `gpt-5-codex` 계열은 OpenAI 가 **Responses API(/responses)로만** 내준다.
+ * `/chat/completions` 로 물으면 404 나 400 이 오는데, 그 화면에는 상태 코드
+ * 한 줄만 남는다. 그러면 사람은 열쇠를 의심하거나 모델 이름을 잘못 적은 줄
+ * 알고, 맞는 이름을 몇 번씩 다시 넣어 본다 — 이름은 처음부터 맞았다.
+ *
+ * ── 왜 이름을 보나. 이 파일에서만 본다 ─────────────────────────────────
+ *
+ * 어디로 보낼지는 **주소로만** 정한다(1.9). 그 규칙은 여기서도 안 깬다 —
+ * 여기서 이름을 보는 것은 보낼 곳을 고르려는 것이 아니라, **이미 실패한
+ * 요청에 까닭을 붙이려는** 것뿐이다. 그래서 미리 막지 않는다. 요청은 그대로
+ * 나가고, 실패했을 때만 한 줄이 붙는다. 언젠가 OpenAI 가 이 문으로도 내주면
+ * 요청이 그냥 성공하고 이 줄은 저절로 안 나온다.
+ *
+ * 게이트웨이는 해당 없다. 그 뒤에 무엇이 걸려 있는지 우리는 모르고, 사내
+ * 게이트웨이가 제 나름대로 이 계열을 chat 창구로 내주는 일도 있다.
+ */
+const CODEX계열 = /^(?:gpt-5-codex|codex-)/i;
+
+export function 코덱스인가(conn) {
+  return 벤더(conn) === 'openai' && CODEX계열.test(String(conn?.model ?? ''));
+}
+
 const SKIPPED = [
   ['system', '시스템 메시지'],
   ['stream', '스트리밍'],
@@ -69,7 +99,14 @@ const SKIPPED = [
 export async function probe(conn, onStep = () => {}) {
   const { kind: shape, base, auth, model } = conn;
   const key = conn.key ?? '';
-  const H = () => headersFor(auth, key);
+  /*
+   * 판 머리를 여기서도 얹는다 (adapter.js 의 더할머리).
+   *
+   * Anthropic 규격은 `anthropic-version` 하나가 없으면 400 이다. 열쇠가
+   * 멀쩡해도 그렇다. 진단 화면은 그 400 을 「연결 실패」 로 적고, 사람은
+   * 열쇠를 다시 받으러 간다 — 여덟 칸이 전부 그 한 줄 때문에 빨개진다.
+   */
+  const H = () => headersFor(auth, key, 더할머리(shape));
   /*
    * 물음표 뒤를 끝에 남겨야 한다 (adapter.js 의 주소붙이기).
    *
@@ -85,23 +122,23 @@ export async function probe(conn, onStep = () => {}) {
   const facts = { shape, base, auth, model };
 
   const add = (r) => { results.push(r); onStep(r); return r; };
-  const call = (opts) => {
-    const { path, body } = build(shape, { model, ...opts });
-    return req(url(path), {
-      method: 'POST',
-      headers: H(),
-      body,
-      timeout: opts.timeout ?? 60000,
-      stream: opts.stream,
-    });
-  };
+  const call = (opts) => req(url(endpoint(shape)), {
+    method: 'POST',
+    headers: H(),
+    body: 몸통(conn, opts),
+    timeout: opts.timeout ?? 60000,
+    stream: opts.stream,
+  });
+  // 답 읽기도 루프와 같은 함수를 쓴다. 도구 부름은 { id, name, args } 로
+  // 고르게 나온다 — 규격마다 다른 자리를 여기서 또 헤아리지 않는다.
+  const 읽기 = (r) => extractMessage(shape, r?.json);
 
   // 1. 기본 대화 — 이게 안 되면 나머지는 볼 필요가 없다.
   //    추론 모델은 본문이 전부 thinking 으로 가고 토큰 상한에 잘린다.
   //    그걸 "안됨"으로 볼 수 없으므로, 사고를 끄고 넉넉히 한 번 더 물어본다.
   const ASK = { messages: [{ role: 'user', content: '1+1은? 숫자만 답하세요.' }] };
   let basic = await call({ ...ASK, maxTokens: 256 });
-  let got = basic.ok ? extract(shape, basic.json) : { content: '', thinking: '' };
+  let got = basic.ok ? 읽기(basic) : { content: '', thinking: '' };
   let thinkingModel = false;
   let retried = false;
 
@@ -110,12 +147,12 @@ export async function probe(conn, onStep = () => {}) {
     retried = true;
     const second = await call({ ...ASK, maxTokens: 1024, think: false, timeout: 90000 });
     if (second.ok) {
-      const e2 = extract(shape, second.json);
+      const e2 = 읽기(second);
       if (e2.content) { basic = second; got = e2; }
       else {
         // 사고를 못 끄는 서버 — 상한만 크게 올려 한 번 더.
         const third = await call({ ...ASK, maxTokens: 2048, timeout: 120000 });
-        if (third.ok && extract(shape, third.json).content) { basic = third; got = extract(shape, third.json); }
+        if (third.ok && 읽기(third).content) { basic = third; got = 읽기(third); }
       }
     }
   }
@@ -136,7 +173,11 @@ export async function probe(conn, onStep = () => {}) {
         ? got.thinking
           ? '사고만 나오고 본문이 안 나옵니다 — 토큰 상한을 크게 올려야 합니다'
           : '응답이 비어 있습니다 — 모델 이름을 확인하세요'
-        : serverMessage(basic),
+        // 못 붙은 까닭을 아는 자리가 하나 있다. 상태 코드만 남기면 사람은
+        // 열쇠를 의심하는데, 열쇠도 이름도 처음부터 맞았다 (코덱스인가 머리말).
+        : 코덱스인가(conn)
+          ? `${serverMessage(basic)}\n${말('probe.codexOnly', { 모델: model })}`
+          : serverMessage(basic),
     ms: basic.ms,
   });
   if (!basicOk) {
@@ -154,7 +195,7 @@ export async function probe(conn, onStep = () => {}) {
       { role: 'user', content: '안녕하세요' },
     ],
   });
-  const sysHit = sys.ok && /DEEL/i.test(extract(shape, sys.json).content);
+  const sysHit = sys.ok && /DEEL/i.test(읽기(sys).content);
   add({
     id: 'system',
     label: '시스템 메시지',
@@ -209,15 +250,18 @@ export async function probe(conn, onStep = () => {}) {
     maxTokens: 512,
     timeout: 90000,
   });
-  const tcalls = tl.ok ? extract(shape, tl.json).toolCalls : [];
+  const tcalls = tl.ok ? 읽기(tl).toolCalls : [];
   const gotCall = tcalls.length > 0;
-  const argOk = gotCall && JSON.stringify(tcalls[0]?.function?.arguments ?? '').includes('config');
+  // 부름은 이미 { id, name, args } 로 고르게 나온다 (extractMessage).
+  // 예전에는 여기서 OpenAI 날모양(function.arguments)을 직접 팠다 —
+  // 그러면 Anthropic 은 도구를 제대로 불러도 「안 불렀다」 로 읽힌다.
+  const argOk = gotCall && JSON.stringify(tcalls[0]?.args ?? '').includes('config');
   add({
     id: 'tools',
     label: '도구 호출',
     status: gotCall ? (argOk ? 'ok' : 'warn') : 'no',
     detail: gotCall
-      ? `${tcalls[0]?.function?.name} 호출됨${argOk ? '' : ' — 인자가 부정확, 편집 신뢰성 작업이 더 필요합니다'}`
+      ? `${tcalls[0]?.name} 호출됨${argOk ? '' : ' — 인자가 부정확, 편집 신뢰성 작업이 더 필요합니다'}`
       : tl.ok ? '도구를 안 부르고 글로만 답합니다' : serverMessage(tl),
     ms: tl.ms,
   });
@@ -227,12 +271,15 @@ export async function probe(conn, onStep = () => {}) {
   if (gotCall) {
     const tc = tcalls[0];
     const callId = tc.id ?? 'call_1';
-    const assistantMsg = shape === 'ollama'
-      ? { role: 'assistant', content: '', tool_calls: tcalls }
-      : { role: 'assistant', content: null, tool_calls: [{ id: callId, type: 'function', function: tc.function }] };
-    const toolMsg = shape === 'ollama'
-      ? { role: 'tool', tool_name: tc.function?.name, content: '{"port": 7099}' }
-      : { role: 'tool', tool_call_id: callId, content: '{"port": 7099}' };
+    /*
+     * 되돌려 넣는 모양도 루프와 같은 함수로 짓는다 (adapter.js).
+     *
+     * 여기에 규격별 갈래를 손으로 적어 두면 규격이 하나 늘 때마다 이 자리가
+     * 조용히 틀린다 — Anthropic 에서는 도구 결과가 사람 차례로 가야 하는데
+     * `role:'tool'` 로 보내 「모르는 역할」 을 받고 있었다.
+     */
+    const assistantMsg = assistantMessage(shape, { content: '', toolCalls: [tc] });
+    const toolMsg = toolMessage(shape, { callId, name: tc.name, content: '{"port": 7099}' });
     const rt = await call({
       ...quiet,
       timeout: 90000,
@@ -245,7 +292,7 @@ export async function probe(conn, onStep = () => {}) {
       tools: [READ_TOOL],
       maxTokens: 256,
     });
-    const said = rt.ok ? extract(shape, rt.json).content : '';
+    const said = rt.ok ? 읽기(rt).content : '';
     add({
       id: 'toolresult',
       label: '도구 결과 되돌리기',
@@ -279,8 +326,20 @@ export async function probe(conn, onStep = () => {}) {
       timeout: 90000,
     });
     if (!js.ok) break;
-    raw = extract(shape, js.json).content ?? '';
-    try { parsed = JSON.parse(raw); } catch {}
+    raw = 읽기(js).content ?? '';
+    /*
+     * **객체일 때만** 읽었다고 한다.
+     *
+     * 답 모양을 강제하는 칸이 없는 규격(Anthropic)에서는 이 물음에 그냥
+     * `21` 이라고 답한다. `JSON.parse('21')` 은 오류 없이 숫자 21 을 준다.
+     * 그런데 그다음 줄이 `'answer' in parsed` 라, 숫자에 `in` 을 써서
+     * **TypeError 로 진단 전체가 통째로 죽었다.** 스키마를 안 지킨 것은
+     * 「구조적 출력 안 됨」 이라고 적을 일이지 프로그램이 끝날 일이 아니다.
+     */
+    try {
+      const 읽힌것 = JSON.parse(raw);
+      if (읽힌것 && typeof 읽힌것 === 'object' && !Array.isArray(읽힌것)) parsed = 읽힌것;
+    } catch { /* 글로만 답하는 서버 — 아래에서 '스키마를 안 지킴' 으로 적는다 */ }
   }
   const jsonOk = !!(parsed && 'answer' in parsed);
   add({
@@ -316,7 +375,7 @@ export async function probe(conn, onStep = () => {}) {
     maxTokens: 32,
     timeout: 60000,
   });
-  const 눈있음 = !!(눈.ok && extract(shape, 눈.json).content);
+  const 눈있음 = !!(눈.ok && 읽기(눈).content);
   add({
     id: 'vision',
     label: '그림 보기',
@@ -330,9 +389,18 @@ export async function probe(conn, onStep = () => {}) {
   });
   facts.vision = 눈있음;
 
-  // 7. 추론 강도 조절 — 낮음/높음이 실제로 다른 결과를 내느냐.
-  //    상한에 걸리면 둘 다 같은 숫자가 나와 비교가 무의미해진다. 넉넉히 준다.
-  const THINK_CAP = 1500;
+  /*
+   * 7. 추론 강도 조절 — 낮음/높음이 실제로 다른 결과를 내느냐.
+   *
+   * 상한에 걸리면 둘 다 같은 숫자가 나와 비교가 무의미해진다. 넉넉히 준다.
+   *
+   * Anthropic 규격은 여기서 상한을 더 크게 잡아야 한다. 그쪽은 강도를 말이
+   * 아니라 **출력 상한 안에서 나가는 예산**으로 주는데(adapter.js 의
+   * 생각예산), 1,500 으로는 답에 남길 자리를 빼고 나면 최소 예산 1,024 를
+   * 못 만든다. 그러면 생각이 아예 안 켜진 채로 두 번을 부르고, 이 칸은
+   * 「차이 없음」 이라고 적는다 — 켤 수 있는 모델에 대고 못 켠다고 적는 셈이다.
+   */
+  const THINK_CAP = shape === 'anthropic' ? 8000 : 1500;
   const seen = [];
   for (const lv of ['low', 'high']) {
     const r = await call({
@@ -342,13 +410,15 @@ export async function probe(conn, onStep = () => {}) {
       timeout: 120000,
     });
     if (r.ok) {
-      const e = extract(shape, r.json);
+      const e = 읽기(r);
       seen.push({
         lv,
         ms: r.ms,
         thought: (e.thinking ?? '').length,
-        out: r.json?.usage?.completion_tokens ?? r.json?.eval_count ?? 0,
-        capped: (r.json?.done_reason ?? r.json?.choices?.[0]?.finish_reason) === 'length',
+        // 토큰 수와 끝난 까닭도 규격마다 이름이 다르다. 읽는 자리를 하나로 모은다 —
+        // 여기서 OpenAI 이름만 보면 Anthropic 은 늘 0 이고 늘 '안 잘림' 이 된다.
+        out: e.usage?.out ?? 0,
+        capped: e.stopped === 'length' || e.stopped === 'max_tokens',
       });
     } else {
       seen.push({ lv, ms: r.ms, err: serverMessage(r) });