deel-local-cli 0.9.0 → 1.0.0

package/src/backend/ctxsize.js

@@ -1,22 +1,26 @@
-// 모델이 한 번에 받아 줄 수 있는 길이(컨텍스트)를 서버에서 알아낸다.
+// 모델이 한 번에 받아 줄 수 있는 길이(컨텍스트)와 한 번에 낼 수 있는 답 길이를
+// 서버에서 알아낸다.
 //
 // 왜 파일을 따로 뒀는가:
 //
-// 이 숫자 하나가 프로그램 전체를 좌우한다. 이게 작으면 파일을 몇 개 못 읽히고,
-// 대화가 금방 접히고, 한 번에 쓸 수 있는 답 길이도 같이 줄어든다(effort.js 가
-// 이 값에서 상한을 계산한다). 예전에는 못 알아내면 32768 로 뒀는데, 요즘
-// 로컬 모델은 262,144 · 655,360 처럼 훨씬 크다. 32k 로 깔고 앉으면 모델이
-// 가진 것의 5% 만 쓰는 셈이다.
+// 이 숫자들이 프로그램 전체를 좌우한다. 컨텍스트가 작으면 파일을 몇 개 못 읽히고
+// 대화가 금방 접힌다. 답 길이 상한이 작으면 **큰 파일이 안 만들어진다.**
+// 못 알아내면 32,768 로 깔고 앉는데, 요즘 로컬 모델은 262,144 · 655,360 이 흔하다.
+// 그 상태로 쓰면 모델이 가진 것의 5% 만 쓰는 셈이다.
 //
-// 문제는 서버마다 이 숫자를 다른 이름, 다른 자리에 둔다는 것이다. 그래서
-// 한 군데만 보지 않고 아는 자리를 전부 훑는다. 한 번에 다 못 찾아도
-// 부분만 찾으면 그걸 쓴다.
+// 서버 규격을 하나하나 아는 방식으로는 못 따라간다:
+//   LM Studio · llama.cpp · vLLM · TGI · KoboldCpp · LocalAI · LiteLLM ·
+//   OpenRouter · 사내 게이트웨이, 그리고 아직 나오지 않은 것들.
+// 그래서 세 겹으로 간다.
 //
-//   OpenAI 호환    /v1/models/{id}  또는 /v1/models 목록 안의 그 항목
-//   LM Studio      /api/v0/models   (max_context_length · loaded_context_length)
-//   llama.cpp      /props           (n_ctx)
-//   vLLM           /v1/models       (max_model_len)
-//   Ollama         /api/show        (…​.context_length)
+//   1겹. 아는 자리를 훑는다            ← 이 파일
+//   2겹. 우리가 원하는 값을 지시한다    ← backend/adapter.js 의 num_ctx
+//   3겹. 거절당하면 그 말에서 배운다    ← backend/learn.js  ★ 이게 진짜 답
+//
+// 3겹이 핵심이다. 서버는 거절할 때 정답을 알려 준다 —
+//   "This model's maximum context length is 8192 tokens, however you requested 41003"
+// 이 방식은 **처음 보는 서버에서도 통한다.** 규격을 몰라도 되고, 새 서버가
+// 나와도 코드를 안 고쳐도 된다.
 //
 // '올린 길이' 와 '모델 최대' 를 구분한다. LM Studio 는 모델이 655,360 까지
 // 되더라도 8,192 로 올려 둘 수 있다. 그 상태에서 655,360 을 믿고 보내면
@@ -24,19 +28,37 @@
 // 따로 알려 준다 — 사용자가 서버에서 더 올린 다음 /ctx 로 맞출 수 있게.
 import { req, headersFor } from './http.js';
 
-// 이 이름들 중 하나면 컨텍스트 길이다. 순서가 곧 우선순위다.
+// 이 이름들 중 하나면 '모델이 낼 수 있는 최대 컨텍스트' 다. 순서가 곧 우선순위다.
 const 최대이름 = [
   'max_context_length',      // LM Studio
   'context_window',          // 일부 게이트웨이
   'context_length',          // llama.cpp·HF 계열
   'max_model_len',           // vLLM
   'max_input_tokens',        // LiteLLM·OpenRouter 계열
-  'n_ctx',                   // llama.cpp
+  'n_ctx_train',             // llama.cpp — 학습 때 길이
   'max_position_embeddings', // 모델 config 원본
   'max_sequence_length',
   'max_seq_len',
 ];
