deel-local-cli 1.20.13 → 2.0.1

package/src/backend/azure.js

@@ -58,8 +58,19 @@ export function 애저인가(input) {
   if (!s) return false;
   const u = 뜯기(s);
   if (!u) return /\/openai\/deployments(\/|\?|$)/i.test(s);
+  /*
+   * 배포 주소부터 본다 — `/v1` 로 끝나는지보다 **앞**이다.
+   *
+   * 배포 이름이 하필 `v1` 인 자원이 있다. 그 주소
+   * (`…/openai/deployments/v1`)를 `/v1` 로 끝난다는 이유로 OpenAI 규격 창구로
+   * 보고 Azure 에서 빼 버렸다. 길에 `/openai/deployments/` 가 이미 적혀 있으면
+   * 마지막 한 칸은 **배포 이름**이지 판 번호가 아니다 — 애저풀기 는 이 주소에서
+   * 배포 `v1` 을 제대로 뽑는다. 두 함수의 답이 갈리면 한쪽만 맞는 자리가 된다.
+   */
+  const 배포길 = /\/openai\/deployments(\/|$)/i.test(u.pathname);
+  if (배포길) return true;
   if (/\/v\d+\/?$/.test(u.pathname)) return false;
-  return 애저호스트.test(u.hostname) || /\/openai\/deployments(\/|$)/i.test(u.pathname);
+  return 애저호스트.test(u.hostname);
 }
 
 function 뜯기(s) {

package/src/backend/cachemark.js

@@ -123,7 +123,8 @@ export const 조각표 = Symbol.for('deel.시스템조각');
 const 붙일수있나 = (b) => {
   const t = b?.type;
   if (t === 'thinking' || t === 'redacted_thinking') return false;
-  if (t === 'text') return String(b.text ?? '').length > 0;
+  // 빈칸만 든 글도 빈 글이다 — 서버는 그런 글 블록 자체를 거절한다 (2.0.0 6회차 캐시표식6).
+  if (t === 'text') return String(b.text ?? '').trim().length > 0;
   return t === 'tool_result' || t === 'tool_use' || t === 'image' || t === 'document';
 };
 
@@ -159,8 +160,18 @@ export const 닻블록 = 14;
 /** 대화가 이 블록 수를 넘으면 닻을 하나 더 박는다. 그 아래면 꼬리 하나로 닿는다. */
 export const 닻문턱 = 20;
 
-/** 메시지 하나가 몇 블록인가. 글 한 덩이짜리는 1블록이다. */
-const 블록수 = (m) => (Array.isArray(m?.content) ? m.content.length : 1);
+/**
+ * 메시지 하나가 몇 블록인가. 글 한 덩이짜리는 1블록이다.
+ *
+ * OpenAI 꼴에서 도구를 부른 차례는 부름이 content 가 아니라 `tool_calls` 에 있고, 서버 쪽에서는
+ * 부름 하나하나가 블록이 된다. 1블록으로 세면 부름이 셋인 대화에서 닻→꼬리가 24블록이 되어
+ * 창(20) 밖에 박혔다 (2.0.0 6회차 캐시표식6). 글과 부름을 같이 센다.
+ */
+const 블록수 = (m) => {
+  if (Array.isArray(m?.content)) return m.content.length;
+  const 부름 = Array.isArray(m?.tool_calls) ? m.tool_calls.length : 0;
+  return (m?.content ? 1 : 0) + 부름 || 1;
+};
 
 /** 이 배열이 통틀어 몇 블록인가. */
 const 통블록 = (ms) => ms.reduce((n, m) => n + 블록수(m), 0);
@@ -197,7 +208,16 @@ export function 블록에붙이기(msg, 칸 = 'cache_control') {
  * @param {boolean} 표식쓰나
  */
 export function 시스템블록(조각들, 표식쓰나, 칸 = 'cache_control', { 긴수명 = true } = {}) {
-  const 있는것 = (조각들 ?? []).map((x) => String(x ?? '')).filter((x) => x.length);
+  /*
+   * 빈칸만 든 조각은 **없는 것으로 친다.**
+   *
+   * 잣대가 `x.length` 였다. 그러면 `'   '` · `'\n'` 이 그대로 지나 빈칸만 든 글
+   * 블록이 되는데, Anthropic 은 그것을 400 으로 튕긴다 — 화면에서는 열쇠가 틀린 것과
+   * 구별이 안 되는 400 이다. 조각이 전부 빈칸이면 **그 첫 조각에 캐시 표식까지** 붙어
+   * 나갔다. 조각 안의 빈칸은 안 건드린다 — 글자를 한 자라도 바꾸면 앞머리가 통째로
+   * 새로 엮인다(아래 굳은끝 머리말).
+   */
+  const 있는것 = (조각들 ?? []).map((x) => String(x ?? '')).filter((x) => x.trim().length);
   if (!있는것.length) return null;
   if (!표식쓰나) return 있는것.join('');
   const 굳은끝 = 0;   // 첫 조각이 굳은 부분이다
@@ -281,7 +301,13 @@ function 닻자리(ms, 꼬리) {
   let 센것 = 0;
   for (let i = 꼬리; i >= 0; i--) {
     센것 += 블록수(ms[i]);
-    if (센것 >= 닻블록) return i;
+    /*
+     * 꼬리 **한 메시지**가 벌써 닻블록을 넘으면(병렬 도구 결과 수십 개) 꼬리를 고르면 안 된다 —
+     * 표식은 메시지의 마지막 블록에만 붙으니 그건 꼬리 표식과 같은 자리라 닻이 사라지고, 꼬리의
+     * 20블록 창은 그 메시지 안에서 끝나 앞 요청이 굳힌 자리에 못 닿는다 (2.0.0 6회차 캐시표식6).
+     * 한 칸 앞에 박으면 그 닻이 앞 요청의 꼬리를 읽어 온다.
+     */
+    if (센것 >= 닻블록) return i === 꼬리 ? Math.max(0, i - 1) : i;
   }
   return 0;
 }

package/src/backend/clientcert.js

@@ -65,7 +65,12 @@ export function 인증서설정(prof) {
    * 하나뿐이었다 — 그건 프로필마다 다르게 못 준다. 사내 게이트웨이와 로컬
    * 모델을 오가는 사람에게는 그게 곧 못 쓰는 것이다.
    */
-  if (!편것.cert && !편것.pfx && !편것.ca) return null;
+  /*
+   * 개인키만 적은 것도 **버리지 않는다** (사냥5 B5-09). 여기서 null 로 돌리면 사람이 적은
+   * key 가 조용히 사라지고, 게이트웨이는 「인증서를 내라」 는 악수 실패만 준다. 들고 가서
+   * 인증서찾기 가 「반쪽이다」 라고 말하게 한다.
+   */
+  if (!편것.cert && !편것.pfx && !편것.ca && !편것.key) return null;
   return 편것;
 }
 
@@ -127,6 +132,23 @@ export function 인증서찾기(주소) {
   const o = 집(주소);
   const 설정 = o ? 등록부.get(o) : null;
   if (!설정) return null;
+  /*
+   * 반쪽만 적었으면 붙기 전에 말한다 (사냥5 B5-09).
+   *
+   * 인증서만 적고 개인키를 안 적으면 Node 는 인증서를 **아예 안 낸다.** 게이트웨이는
+   * 「인증서를 내라」 는 경보로 끊고, 그 화면으로는 무엇이 빠졌는지 알 길이 없다. 개인키만
+   * 적은 것도 같다. pfx 는 한 덩이에 둘 다 들었으므로 따지지 않는다. 경로가 틀린 것과 같은
+   * 「설정을 고칠 일」 이라 같은 코드로 던진다 — 화면(http.js normalizeError)이 말을 그대로 싣고,
+   * 다시 불러 봐야 소용없다는 것도 같다.
+   */
+  if (!설정.pfx && !!설정.cert !== !!설정.key) {
+    const 있는것 = 설정.cert ? '인증서(cert)' : '개인키(key)';
+    const 빠진것 = 설정.cert ? '개인키(key)' : '인증서(cert)';
+    throw Object.assign(
+      new Error(`클라이언트 ${있는것}만 적혀 있고 ${빠진것}가 없습니다 — 프로필 "인증서" 에 둘을 함께 적거나 pfx 한 덩이로 적으세요`),
+      { code: 'CERT_READ' },
+    );
+  }
   const 옵션 = {};
   if (설정.pfx) 옵션.pfx = 파일읽기(설정.pfx, '클라이언트 인증서(pfx)');
   if (설정.cert) 옵션.cert = 파일읽기(설정.cert, '클라이언트 인증서');

package/src/backend/ctxsize.js

@@ -62,6 +62,20 @@ const 출력이름 = [
   'num_predict', 'n_predict', 'max_output_length',
 ];
 
+/*
+ * 이름 **앞에 뭐가 붙어 와도** 같은 뜻으로 본다 (`qwen3.context_length` · `llm.n_ctx`).
+ *
+ * 잣대를 목록마다 따로 둔다. 전에는 최대 쪽 잣대 하나뿐이라 `llm.n_ctx` 가
+ * 「모델 최대」 로만 걸리고 「올린 길이」 에서는 안 걸렸다 — 숫자 하나가
+ * 「최대 8,192 · 올린 길이 모름」 이 되고, /ctx 자세히 가 그대로 찍었다.
+ * 글자 덩어리 쪽(글에서찾기)은 원래 앞에 붙은 것을 넘기고 읽는다. 두 잣대가
+ * 갈리면 '객체로 오면 못 찾고 글로 오면 찾는' 설명 못 할 상태가 된다.
+ */
+const 꼬리잣대 = new Map([
+  [최대이름, /(^|[._])(context_length|context_window|n_ctx)$/i],
+  [올린이름, /(^|[._])(loaded_context_length|num_ctx|n_ctx)$/i],
+]);
+
 // 사람이 알아볼 수 없는 값은 안 받는다. 512 미만은 오독, 1000만 초과는 단위 착각.
 const 최소 = 512;
 const 최대허용 = 10_000_000;
@@ -114,9 +128,10 @@ export function 파보기(obj, 이름들, { 글도 = true, depth = 0 } = {}) {
     const v = 성한수(obj[key]);
     if (v) return { value: v, key };
   }
+  const 꼬리 = 꼬리잣대.get(이름들);
   for (const [k, v] of Object.entries(obj)) {
-    // 이름이 정확히 안 맞으면 '…context_length' 처럼 끝나는 것도 본다 (Ollama).
-    if (이름들 === 최대이름 && /(^|[._])(context_length|context_window|n_ctx)$/i.test(k)) {
+    // 이름이 정확히 안 맞으면 '…context_length' 처럼 끝나는 것도 본다 (Ollama · 꼬리잣대 머리말).
+    if (꼬리 && 꼬리.test(k)) {
       const n = 성한수(v);
       if (n) return { value: n, key: k };
     }
@@ -229,7 +244,9 @@ export async function probeCtx(conn, { timeout = 6000 } = {}) {
   const 답들 = await Promise.all(자리.map(([label, url, opts]) => 본다(label, url, opts)));
 
   let max = null; let loaded = null; let out = null;
-  let source = null; let outSource = null; let maxKey = null; let loadedKey = null;
+  let outSource = null; let maxKey = null; let loadedKey = null;
+  // 값마다 어느 창구에서 왔는지 따로 든다 — 아래에서 **채택한 값**의 창구만 내보낸다.
+  let 최대창구 = null; let 올린창구 = null;
 
   for (const [i, [label]] of 자리.entries()) {
     const json = 답들[i].json;
@@ -241,15 +258,24 @@ export async function probeCtx(conn, { timeout = 6000 } = {}) {
     const m = 파보기(대상, 최대이름);
     const l = 파보기(대상, 올린이름);
     const o = 파보기(대상, 출력이름);
-    if (m && !max) { max = m.value; maxKey = m.key; source = label; }
-    if (l && !loaded) { loaded = l.value; loadedKey = l.key; }
+    if (m && !max) { max = m.value; maxKey = m.key; 최대창구 = label; }
+    if (l && !loaded) { loaded = l.value; loadedKey = l.key; 올린창구 = label; }
     // llama.cpp 의 n_ctx 는 '지금 올린 길이' 다. 그 서버에서는 최대도 그 값으로 본다.
-    if (올린것도 && m && !loaded) { loaded = m.value; loadedKey = m.key; }
+    if (올린것도 && m && !loaded) { loaded = m.value; loadedKey = m.key; 올린창구 = label; }
     if (o && !out) { out = o.value; outSource = label; }
   }
 
   // 실제로 쓸 값: 올려 둔 길이가 있으면 그것. 없으면 모델 최대.
   const value = loaded ?? max ?? null;
+  /*
+   * source 는 **채택한 값**이 어디서 왔는지다.
+   *
+   * 여태는 최대를 준 창구 이름을 적었다. 모델 상세가 655,360(최대)을, LM Studio 가
+   * 8,192(올린 길이)를 주면 쓰는 값은 8,192 인데 화면은 「모델 상세에서 읽음」 이라
+   * 적었다 (repl.js · commands/model.js 가 이 칸을 그대로 찍는다). 값이 이상할 때
+   * 사람이 뒤지러 가는 자리가 바로 이 이름이라, 틀리면 엉뚱한 창구를 판다.
+   */
+  const source = loaded ? 올린창구 : (max ? 최대창구 : null);
   /*
    * 못 알아낸 까닭. **서버 탓으로 뭉개지 않는다.**
    *
@@ -260,10 +286,20 @@ export async function probeCtx(conn, { timeout = 6000 } = {}) {
    * 이상한 줄 알고 서버를 뒤진다.
    */
   const 문지기가막음 = tried.length > 0 && tried.every((t) => t.막힘);
+  /*
+   * 404 로 **답한** 것과 아무 말도 없는 것도 다르다.
+   *
+   * 여섯 자리가 전부 404 를 돌려줬는데 이 자리는 「아무 응답도 못 받았습니다」 였다.
+   * 서버는 또박또박 「그런 문은 없다」 고 말했는데, 사람은 서버가 죽었거나
+   * 방화벽이 삼킨 줄 알고 서버를 뒤지러 간다. 받은 코드를 그대로 적으면
+   * 「길이를 알려 주는 문이 없는 서버」 라는 것이 한눈에 보인다.
+   */
+  const 답한코드 = [...new Set(tried.filter((t) => t.status > 0).map((t) => t.status))];
   const why = value ? null
     : 문지기가막음 ? '이 주소로 나갈 허락이 아직 없어서 물어보지도 못했습니다'
       : tried.some((t) => t.ok) ? '서버가 응답은 했지만 길이를 안 알려 줍니다'
-        : '두드린 자리에서 아무 응답도 못 받았습니다';
+        : 답한코드.length ? `서버는 답했지만 길이를 알려 주는 문이 없습니다 (HTTP ${답한코드.join('·')})`
+          : '두드린 자리에서 아무 응답도 못 받았습니다';
 
   return { value, max, loaded, out, source, outSource, maxKey, loadedKey, tried, why };
 }
@@ -281,7 +317,7 @@ export function parseSize(text) {
   return 성한수(Number(m[1]) * mult);
 }
 
-/** 33k · 655k · 1.0M — 화면에 넣을 짧은 표기 */
+/** 32k · 640k · 1.0M — 화면에 넣을 짧은 표기 */
 export function fmtSize(n) {
   const v = Number(n) || 0;
   if (v < 1000) return String(v);
@@ -289,5 +325,16 @@ export function fmtSize(n) {
   return (v / (1024 * 1024)).toFixed(1) + 'M';
 }
 
-/** 서버가 끝내 안 알려 줄 때 쓰는 값. 옛날 32768 보다는 요즘 기본에 가깝다. */
+/*
+ * 서버가 끝내 안 알려 줄 때 쓰는 값.
+ *
+ * **더 안 올린다.** 요즘 로컬 창구가 실제로 **올려 두는** 길이는 이보다 작다 —
+ * Ollama 의 num_ctx, llama.cpp 서버의 --ctx-size, LM Studio 가 처음 올릴 때 잡는
+ * 값이 다 4,096 언저리다. 모델이 655,360 까지 된다는 것과 서버가 그만큼 올려
+ * 뒀다는 것은 다른 말이다(맨 위 머리말).
+ *
+ * 여기는 **아무것도 못 알아냈을 때** 쓰는 값이라 큰 쪽으로 틀리면 매 요청이
+ * 거절당하고, 작은 쪽으로 틀리면 덜 쓸 뿐이다. 그리고 덜 쓰는 쪽은 3겹
+ * (backend/learn.js)이 서버의 거절문에서 곧 배워 올린다 — 반대쪽은 못 배운다.
+ */
 export const 기본값 = 32768;

package/src/backend/detect.js

@@ -49,12 +49,16 @@ async function tryAzure(input, key) {
   let 닿음 = false;              // 서버가 HTTP 로 대답을 하기는 했나
   const 막힌것 = [];             // 거절당한 방식들 — 다 해 보고 고른다
   let 마지막오류 = null;
+  // 200 인데 JSON 이 아닌 답 — 사내 로그인 페이지·프록시 안내면이 가로챈 것 (아래 끝 머리말).
+  let 글로답함 = false;
 
   for (const style of 차례) {
     if (style.id !== 'none' && !key) continue;
     const r = await req(푼것.목록주소, { headers: headersFor(style.id, key), timeout: 12000 });
     if (r.status) 닿음 = true;
     else 마지막오류 = r.error ?? 마지막오류;
+    // 아무도 답한 적 없이 시간이 다 됐으면 머리를 바꿔 12초씩 더 기다리지 않는다 (시간다됨 머리말).
+    if (!닿음 && 시간다됨(r)) break;
 
     if (r.ok && r.json) {
       const models = 배포목록(r.json);
@@ -68,7 +72,20 @@ async function tryAzure(input, key) {
           + ' Azure 포털에서 모델을 배포한 뒤 다시 해 보세요.',
       };
     }
-    if ([401, 403, 404].includes(r.status)) 막힌것.push({ auth: style.id, status: r.status, ms: r.ms });
+    /*
+     * 거절당한 것은 **코드를 가리지 않고** 적어 둔다.
+     *
+     * 여태는 401·403·404 만 담았다. 그래서 앞단이 아파서 낸 500·502 는 담기는
+     * 자리가 없었고, 아래에서 「무엇을 봤는지」 를 말할 때 그 자리가 통째로
+     * 비어 있었다 — 서버가 아픈 것이 주소를 잘못 적은 것으로 읽혔다.
+     *
+     * 200 인데 JSON 이 아닌 것(사내 로그인 페이지)은 여기 안 들어온다. 그건
+     * 거절이 아니라 **다른 서버가 답한 것**이라, 인증 방식을 고르는 표에
+     * 섞이면 안 된다.
+     */
+    if (r.status && !r.ok) 막힌것.push({ auth: style.id, status: r.status, ms: r.ms });
+    // 그래도 **본 것**이다. 아래 끝에서 이 한 가지만은 말해 준다 (사냥6 막판-뒷단).
+    else if (r.ok && !r.json) 글로답함 = true;
   }
 
   // 아무도 못 닿았다. 이건 목록 권한 문제가 아니라 연결 문제다.
@@ -101,10 +118,93 @@ async function tryAzure(input, key) {
       warn: 다막힘 && key
         ? `배포 목록도 인증도 확인 못 했습니다 (해 본 방식마다 HTTP ${막힌것.map((x) => x.status).join('·')})`
           + ' — 주소에 적힌 배포로 그냥 씁니다. 첫 한마디에서 걸리면 /model 로 인증 방식을 바꾸세요.'
-        : `배포 목록을 못 봤습니다 (HTTP ${고른것.status}) — 주소에 적힌 배포로 그냥 씁니다.`,
+        /*
+         * 열쇠 없이 두드려 401·403 을 받았으면 그렇다고 말한다. 「목록을 못 봤다」 만 적으면 첫
+         * 한마디의 401 을 사람이 짐작해야 한다 — 서버는 이미 열쇠가 없다고 말했다 (6회차 Gemini 알아내기6 D1).
+         */
+        : !key && (고른것.status === 401 || 고른것.status === 403)
+          ? `열쇠 없이 두드렸더니 배포 목록이 HTTP ${고른것.status} 입니다 — 주소에 적힌 배포로 그냥 씁니다.`
+            + ' 첫 한마디에서도 막히면 열쇠(api-key)를 넣으세요.'
+          : `배포 목록을 못 봤습니다 (HTTP ${고른것.status}) — 주소에 적힌 배포로 그냥 씁니다.`,
     };
   }
-  return null;
+
+  /*
+   * ── 여기까지 왔다는 것은 **배포를 못 집었다**는 뜻이다 ──────────────────
+   *
+   * 사람이 본 것: 포털에서 자원 주소만(배포 이름 없이) 복사해 넣고 열쇠가
+   * 틀렸을 때, 화면은 「Azure 주소로 보이는데 배포를 못 찾았습니다 — 주소에
+   * /openai/deployments/<배포이름> 까지 넣어 보세요」 였다. 시키는 대로 주소를
+   * 고쳐 넣어도 아무것도 안 바뀐다. 서버는 세 방식 모두에 401 을 냈고, 그건
+   * 주소 이야기가 아니라 **열쇠 이야기**였다.
+   *
+   * 왜 그랬나: 배포를 못 집으면(푼것.base 가 없으면) 위 갈래에 못 들어가고
+   * 여기서 그냥 `null` 이 나갔다. 세 번 두드려 받아 온 상태 코드를 **통째로
+   * 버린 것**이다. 부르는 쪽(detect)은 받은 것이 없으니 제가 아는 짐작 한
+   * 줄을 적었고, 그 짐작이 틀리는 자리가 바로 여기다.
+   *
+   * 이제 지키는 규칙: **본 것을 그대로 들고 나간다.** 상태 코드로 말하고,
+   * 주소를 고치라는 말은 그 말이 들을 만한 자리(404)에서만 한다. 상태 코드도
+   * 함께 넘겨서 부르는 쪽이 제 표로 옮길 수 있게 한다 (providers 의 막힌까닭).
+   */
+  const 본상태 = 막힌것.map((x) => x.status);
+  /*
+   * ── 200 으로 답한 자리에 「주소를 고쳐 보세요」 라고 하지 않는다 (사냥6 막판-뒷단) ──
+   *
+   * 사내 SSO·프록시가 배포 목록 요청을 가로채 **200 으로 로그인 페이지**를 준다. 그건
+   * 거절이 아니라 위 막힌것 에 안 담기고(그건 맞다 — 인증 방식 표에 섞이면 안 된다),
+   * 그래서 여기서 `null` 이 나갔다. 부르는 쪽(detect)은 받은 것이 없으니 제 짐작 —
+   * 「주소에 /openai/deployments/<배포이름> 까지 넣어 보세요」— 를 적었는데, 주소에는
+   * 이미 그 길이 적혀 있고 서버는 200 으로 또박또박 답했다. 시키는 대로 고쳐도 아무것도
+   * 안 바뀐다. 바로 위 머리말이 「주소를 고치라는 말은 404 에서만」 이라고 못 박은 그 자리다.
+   *
+   * 본 것을 그대로 말한다. 여기서 사람이 할 일은 주소를 고치는 것이 아니라 **브라우저로
+   * 같은 주소를 열어 무엇이 뜨는지 보는 것**이다.
+   */
+  if (!본상태.length) {
+    if (!글로답함) return null;
+    return {
+      kind: null,
+      status: 200,
+      why: '배포 목록 자리가 HTTP 200 으로 답했는데 JSON 이 아닙니다 — Azure 가 아니라'
+        + ' 사내 로그인 페이지나 프록시 안내면이 가로챈 것으로 보입니다.'
+        + ' 브라우저로 같은 주소를 열어 무엇이 뜨는지 보세요 — 주소를 고쳐도 이 답은 안 바뀝니다.',
+    };
+  }
+  const 대표 = 본상태.find((s) => s >= 500)
+    ?? 본상태.find((s) => s === 401 || s === 403)
+    ?? 본상태[0];
+  return { kind: null, status: 대표, why: 애저막힌말(대표, 본상태) };
+}
+
+/** 배포를 못 집은 채 끝났을 때 무슨 말을 하나. 본 것만 말한다 — 짐작을 안 보탠다. */
+function 애저막힌말(대표, 본상태) {
+  const 본것 = 본상태.length > 1
+    ? `해 본 방식마다 HTTP ${본상태.join('·')}`
+    : `HTTP ${대표}`;
+  if (대표 >= 500) {
+    return `자원에는 닿았는데 배포 목록에서 서버가 오류를 냈습니다 (${본것})`
+      + ' — 주소가 아니라 서버 쪽입니다. 잠시 뒤 다시 해 보세요.';
+  }
+  if (대표 === 401 || 대표 === 403) {
+    return `자원에는 닿았는데 열쇠를 안 받아 줍니다 (${본것})`
+      + ' — 주소가 아니라 열쇠를 보세요. 배포 이름을 붙여도 이 답은 안 바뀝니다.';
+  }
+  if (대표 === 404) {
+    return `배포 목록을 못 봤습니다 (${본것})`
+      + ' — 주소에 /openai/deployments/<배포이름> 까지 넣어 보세요.';
+  }
+  /*
+   * 404 가 아니면 **주소 이야기가 아니다.**
+   *
+   * 429 는 앞단이 지금 못 받는다는 말이고 400 은 우리가 보낸 것을 못 읽었다는
+   * 말이다. 둘 다 배포 이름을 붙여도 답이 안 바뀐다. 그런데도 이 자리는 코드를
+   * 가리지 않고 「주소에 배포 이름을 넣어 보세요」 로 끝났다 — 바로 위 머리말이
+   * 「그 말은 들을 만한 자리(404)에서만 한다」 고 적어 둔 그 약속을 깬 것이다.
+   * 시키는 대로 주소를 고쳐 넣어도 아무것도 안 바뀐다.
+   */
+  return `배포 목록을 못 봤습니다 (${본것})`
+    + ' — 404 가 아니라 주소 이야기가 아닙니다. 서버가 낸 코드를 그대로 보세요.';
 }
 
 /*
@@ -121,11 +221,53 @@ async function tryAzure(input, key) {
  * 하나는 0(닿지도 못함)일 수 있는데, 401 쪽이 훨씬 쓸모 있는 단서다 — 적어도
  * 서버가 거기 있다는 뜻이니까.
  */
-function 막은것적기(막힌것, r) {
+export function 막은것적기(막힌것, r) {
   if (!막힌것) return;
   const 말 = (r.status ? serverMessage(r) : r.error) ?? '';
-  if (!막힌것.status && r.status) { 막힌것.status = r.status; 막힌것.why = 말; }
+  /*
+   * ── 404 는 약한 단서다 ────────────────────────────────────────────────
+   *
+   * 사람이 본 것: `/v1/models` 는 404(길 없음), `/models` 는 401(열쇠 틀림)인 게이트웨이에서
+   * 화면이 「no route」 · HTTP 404 — 주소 탓 — 로 끝났다. 서버는 열쇠를 안 받는다고 분명히
+   * 말했는데, 후보 차례상 404 를 먼저 받았고 여기가 **처음 받은 것만** 적었다
+   * (6회차 Gemini 알아내기6 D4). 사람은 주소를 고치러 가고 열쇠는 안 본다.
+   *
+   * 이제 지키는 규칙: 404·405 와 2xx·3xx(다른 무엇이 답함)는 「이 길이 아니다」 일 뿐이라,
+   * 뒤에 401·403·5xx 같은 **그 서버가 제 말로 거절한 것**이 오면 그걸로 바꿔 적는다.
+   * 그 밖에는 여전히 처음 것이 이긴다.
+   */
+  const 약한것 = (s) => s === 404 || s === 405 || (s > 0 && s < 400);
+  if (r.status && (!막힌것.status || (약한것(막힌것.status) && !약한것(r.status)))) { 막힌것.status = r.status; 막힌것.why = 말; }
   else if (!막힌것.status && !막힌것.why) 막힌것.why = 말;
+  // 아무도 답한 적 없는데 시간이 다 됐다 — 이 주소는 먹통이다(시간다됨 머리말). 한 번 답한 곳은 먹통이 아니다.
+  if (시간다됨(r) && !막힌것.status) 막힌것.먹통 = true;
+  /*
+   * ...그리고 뒤늦게라도 서버가 제 말로 답하면 그 표시는 **내린다.**
+   *
+   * 먹통의 뜻은 「아무도 답한 적 없는데 시간이 다 됐다」 이다. 그 뒤에 401 이
+   * 와서 status 가 채워져도 표시는 그대로 남아 있었다. 남은 표시 하나로 부르는
+   * 쪽(detect)은 나머지 후보를 통째로 건너뛰고 먹통끝() 으로 나간다 — 서버가
+   * 거기 있다고 방금 말했는데 화면은 「닿지도 못했다」 로 끝난다.
+   */
+  else if (r.status && 막힌것.먹통) 막힌것.먹통 = false;
+}
+
+/*
+ * ── 안 답하는 곳을 인증 방식마다 또 기다리지 않는다 ─────────────────────
+ *
+ * 사람이 본 것: 방화벽이 삼키는 주소(VPN 이 반쯤 올라온 자리)를 넣었더니 설치 화면이 3분 넘게
+ * 멈췄다가 「시간 초과」 한 줄로 끝났다.
+ *
+ * 실제로 있었던 일: 후보 주소 셋 × 인증 방식 넷을 하나씩 12초씩 기다렸다 — 일반 주소 188초(16번),
+ * Azure 36초(3번) (6회차 Gemini 알아내기6 D3). 후보들은 **같은 호스트·포트**에 길만 다르고, 머리
+ * 하나 · 길 하나 바꾼다고 안 답하던 곳이 답하지 않는다.
+ *
+ * 이제 지키는 규칙: 아무도 답한 적 없는 채 **시간이 다 되면** 그 주소는 거기서 끝. 곧장 오는 실패
+ * (연결 거절 · DNS)는 시간이 안 드니 그대로 둔다 — 고칠 것은 기다림이지 차례가 아니다.
+ */
+const 시간코드 = new Set(['TimeoutError', 'CONNECT_TIMEOUT', 'ETIMEDOUT', 'UND_ERR_CONNECT_TIMEOUT', 'UND_ERR_HEADERS_TIMEOUT', 'UND_ERR_BODY_TIMEOUT']);
+function 시간다됨(r) {
+  return !r?.status && 시간코드.has(r?.code);
 }
 
 /*
@@ -172,9 +314,15 @@ async function tryAnthropic(base, key, 막힌것 = null) {
       timeout: 12000,
     });
     막은것적기(막힌것, r);
-    if (r.ok && Array.isArray(r.json?.data)) {
-      return { kind: 'anthropic', base, auth, models: normalizeModels(r.json.data), ms: r.ms };
-    }
+    if (막힌것?.먹통) return null;   // 안 답하는 곳을 인증 방식마다 또 기다리지 않는다 (시간다됨 머리말)
+    /*
+     * 목록 **모양**을 본다 — tryOpenAI 와 같은 잣대(모델목록모양 머리말). `data` 가 배열이기만
+     * 보면 모든 길에 `{"data":[{"status":"ok"}]}` 를 주는 개발 서버가, OpenAI 쪽에서는 걸러지고
+     * 여기로 넘어와 「anthropic · 모델 0개」 로 붙었다 (6회차 Gemini 알아내기6 E3). 사냥5 B5-08 이
+     * 막은 고장이 뒷문으로 다시 들어온 것이다.
+     */
+    const 목록 = r.ok ? 모델목록모양(r.json) : null;
+    if (목록) return { kind: 'anthropic', base, auth, models: normalizeModels(목록), ms: r.ms };
   }
   return null;
 }
@@ -183,7 +331,18 @@ async function tryAnthropic(base, key, 막힌것 = null) {
 export function 앤트로픽같나(input, key) {
   if (/^sk-ant-/.test(String(key ?? '').trim())) return true;
   try {
-    const u = new URL(/^https?:\/\//i.test(input) ? String(input) : 'https://' + String(input));
+    /*
+     * 주소는 **candidates() 와 똑같이** 다듬고 본다.
+     *
+     * detect 는 origin 만 trim 하고 원본 input 은 그대로 여기로 넘긴다. 그래서
+     * 앞뒤에 빈칸이 붙은 ` api.anthropic.com ` 은 여기서 URL 이 안 만들어져
+     * false 가 됐다 — 정작 실제로 두드릴 주소는 candidates() 가 빈칸을 털어
+     * 제대로 만든다. 단서를 잃으면 Anthropic 규격을 먼저 볼 기회를 놓치고,
+     * OpenAI 쪽이 `{data:[...]}` 를 내주면 규격이 거기서 굳는다.
+     * setup --url 은 사람이 붙여 넣은 글을 trim 도 안 하고 준다.
+     */
+    const 주소 = String(input ?? '').trim().replace(/\s+/g, '');
+    const u = new URL(/^https?:\/\//i.test(주소) ? 주소 : 'https://' + 주소);
     if (/(^|\.)anthropic\.com$/i.test(u.hostname)) return true;
     /*
      * AWS mantle 의 Anthropic 창구. 길에 규격 이름이 적혀 있다.
@@ -204,6 +363,27 @@ export function 앤트로픽같나(input, key) {
   } catch { return false; }
 }
 
+/**
+ * 받은 JSON 이 **모델 목록 모양**인가. 맞으면 그 목록, 아니면 null (사냥5 B5-08).
+ *
+ * `r.json.data ?? r.json.models ?? []` 로 읽었더니 없는 칸이 곧 빈 목록이 됐다. 그래서
+ * 모든 길에 `{"status":"ok"}` 나 `[]` 를 주는 개발 서버가 「openai · 모델 0개」 로 붙었고,
+ * 사람은 모델이 안 올라온 줄 알고 엉뚱한 서버를 뒤졌다.
+ *
+ * 빈 목록은 받는다 — 모델을 아직 안 올린 LM Studio 가 실제로 `{"data":[]}` 를 준다.
+ * 그러나 **칸은 있어야** 하고, 원소가 있으면 적어도 하나는 이름(id·name·model)을 가져야
+ * 한다. scan.js 도 같은 잣대를 쓴다 — 설치와 훑기가 서로 다른 서버를 LLM 이라 부르면 안 된다.
+ */
+export function 모델목록모양(json) {
+  if (!json || typeof json !== 'object' || Array.isArray(json)) return null;
+  const list = Array.isArray(json.data) ? json.data : (Array.isArray(json.models) ? json.models : null);
+  if (!list) return null;
+  const 이름있나 = (m) => (typeof m === 'string' && m.length > 0)
+    || (!!m && typeof m === 'object' && !!(m.id ?? m.name ?? m.model));
+  if (list.length && !list.some(이름있나)) return null;
+  return list;
+}
+
 // OpenAI 호환인지 확인 (GET {base}/models). 막힌것은 막은것적기 머리말 참고.
 async function tryOpenAI(base, key, 막힌것 = null) {
   const 적기 = (r) => 막은것적기(막힌것, r);
@@ -212,12 +392,9 @@ async function tryOpenAI(base, key, 막힌것 = null) {
     if (style.id === 'none' && key) { /* 키를 줬어도 인증 없는 서버일 수 있으니 마지막에 본다 */ }
     const r = await req(`${base}/models`, { headers: headersFor(style.id, key), timeout: 12000 });
     적기(r);
-    if (r.ok && r.json) {
-      const list = r.json.data ?? r.json.models ?? [];
-      if (Array.isArray(list)) {
-        return { kind: 'openai', base, auth: style.id, models: normalizeModels(list), ms: r.ms };
-      }
-    }
+    if (막힌것?.먹통) return null;   // 안 답하는 곳을 인증 방식마다 또 기다리지 않는다 (시간다됨 머리말)
+    const 목록 = r.ok ? 모델목록모양(r.json) : null;
+    if (목록) return { kind: 'openai', base, auth: style.id, models: normalizeModels(목록), ms: r.ms };
     // 401/403 이면 규격은 맞고 인증만 틀린 것 — 다음 방식으로 계속.
     //
     // 그 밖의 오류(500 등)는 '규격은 맞는데 서버가 지금 화가 난 것' 으로 본다.
@@ -237,9 +414,53 @@ async function tryOpenAI(base, key, 막힌것 = null) {
      * 실제로 이 길로 온다.
      */
     if (r.status === 400 && /anthropic-version/i.test(serverMessage(r) ?? '')) return null;
-    const 성공인데JSON아님 = r.status >= 200 && r.status < 300 && !r.json;
-    if (r.status && !성공인데JSON아님 && ![401, 403, 0, 404].includes(r.status)) {
-      return { kind: 'openai', base, auth: style.id, models: [], ms: r.ms, warn: serverMessage(r) };
+    /*
+     * 2xx 인데 위에서 목록 모양이 아니었으면(JSON 이든 아니든) 이 규격이 아니다. 3xx 도
+     * 같다 — 되돌림을 안 따라가므로, 모든 길을 `/login` 으로 보내는 관리 화면이 「HTTP 302」
+     * 경고를 단 openai 로 굳었다. 둘 다 서버가 **다른 무엇**이라는 말이지 화가 난 것이
+     * 아니다 (사냥5 B5-08).
+     */
+    /*
+     * 405 도 같다. `/models` 가 GET 을 안 받는다는 말이라 모델 목록 문이 아니다 — 404 처럼 「이 길이
+     * 아니다」 로 보고 다음으로 간다. 여태는 LLM 이 아닌 서버가 「openai · 인증 bearer」 초록색으로
+     * 붙었고 짐작 표시도 없었다 (6회차 Gemini 알아내기6 E1). 400·402 는 그대로 둔다 — 서버가 요청을
+     * 읽고 제 말로 답한 것이다(아래 머리말과 detect.test 의 402 검사).
+     */
+    const 이규격아님 = (r.status >= 200 && r.status < 400) || r.status === 405;
+    if (r.status && !이규격아님 && ![401, 403, 0, 404].includes(r.status)) {
+      /*
+       * ── 답을 했다는 것과 **이 규격이라는 것**은 다른 말이다 ──────────────
+       *
+       * 사람이 본 것: 설치 화면이 초록색 「연결됨 · 인증 bearer」 로 끝나고,
+       * 그 값이 프로필에 그대로 저장됐다. 그런데 첫 한마디부터 401 이다.
+       * 열쇠를 다시 발급받고, 다시 넣고, 또 401 이다 — 화면 어디에도 인증
+       * 방식을 우리가 **찍었다**는 말이 없으니 열쇠만 의심하게 된다.
+       *
+       * 실제로 있었던 일: `/models` 에 503 이 왔다. 5xx·429 는 앞단 프록시나
+       * 로드밸런서도 낸다. 그 한 마디로 알 수 있는 것은 「거기 무언가가 있다」
+       * 뿐인데, 우리는 규격을 openai 로 못 박고 **그때 쓰던 인증 방식**을
+       * 같이 적어 뒀다. 차례상 맨 앞이라 대개 bearer 였다. 서버가 그 방식을
+       * 받는다고 말한 적은 한 번도 없다.
+       *
+       * 이제 지키는 규칙: 서버가 한 말은 그대로 싣되, **짐작은 짐작이라고
+       * 적는다.** 5xx·429 는 규격도 인증도 확인된 것이 아니다 — 그 한 줄이
+       * 있으면 사람은 첫 401 에서 열쇠 대신 인증 방식을 먼저 본다.
+       */
+      const 서버말 = serverMessage(r);
+      const 짐작 = r.status >= 500 || r.status === 429;
+      return {
+        kind: 'openai',
+        base,
+        auth: style.id,
+        models: [],
+        ms: r.ms,
+        짐작,
+        warn: 짐작
+          ? `${서버말}\n서버가 HTTP ${r.status} 만 돌려줘서 규격도 인증도 확인 못 했습니다`
+            + ` — 인증은 '${style.id}' 로 짐작해 적어 둡니다. 첫 한마디에서 401 이 나면`
+            + ' 열쇠보다 /model 의 인증 방식을 먼저 보세요.'
+          : 서버말,
+      };
     }
   }
   return null;
@@ -281,9 +502,12 @@ export async function detect(input, key) {
     const hit = await tryAzure(input, key);
     if (hit?.kind) return { ...hit, tried };
     // 못 붙은 이유를 tryAzure 가 알고 있으면 그 말을 쓴다. 우리가 아는 것보다 정확하다.
+    // 상태 코드도 같이 넘긴다 — 401 을 받은 자리에 「주소를 고쳐 보세요」 라고
+    // 적던 것이 이 자리의 고장이었다 (tryAzure 끝의 머리말).
     return {
       kind: null,
       tried,
+      status: hit?.status ?? 0,
       why: hit?.why ?? 'Azure 주소로 보이는데 배포를 못 찾았습니다 — 주소에 /openai/deployments/<배포이름> 까지 넣어 보세요.',
     };
   }
@@ -293,22 +517,31 @@ export async function detect(input, key) {
   const 막힌것 = { status: 0, why: '' };
 
   // 단서가 있으면 이 규격을 먼저 본다 (tryAnthropic 머리말).
+  // 후보들은 같은 호스트·포트에 길만 다르다. 한 번 먹통이면 나머지 후보도 같은 답이다 (시간다됨 머리말).
+  const 먹통끝 = () => ({ kind: null, tried, status: 막힌것.status, why: 막힌것.why });
+
   if (앤트로픽같나(input, key)) {
     for (const base of candidates(input)) {
       tried.push(base);
       const hit = await tryAnthropic(base, key, 막힌것);
       if (hit) return { ...hit, tried };
+      if (막힌것.먹통) return 먹통끝();
     }
   }
 
   // Ollama 를 먼저 본다 — 로컬이면 대개 이쪽이고 확인이 빠르다.
-  const oll = await tryOllama(/^https?:\/\//i.test(origin) ? origin : 'http://' + origin);
+  // 두드린 자리는 여기서도 적는다. 이 갈래만 안 적어서, Ollama 로 붙으면
+  // 「어디를 두드렸나」 화면(setup.js)이 이 갈래에서만 빈칸이었다.
+  const 올라마주소 = /^https?:\/\//i.test(origin) ? origin : 'http://' + origin;
+  if (!tried.includes(올라마주소)) tried.push(올라마주소);
+  const oll = await tryOllama(올라마주소);
   if (oll) return { ...oll, tried };
 
   for (const base of candidates(input)) {
     if (!tried.includes(base)) tried.push(base);
     const hit = await tryOpenAI(base, key, 막힌것);
     if (hit) return { ...hit, tried };
+    if (막힌것.먹통) return 먹통끝();
   }
 
   /*