-const 올린이름 = ['loaded_context_length', 'n_ctx', 'context_length'];
+
+/**
+ * '지금 서버에 실제로 올려 둔 길이'.
+ *
+ * context_length 를 여기서 뺐다. 그건 **모델 최대**이지 올린 길이가 아니다.
+ * Ollama /api/show 가 그 이름으로 131,072 를 주는데 서버는 8,192 만 받는다.
+ * 그대로 믿으면 확신에 찬 오답이 된다 — 화면에는 "131,072 · 서버에서 읽음" 이
+ * 뜨고, 긴 대화에서 조용히 거절당한다. 못 찾았으면 못 찾았다고 해야 한다.
+ *
+ * 진짜 올린 길이는 대개 parameters 라는 **글자 덩어리** 안에 있다.
+ * 그래서 아래 글에서찾기() 가 필요하다.
+ */
+const 올린이름 = ['loaded_context_length', 'num_ctx', 'n_ctx'];
+
+// 한 번에 낼 수 있는 답 길이. 컨텍스트와 다른 축인데 전에는 아예 안 봤다.
+const 출력이름 = [
+  'max_output_tokens', 'max_completion_tokens', 'max_tokens',
+  'num_predict', 'n_predict', 'max_output_length',
+];
 
 // 사람이 알아볼 수 없는 값은 안 받는다. 512 미만은 오독, 1000만 초과는 단위 착각.
 const 최소 = 512;
@@ -50,28 +72,66 @@ function 성한수(v) {
 }
 
 /**
- * 객체 어디에 박혀 있어도 찾는다.
+ * 글자 덩어리 안에서 값을 찾는다.
+ *
+ * 서버가 값을 JSON 으로 안 주고 글로 주는 일이 흔하다. Ollama 가 그렇다 —
+ *   "parameters": "num_ctx                    8192\nstop  \"<|im_end|>\""
+ * 이건 JSON 으로 보면 그냥 긴 문자열 하나다. 파보기() 로는 영영 못 찾는다.
+ * 실제로 이것 때문에 8,192 서버에 131,072 를 보내고 있었다.
+ *
+ * llama.cpp 의 /props 나 일부 게이트웨이의 설명 필드도 같은 모양이다.
+ */
+export function 글에서찾기(s, 이름들) {
+  const 글 = String(s ?? '');
+  if (!글 || 글.length > 200000) return null;
+  for (const 이름 of 이름들) {
+    // 이름 뒤에 : = 공백 무엇이 와도 받는다. 값에 따옴표나 자릿점이 붙어도 받는다.
+    const re = new RegExp(`(?:^|[^a-z0-9_])${이름}["']?\\s*[:=]?\\s*["']?(\\d[\\d,_]*)`, 'i');
+    const m = re.exec(글);
+    if (m) {
+      const v = 성한수(m[1].replace(/[,_]/g, ''));
+      if (v) return { value: v, key: 이름 };
+    }
+  }
+  return null;
+}
+
+/**
+ * 객체 어디에 박혀 있어도 찾는다. 글자 덩어리 안까지 본다.
  *
  * 서버가 { data: { meta: { config: { max_position_embeddings: 655360 } } } } 처럼
  * 깊이 넣어 두는 일이 흔하다. 그래서 이름으로 훑는다. 다만 아무 데나 파고들면
  * 엉뚱한 숫자를 집으므로 깊이를 5 로 막는다.
+ *
+ * 어느 이름에서 찾았는지도 같이 돌려준다 — 값이 이상할 때 사람이 원인을
+ * 짚을 수 있어야 한다. /ctx 자세히 가 이걸 보여 준다.
  */
-function 파보기(obj, 이름들, depth = 0) {
+export function 파보기(obj, 이름들, { 글도 = true, depth = 0 } = {}) {
   if (!obj || typeof obj !== 'object' || depth > 5) return null;
   for (const key of 이름들) {
     const v = 성한수(obj[key]);
-    if (v) return v;
+    if (v) return { value: v, key };
   }
-  // 이름이 정확히 안 맞으면 '…context_length' 처럼 끝나는 것도 본다 (Ollama).
   for (const [k, v] of Object.entries(obj)) {
-    if (/(^|[._])(context_length|context_window|n_ctx)$/i.test(k)) {
+    // 이름이 정확히 안 맞으면 '…context_length' 처럼 끝나는 것도 본다 (Ollama).
+    if (이름들 === 최대이름 && /(^|[._])(context_length|context_window|n_ctx)$/i.test(k)) {
       const n = 성한수(v);
-      if (n) return n;
+      if (n) return { value: n, key: k };
+    }
+    // 글자 덩어리 안까지 본다. 여기가 Ollama 의 진짜 num_ctx 가 사는 자리다.
+    //
+    // 찾는 이름은 객체를 볼 때와 **똑같이** 맞춘다. 위의 특별 취급(…context_length
+    // 로 끝나는 이름)까지 글에서도 그대로 본다. 두 잣대가 갈리면 '객체로 오면
+    // 찾고 글로 오면 못 찾는' 설명 못 할 상태가 된다.
+    if (글도 && typeof v === 'string') {
+      const 볼이름 = 이름들 === 최대이름 ? [...이름들, 'n_ctx', 'context_window'] : 이름들;
+      const 글것 = 글에서찾기(v, 볼이름);
+      if (글것) return { value: 글것.value, key: `${k}.${글것.key}` };
     }
   }
   for (const v of Object.values(obj)) {
     if (v && typeof v === 'object') {
-      const found = 파보기(v, 이름들, depth + 1);
+      const found = 파보기(v, 이름들, { 글도, depth: depth + 1 });
       if (found) return found;
     }
   }
@@ -86,67 +146,79 @@ function 목록에서찾기(json, model) {
 }
 
 /**
- * 서버에 물어 컨텍스트 길이를 알아낸다.
+ * 서버에 물어 길이를 알아낸다.
+ *
+ * 두드릴 자리를 **한꺼번에** 두드린다. 전에는 차례로 갔다 — 다섯 곳이 각각
+ * 시간 제한에 걸리면 켤 때마다 그만큼 멈춰 있었다. 서로 상관없는 요청이라
+ * 순서를 지킬 이유가 없다. 우선순위는 결과를 모아 놓고 정하면 된다.
  *
- * @param {{kind:string, base:string, auth:string, key:string, model:string}} conn
- * @returns {Promise<{value:number|null, max:number|null, loaded:number|null, source:string|null, tried:Array}>}
+ * @returns {Promise<{value, max, loaded, out, source, outSource, tried, why}>}
  */
-export async function probeCtx(conn, { timeout = 12000 } = {}) {
+export async function probeCtx(conn, { timeout = 6000 } = {}) {
   const H = () => headersFor(conn.auth, conn.key);
   const base = String(conn.base ?? '').replace(/\/+$/, '');
   const origin = base.replace(/\/v\d+$/, '').replace(/\/api$/, '');
   const model = conn.model;
   const tried = [];
-  let max = null;
-  let loaded = null;
-  let source = null;
 
   const 본다 = async (label, url, opts = {}) => {
-    if (max && loaded) return null;
     try {
       const r = await req(url, { headers: H(), timeout, ...opts });
       tried.push({ label, url, status: r.status ?? 0, ok: !!r.ok });
-      return r.ok ? r.json : null;
+      return { label, json: r.ok ? r.json : null };
     } catch (err) {
       tried.push({ label, url, status: 0, ok: false, why: String(err?.message ?? err) });
-      return null;
+      return { label, json: null };
     }
   };
 
-  const 담기 = (json, label, { 목록 = false } = {}) => {
-    if (!json) return;
+  // 두드릴 자리. 순서가 곧 우선순위다 — 앞엣것이 더 믿을 만하다.
+  const 자리 = conn.kind === 'ollama'
+    ? [
+      ['Ollama 모델 정보', `${origin}/api/show`, { method: 'POST', body: { model } }, {}],
+    ]
+    : [
+      // 이 모델만 콕 집어 묻는다. 있으면 가장 정확하다.
+      ['모델 상세', `${base}/models/${encodeURIComponent(model)}`, {}, {}],
+      // LM Studio 는 자기 규격에만 '올린 길이' 를 준다. 이게 실제로 쓸 값이다.
+      ['LM Studio', `${origin}/api/v0/models/${encodeURIComponent(model)}`, {}, {}],
+      ['LM Studio 목록', `${origin}/api/v0/models`, {}, { 목록: true }],
+      // 목록 응답 안에 들어 있는 경우 (vLLM 의 max_model_len 이 여기 있다)
+      ['모델 목록', `${base}/models`, {}, { 목록: true }],
+      // llama.cpp 는 /props 로만 알려 준다. TGI 는 /info 다.
+      ['llama.cpp /props', `${origin}/props`, {}, { 올린것도: true }],
+      ['TGI /info', `${origin}/info`, {}, {}],
+    ];
+
+  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;
+
+  for (const [i, [label]] of 자리.entries()) {
+    const json = 답들[i].json;
+    if (!json) continue;
+    const { 목록 = false, 올린것도 = false } = 자리[i][3] ?? {};
     const 대상 = 목록 ? 목록에서찾기(json, model) : json;
-    if (!대상) return;
+    if (!대상) continue;
+
     const m = 파보기(대상, 최대이름);
     const l = 파보기(대상, 올린이름);
-    if (m && !max) { max = m; source = label; }
-    if (l && !loaded) loaded = l;
-  };
-
-  if (conn.kind === 'ollama') {
-    담기(await 본다('Ollama /api/show', `${origin}/api/show`, { method: 'POST', body: { model } }), 'Ollama 모델 정보');
-  } else {
-    // 1) 이 모델만 콕 집어 묻는다. 있으면 가장 정확하다.
-    담기(await 본다('모델 상세', `${base}/models/${encodeURIComponent(model)}`), '모델 상세');
-
-    // 2) LM Studio 는 자기 규격에만 '올린 길이' 를 준다. 이게 실제로 쓸 값이다.
-    담기(await 본다('LM Studio 상세', `${origin}/api/v0/models/${encodeURIComponent(model)}`), 'LM Studio');
-    담기(await 본다('LM Studio 목록', `${origin}/api/v0/models`), 'LM Studio', { 목록: true });
-
-    // 3) 목록 응답 안에 들어 있는 경우 (vLLM 의 max_model_len 이 여기 있다)
-    담기(await 본다('모델 목록', `${base}/models`), '모델 목록', { 목록: true });
-
-    // 4) llama.cpp 서버는 /props 로만 알려 준다.
-    const props = await 본다('llama.cpp /props', `${origin}/props`);
-    if (props) {
-      const n = 파보기(props, ['n_ctx', 'context_length']);
-      if (n) { if (!max) { max = n; source = 'llama.cpp'; } if (!loaded) loaded = n; }
-    }
+    const o = 파보기(대상, 출력이름);
+    if (m && !max) { max = m.value; maxKey = m.key; source = label; }
+    if (l && !loaded) { loaded = l.value; loadedKey = l.key; }
+    // llama.cpp 의 n_ctx 는 '지금 올린 길이' 다. 그 서버에서는 최대도 그 값으로 본다.
+    if (올린것도 && m && !loaded) { loaded = m.value; loadedKey = m.key; }
+    if (o && !out) { out = o.value; outSource = label; }
   }
 
   // 실제로 쓸 값: 올려 둔 길이가 있으면 그것. 없으면 모델 최대.
   const value = loaded ?? max ?? null;
-  return { value, max, loaded, source, tried };
+  const why = value ? null
+    : tried.some((t) => t.ok) ? '서버가 응답은 했지만 길이를 안 알려 줍니다'
+      : '두드린 자리에서 아무 응답도 못 받았습니다';
+
+  return { value, max, loaded, out, source, outSource, maxKey, loadedKey, tried, why };
 }
 
 /**

package/src/backend/detect.js

@@ -27,7 +27,16 @@ async function tryOpenAI(base, key) {
       }
     }
     // 401/403 이면 규격은 맞고 인증만 틀린 것 — 다음 방식으로 계속.
-    if (r.status && ![401, 403, 0, 404].includes(r.status)) {
+    //
+    // 그 밖의 오류(500 등)는 '규격은 맞는데 서버가 지금 화가 난 것' 으로 본다.
+    // 그래야 서버가 한 말을 사람에게 그대로 보여 줄 수 있다.
+    //
+    // 단, **200 인데 JSON 이 아니면 여기 해당하지 않는다.** 사내 프록시가
+    // 로그인 페이지를 200 으로 내주는 일이 흔한데, 예전에는 그걸 "OpenAI 호환
+    // 서버 · 모델 0개" 로 잡았다. 그러면 사람은 모델이 안 올라온 줄 알고
+    // 엉뚱한 데를 파게 된다 — 실제로는 인증 페이지에 막힌 것이다.
+    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) };
     }
   }

package/src/backend/learn.js

@@ -0,0 +1,102 @@
+// 서버가 거절할 때 하는 말에서 진짜 한계를 배운다.
+//
+// 왜 이게 핵심인가:
+//
+//   서버 규격을 하나하나 아는 방식으로는 영영 못 따라간다. LM Studio · llama.cpp ·
+//   vLLM · TGI · KoboldCpp · LocalAI · LiteLLM · OpenRouter · 사내 게이트웨이,
+//   그리고 아직 나오지 않은 것들. 새 서버가 나올 때마다 코드를 고쳐야 한다면
+//   그 코드는 늘 한 발 늦는다.
+//
+//   그런데 서버는 거절할 때 **정답을 그대로 말해 준다.**
+//
+//     "This model's maximum context length is 8192 tokens, however you
+//      requested 41003 tokens (33003 in the messages, 8000 in the completion)."
+//
+//   숫자가 둘 다 들어 있다 — 한계도, 우리가 얼마나 넘겼는지도. 규격을 몰라도
+//   되고, 이름이 무엇인지도 알 필요가 없다. **처음 보는 서버에서도 통한다.**
+//
+//   그런데 지금까지 그 문장을 버리고 있었다. 스트리밍이면 본문을 안 읽고
+//   HTTP 400 만 던졌다. 화면에는 `✗ HTTP 400` 한 줄만 남았다.
+//   사용자를 구할 수 있었던 문장이 그 자리에서 사라진 것이다.
+//
+// 여기서는 문장에서 숫자만 뽑는다. 뽑은 값으로 무엇을 할지는 loop.js 가 정한다.
+
+const 최소 = 512;
+const 최대허용 = 10_000_000;
+
+const 성한수 = (v) => {
+  const n = Math.floor(Number(v));
+  return Number.isFinite(n) && n >= 최소 && n <= 최대허용 ? n : null;
+};
+
+/**
+ * 거절 문장에서 배울 것이 있나.
+ *
+ * 여러 규격의 문장을 받는다. 영어가 대부분이지만 사내 게이트웨이가 한국어로
+ * 옮겨 놓은 것도 있어서 그쪽도 같이 본다.
+ *
+ * @returns {{kind:'ctx'|'out', limit:number, asked:number|null, text:string}|null}
+ *   kind  'ctx' 는 컨텍스트 전체, 'out' 은 한 번에 낼 답 길이
+ *   limit 서버가 말한 한계
+ *   asked 우리가 요청했던 값 (알 수 있으면)
+ */
+export function 배울것(message) {
+  const s = String(message ?? '');
+  if (!s) return null;
+
+  // ── 1) 컨텍스트 한계 ──────────────────────────────────────────────────
+  // OpenAI·vLLM·LiteLLM·대부분의 게이트웨이가 이 모양으로 말한다.
+  const ctx표 = [
+    // "maximum context length is 8192 tokens, however you requested 41003"
+    // "…is 4096 tokens. However, you requested 5000 tokens."  ← 마침표가 중간에 낀다.
+    // 그래서 [^.] 로 막으면 안 된다. 대신 사이를 80자로만 묶어 엉뚱한 숫자를 안 집게 한다.
+    /maximum context length is\s+(\d+)\s*tokens?(?:[\s\S]{0,80}?requested\s+(\d+))?/i,
+    /context length[^.\d]{0,40}(\d{3,})[\s\S]{0,80}?requested\s+(\d+)/i,
+    // llama.cpp: "the request exceeds the available context size. try increasing the context size or enable context shift"
+    // 숫자를 안 주는 경우다. n_ctx = 8192 처럼 따로 적어 주기도 한다.
+    /n_ctx\s*[:=]?\s*(\d{3,})/i,
+    // 한국어로 옮겨 놓은 사내 게이트웨이
+    /(?:최대\s*)?컨텍스트[^\d]{0,20}(\d{3,})/,
+  ];
+  for (const re of ctx표) {
+    const m = re.exec(s);
+    if (!m) continue;
+    const limit = 성한수(m[1]);
+    if (!limit) continue;
+    return { kind: 'ctx', limit, asked: 성한수(m[2]) ?? null, text: 짧게(s) };
+  }
+
+  // ── 2) 답 길이 한계 ───────────────────────────────────────────────────
+  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,
+    // "max_tokens must be less than or equal to 8192"
+    /max_(?:completion_)?tokens[^\d]{0,40}(\d{3,})/i,
+    /num_predict[^\d]{0,20}(\d{3,})/i,
+    /(?:최대\s*)?(?:출력|답)[^\d]{0,20}(\d{3,})/,
+  ];
+  for (const re of out표) {
+    const m = re.exec(s);
+    if (!m) continue;
+    const limit = 성한수(m[1]);
+    if (!limit) continue;
+    return { kind: 'out', limit, asked: null, text: 짧게(s) };
+  }
+
+  return null;
+}
+
+/**
+ * 이 오류가 '너무 길어서' 인가.
+ *
+ * 숫자를 못 뽑았어도 이건 알 수 있을 때가 있다. 그러면 값을 배우지는 못해도
+ * **줄여서 다시 해 볼 수는 있다.** 사용자에게는 실패가 안 보이는 편이 낫다.
+ */
+export function 길이문제인가(message) {
+  const s = String(message ?? '');
+  return /context (?:length|size|window)|too (?:long|large|many tokens)|exceeds?[^.]{0,30}(?:context|limit|token)|max_tokens|token limit|컨텍스트|너무 (?:깁|많|큽)/i.test(s);
+}
+
+function 짧게(s) {
+  return String(s).replace(/\s+/g, ' ').trim().slice(0, 200);
+}