deel-local-cli 1.6.3 → 1.8.0

package/src/backend/adapter.js

@@ -1,11 +1,43 @@
-// 규격 차이(OpenAI 호환 / Ollama)를 여기 한 곳에서만 흡수한다.
+// 규격 차이(OpenAI 호환 / Ollama / Anthropic)를 여기 한 곳에서만 흡수한다.
 // 진단(probe)과 에이전트 루프가 같은 함수를 쓴다.
 import { req, headersFor, serverMessage, Aborted } from './http.js';
 import { 할당량기억 } from './quota.js';
+import { 열쇠 as 열쇠받아오기, 쓸수있나 } from '../safety/authcmd.js';
+import { 말 } from '../i18n/index.js';
 import { 다시부를지, 기다리기, 정책고르기 } from './retry.js';
 
+/*
+ * Anthropic 규격의 판 이름.
+ *
+ * 이 머리 하나가 없으면 400 이다. 열쇠가 멀쩡해도 그렇다. 날짜처럼 생겼지만
+ * 「오늘 날짜」 가 아니라 **규격 판 이름**이라, 새 날짜를 넣는다고 새 기능이
+ * 켜지지 않는다. 회사가 새 판을 내놓기 전에는 이 값이 바뀔 일이 없다.
+ */
+export const ANTHROPIC_VERSION = '2023-06-01';
+
 export function endpoint(shape) {
-  return shape === 'ollama' ? '/api/chat' : '/chat/completions';
+  if (shape === 'ollama') return '/api/chat';
+  if (shape === 'anthropic') return '/messages';
+  return '/chat/completions';
+}
+
+/** 이 규격이 더 요구하는 머리. 없으면 빈 것. */
+export function 더할머리(shape) {
+  return shape === 'anthropic' ? { 'anthropic-version': ANTHROPIC_VERSION } : {};
+}
+
+/**
+ * 이 규격을 사람에게 뭐라고 부를까.
+ *
+ * 한 곳에 모아 둔다. 화면 여러 자리가 각자 `kind === 'ollama' ? … : 'OpenAI
+ * 호환'` 로 갈라 놓고 있었는데, 규격이 셋이 되는 순간 그 자리들이 전부
+ * Anthropic 연결을 **「OpenAI 호환」 이라고 잘못 적는다.** 붙는 데는 아무
+ * 지장이 없어서 아무도 안 고치고, 그 화면을 믿고 남에게 설명하게 된다.
+ */
+export function 규격이름(shape) {
+  if (shape === 'ollama') return 말('head.spec.ollama');
+  if (shape === 'anthropic') return 말('head.spec.anthropic');
+  return 말('head.spec.openai');
 }
 
 /**
@@ -60,6 +92,9 @@ export function buildBody(shape, { model, messages, tools, stream, json, think,
     if (think !== undefined) body.think = think;
     return body;
   }
+  if (shape === 'anthropic') return anthropic몸(
+    { model, messages, tools, stream, json, think, maxTokens },
+  );
   // 출력 상한을 **두 이름으로 같이** 보낸다.
   //
   // 옛 규격은 max_tokens 하나였다. 그런데 GPT-5 계열을 붙여 놓은 게이트웨이는
@@ -78,7 +113,90 @@ export function buildBody(shape, { model, messages, tools, stream, json, think,
   return body;
 }
 
+/*
+ * ── Anthropic 규격은 어디가 다른가 ─────────────────────────────────────
+ *
+ * OpenAI 호환 서버는 문 이름(/chat/completions)만 같으면 대충 통했다. 이쪽은
+ * 통하지 않는 자리가 넷이다. 그래서 여기 한 곳에 몰아 둔다.
+ *
+ *   1. 시킴말(system)이 messages 안에 못 들어간다. 몸의 딴 칸이다.
+ *   2. 차례가 사람·모델로 **번갈아** 와야 한다. 도구를 한 턴에 둘 부르면
+ *      결과가 둘인데, 그대로 보내면 거절당한다.
+ *   3. 도구 모양이 { name, description, input_schema } 다.
+ *      OpenAI 의 { type:'function', function:{...} } 가 아니다.
+ *   4. 답이 글 한 덩어리가 아니라 **블록 배열**이다.
+ *
+ * 안 보내는 것도 적어 둔다. 확인 못 한 것은 안 보낸다는 뜻이지, 없다는 뜻이
+ * 아니다 — 짐작으로 보낸 칸 하나가 400 을 만들면 열쇠가 틀린 줄 알게 된다.
+ *
+ *   · think — 생각 칸의 값 모양을 문서에서 확인하지 못했다.
+ *   · json  — 이 규격에는 답 모양을 강제하는 칸이 없다. 도구로 하는 방법뿐이다.
+ */
+function anthropic몸({ model, messages, tools, stream, json, think, maxTokens }) {
+  const 머리말 = [];
+  const 나머지 = [];
+  for (const m of messages ?? []) {
+    if (m?.role === 'system') 머리말.push(typeof m.content === 'string' ? m.content : String(m.content ?? ''));
+    else 나머지.push(m);
+  }
+  const body = { model, messages: 차례합치기(나머지), stream: !!stream, max_tokens: maxTokens };
+  if (머리말.length) body.system = 머리말.join('\n\n');
+  if (tools?.length) {
+    body.tools = tools.map((t) => {
+      const f = t.function ?? t;
+      return {
+        name: f.name,
+        description: f.description ?? '',
+        input_schema: f.parameters ?? f.input_schema ?? { type: 'object', properties: {} },
+      };
+    });
+    body.tool_choice = { type: 'auto' };
+  }
+  return body;
+}
+
+/**
+ * 같은 차례가 연달아 오면 하나로 합친다.
+ *
+ * 도구를 한 턴에 둘 부르면 결과 메시지가 둘이고, 이 규격에서 그 둘은 다
+ * 사람 차례다. 번갈아 오지 않으면 서버가 통째로 거절한다 — 그러면 도구를
+ * 하나만 부를 때는 되고 둘 부를 때만 안 되는, 제일 알아내기 어려운 고장이 된다.
+ */
+export function 차례합치기(messages) {
+  const 덩이 = (c) => (Array.isArray(c) ? c : [{ type: 'text', text: String(c ?? '') }]);
+  const out = [];
+  for (const m of messages ?? []) {
+    const 앞 = out[out.length - 1];
+    if (앞 && 앞.role === m?.role) {
+      앞.content = [...덩이(앞.content), ...덩이(m.content)];
+      continue;
+    }
+    out.push({ ...m });
+  }
+  return out;
+}
+
 export function extractMessage(shape, json) {
+  if (shape === 'anthropic') {
+    // 답이 블록 배열이다. 글·생각·도구 부름이 한 배열에 섞여 온다.
+    let content = '';
+    let thinking = '';
+    const 부름들 = [];
+    for (const b of Array.isArray(json?.content) ? json.content : []) {
+      if (b?.type === 'text') content += b.text ?? '';
+      else if (b?.type === 'thinking') thinking += b.thinking ?? '';
+      else if (b?.type === 'tool_use') 부름들.push({ id: b.id, name: b.name, args: b.input ?? {} });
+    }
+    return {
+      content,
+      thinking,
+      toolCalls: normalizeCalls(부름들),
+      // 이름이 다르다. prompt_tokens 를 찾으면 늘 0 이 나오고, 화면에는
+      // 「토큰을 하나도 안 썼다」 로 뜬다.
+      usage: { in: json?.usage?.input_tokens ?? 0, out: json?.usage?.output_tokens ?? 0 },
+      stopped: json?.stop_reason ?? null,
+    };
+  }
   if (shape === 'ollama') {
     const m = json?.message ?? {};
     return {
@@ -141,6 +259,23 @@ export function normalizeCalls(list) {
 
 // 대화 이력에 되돌려 넣을 메시지 만들기 — 규격마다 모양이 다르다.
 export function assistantMessage(shape, { content = '', thinking = '', toolCalls = [] }) {
+  if (shape === 'anthropic') {
+    const 블록 = [];
+    if (content) 블록.push({ type: 'text', text: content });
+    for (const t of toolCalls) 블록.push({ type: 'tool_use', id: t.id, name: t.name, input: t.args ?? {} });
+    /*
+     * 생각은 **안 돌려보낸다.**
+     *
+     * 이 규격의 생각 블록에는 서명(signature)이 딸려 있고, 서명 없이 돌려보내면
+     * 서버가 거절한다. 흘려받기에서 서명 조각을 제대로 모으는 것까지 확인하지
+     * 못했으므로 여기서는 뺀다. 화면에는 그대로 흘러가고, 대화 이력에만 안 남는다.
+     *
+     * 블록이 하나도 없으면 이 규격은 거절한다. 빈 답이 오는 일은 드물지만
+     * 그때 대화 전체가 죽으면 안 되니 자리표시를 하나 넣는다.
+     */
+    if (!블록.length) 블록.push({ type: 'text', text: '(빈 답)' });
+    return { role: 'assistant', content: 블록 };
+  }
   if (shape === 'ollama') {
     const m = { role: 'assistant', content };
     if (thinking) m.thinking = thinking;
@@ -158,19 +293,71 @@ export function assistantMessage(shape, { content = '', thinking = '', toolCalls
 }
 
 export function toolMessage(shape, { callId, name, content }) {
+  // 이 규격에는 도구 차례가 없다. 도구 결과도 **사람 차례**로 돌려준다.
+  // role:'tool' 로 보내면 「모르는 역할」 이라고 거절당한다.
+  if (shape === 'anthropic') {
+    return { role: 'user', content: [{ type: 'tool_result', tool_use_id: callId, content: String(content) }] };
+  }
   return shape === 'ollama'
     ? { role: 'tool', tool_name: name, content: String(content) }
     : { role: 'tool', tool_call_id: callId, content: String(content) };
 }
 
+/*
+ * 이번 요청에 실을 머리말.
+ *
+ * 열쇠받기가 걸려 있으면 여기서 받아 온다. 요청 **직전**에 받는 것이
+ * 중요하다 — 판을 켤 때 한 번 받아 두면 세 시간짜리 대화의 두 시간째에
+ * 죽어 있고, 그 401 은 「열쇠가 틀렸다」 와 화면에서 구별이 안 된다.
+ *
+ * 못 받으면 **던지지 않는다.** 원래 열쇠(있으면)로 그냥 간다. 여기서
+ * 막아 버리면 열쇠받기 설정 한 줄이 잘못된 것으로 멀쩡히 붙던 연결까지
+ * 안 붙는다. 못 받았다는 것은 부르는 쪽이 onAuth 로 듣고 화면에 적는다.
+ */
+async function 머리말짓기(conn, opts, { 다시 = false } = {}) {
+  const 설정 = conn.열쇠받기 ?? null;
+  const 판단 = 쓸수있나(설정, { auth: conn.auth });
+  if (!설정 || !판단.된다) {
+    if (설정 && 판단.왜) opts.onAuth?.({ ok: false, 왜: 판단.왜, 안부름: true });
+    return headersFor(conn.auth, conn.key ?? '', 더할머리(conn.kind));
+  }
+  const r = await 열쇠받아오기(설정, {
+    다시, signal: opts.signal ?? null,
+    물어보기: opts.열쇠물어보기 ?? null,
+    알림: opts.onAuth ? (것) => opts.onAuth(것) : null,
+  });
+  if (!r.ok) {
+    opts.onAuth?.({ ...r, ok: false });
+    return headersFor(conn.auth, conn.key ?? '', 더할머리(conn.kind));
+  }
+  if (!r.그대로) opts.onAuth?.({ ok: true, 만료: r.만료, ms: r.ms });
+  return headersFor(conn.auth, r.token, { ...더할머리(conn.kind), ...r.headers });
+}
+
+/*
+ * 401 을 맞았을 때 열쇠를 새로 받고 한 번만 다시 부를까.
+ *
+ * retry.js 는 401 을 안 다시 부른다 — 열쇠가 틀린 것은 백 번 불러도
+ * 같기 때문이다. 그 말은 지금도 맞다. 다른 것은 **열쇠를 바꿀 수 있을
+ * 때**뿐이다. 그때는 같은 열쇠로 다시 부르는 것이 아니라 새 열쇠로
+ * 부르는 것이라, 「불러 봐야 같다」 에 해당하지 않는다.
+ *
+ * 한 번만이다. 두 번째 401 은 진짜로 권한이 없는 것이고, 그때 더 부르면
+ * 로그인 명령만 되풀이해서 띄우게 된다.
+ */
+function 열쇠다시받을까(conn, status, 이미) {
+  return !이미 && Number(status) === 401 && !!conn.열쇠받기;
+}
+
 // 한 번에 받기.
 export async function chat(conn, opts) {
   const body = buildBody(conn.kind, { model: conn.model, ctx: conn.ctx ?? null, ...opts });
   const 정책 = 정책고르기(conn, opts);
+  let 열쇠다시받음 = false;
   for (let 시도 = 1; ; 시도++) {
     const r = await req(요청주소(conn), {
       method: 'POST',
-      headers: headersFor(conn.auth, conn.key ?? ''),
+      headers: await 머리말짓기(conn, opts),
       body,
       timeout: opts.timeout ?? 300000,
       signal: opts.signal ?? null,
@@ -179,6 +366,14 @@ export async function chat(conn, opts) {
     // 429 를 맞고 나서야 아는 것과, 맞기 전에 아는 것은 사람이 할 일이 다르다.
     할당량기억(r.headers);
     if (r.ok) return extractMessage(conn.kind, r.json);
+    // 열쇠가 늙어서 막힌 것이면 새로 받고 한 번만 다시. 시도 수는 안 올린다 —
+    // 서버가 막은 것이 아니라 우리 열쇠가 낡았던 것이라 물러설 까닭이 없다.
+    if (열쇠다시받을까(conn, r.status, 열쇠다시받음)) {
+      열쇠다시받음 = true;
+      await 머리말짓기(conn, opts, { 다시: true });
+      시도 -= 1;
+      continue;
+    }
     // 잠깐 막힌 것이면 기다렸다 다시 부른다 (backend/retry.js 머리말).
     // 한 번에 받는 길은 제너레이터가 아니라 화면에 말을 못 걸어서, 부르는 쪽이
     // 준 onBackoff 로 알린다. 안 줬으면 조용히 기다린다.
@@ -241,10 +436,11 @@ export async function* chatStream(conn, opts) {
   const body = buildBody(conn.kind, { model: conn.model, ctx: conn.ctx ?? null, ...opts, stream: true });
   const 정책 = 정책고르기(conn, opts);
   let r;
+  let 열쇠다시받음 = false;
   for (let 시도 = 1; ; 시도++) {
     r = await req(요청주소(conn), {
       method: 'POST',
-      headers: headersFor(conn.auth, conn.key ?? ''),
+      headers: await 머리말짓기(conn, opts),
       body,
       timeout: opts.timeout ?? 300000,
       stream: true,
@@ -253,6 +449,14 @@ export async function* chatStream(conn, opts) {
     할당량기억(r.headers ?? r.res?.headers);
     if (r.ok && r.res?.body) break;
     const 거절 = await 거절읽기(r);
+    // 위 chat() 과 같은 규칙. 몸을 먼저 읽고(거절읽기) 나서 다시 부른다 —
+    // 안 읽은 몸을 두고 다음 요청을 보내면 연결이 남는다.
+    if (열쇠다시받을까(conn, 거절.status, 열쇠다시받음)) {
+      열쇠다시받음 = true;
+      await 머리말짓기(conn, opts, { 다시: true });
+      시도 -= 1;
+      continue;
+    }
     // 잠깐 막힌 것이면 알리고, 기다렸다, 다시 부른다. 머리말도 못 받은 자리라
     // 화면에 흘러간 글이 없다 — 그래서 여기서만 다시 부르고, 아래 읽기 도중에
     // 끊긴 것은 다시 안 부른다 (backend/retry.js 머리말).
@@ -299,6 +503,7 @@ export async function* chatStream(conn, opts) {
 // 조각 하나를 누적하고, 화면에 흘릴 것만 내보낸다.
 function absorb(shape, obj, acc) {
   const out = [];
+  if (shape === 'anthropic') return anthropic흡수(obj, acc, out);
   if (shape === 'ollama') {
     const m = obj.message ?? {};
     if (m.thinking) { acc.thinking += m.thinking; out.push({ type: 'thinking', text: m.thinking }); }
@@ -320,6 +525,68 @@ function absorb(shape, obj, acc) {
   return out;
 }
 
+/*
+ * Anthropic 흘려받기.
+ *
+ * OpenAI 는 조각마다 같은 모양(choices[0].delta)이 오는데, 이쪽은 **사건 이름**
+ * 으로 나뉜다. 하나씩 다르게 읽어야 한다.
+ *
+ *   message_start        — 시작. 여기 입력 토큰 수가 들어 있다.
+ *   content_block_start  — 블록 하나 시작. 도구 부름이면 이름과 번호가 여기 있다.
+ *   content_block_delta  — 알맹이 조각. 글·생각·도구 인자가 각각 딴 이름으로 온다.
+ *   message_delta        — 끝난 까닭과 출력 토큰 수.
+ *   message_stop         — 끝.
+ *
+ * 도구 인자는 글자 단위로 쪼개져 오므로 번호별로 이어 붙인다. 이 자리는
+ * OpenAI 쪽과 같아서 마무리(도구마무리)를 같이 쓴다.
+ */
+function anthropic흡수(obj, acc, out) {
+  const 종류 = obj?.type;
+  const 번호 = obj?.index ?? 0;
+  if (종류 === 'message_start') {
+    const u = obj.message?.usage;
+    if (u) acc.usage = { in: u.input_tokens ?? 0, out: u.output_tokens ?? 0 };
+    return out;
+  }
+  if (종류 === 'content_block_start') {
+    const b = obj.content_block ?? {};
+    if (b.type === 'tool_use') {
+      acc._raw ??= [];
+      acc._raw[번호] = { id: b.id, name: b.name ?? '', args: '' };
+    }
+    return out;
+  }
+  if (종류 === 'content_block_delta') {
+    const d = obj.delta ?? {};
+    if (d.type === 'text_delta' && d.text) {
+      acc.content += d.text;
+      out.push({ type: 'content', text: d.text });
+    } else if (d.type === 'thinking_delta' && d.thinking) {
+      acc.thinking += d.thinking;
+      out.push({ type: 'thinking', text: d.thinking });
+    } else if (d.type === 'input_json_delta' && d.partial_json != null) {
+      acc._raw ??= [];
+      acc._raw[번호] ??= { id: null, name: '', args: '' };
+      acc._raw[번호].args += d.partial_json;
+    }
+    return out;
+  }
+  if (종류 === 'message_delta') {
+    /*
+     * 출력 토큰은 **덮어쓴다.** 조각마다의 양이 아니라 여태 누적 총계라서,
+     * 더하면 조각 수만큼 부풀어 오른다. 입력 쪽은 해당 없으면 아예 안 오므로
+     * 왔을 때만 덮는다 — 없는 것을 0 으로 덮으면 message_start 에서 받아 둔
+     * 진짜 값이 지워진다.
+     */
+    if (obj.usage?.output_tokens != null) acc.usage.out = obj.usage.output_tokens;
+    if (obj.usage?.input_tokens != null) acc.usage.in = obj.usage.input_tokens;
+    if (obj.delta?.stop_reason) acc.stopped = obj.delta.stop_reason;
+    return out;
+  }
+  if (종류 === 'content_block_stop' || 종류 === 'message_stop') 도구마무리(acc);
+  return out;
+}
+
 // OpenAI 스트리밍은 도구 호출 인자를 글자 단위로 쪼개 보낸다. 인덱스별로 이어 붙인다.
 function mergeDeltaCalls(acc, deltas) {
   acc._raw ??= [];
@@ -330,6 +597,12 @@ function mergeDeltaCalls(acc, deltas) {
     if (d.function?.name) acc._raw[i].name += d.function.name;
     if (d.function?.arguments) acc._raw[i].args += d.function.arguments;
   }
+  도구마무리(acc);
+}
+
+// 글자로 쪼개져 온 도구 인자를 하나로 읽는다. 두 규격이 같이 쓴다.
+function 도구마무리(acc) {
+  if (!acc._raw) return;
   // 인자가 안 읽히면 읽혔다고 치지 않는다 — normalizeCalls 머리말 참고.
   // 스트리밍은 마지막 조각이 안 오면 여기서 늘 깨진 채로 끝난다.
   acc.toolCalls = acc._raw.filter(Boolean).map((c, i) => {

package/src/backend/ctxsize.js

@@ -28,6 +28,7 @@
 // 따로 알려 준다 — 사용자가 서버에서 더 올린 다음 /ctx 로 맞출 수 있게.
 import { req, headersFor } from './http.js';
 import { 애저인가 } from './azure.js';
+import { 더할머리 } from './adapter.js';
 
 // 이 이름들 중 하나면 '모델이 낼 수 있는 최대 컨텍스트' 다. 순서가 곧 우선순위다.
 const 최대이름 = [
@@ -156,7 +157,7 @@ function 목록에서찾기(json, model) {
  * @returns {Promise<{value, max, loaded, out, source, outSource, tried, why}>}
  */
 export async function probeCtx(conn, { timeout = 6000 } = {}) {
-  const H = () => headersFor(conn.auth, conn.key);
+  const H = () => headersFor(conn.auth, conn.key, 더할머리(conn.kind));
   const base = String(conn.base ?? '').replace(/\/+$/, '');
   const origin = base.replace(/\/v\d+$/, '').replace(/\/api$/, '');
   const model = conn.model;
@@ -196,7 +197,20 @@ export async function probeCtx(conn, { timeout = 6000 } = {}) {
     ? [
       ['Ollama 모델 정보', `${origin}/api/show`, { method: 'POST', body: { model } }, {}],
     ]
-    : [
+    : conn.kind === 'anthropic'
+      /*
+       * Anthropic 은 모델 목록에 **창 크기가 없다.** 이름과 나온 날짜뿐이다.
+       *
+       * 그래도 두 자리는 두드린다. 값이 없어도 「모델이 있다」 는 것은 확인되고,
+       * 못 찾았다는 사실이 tried 에 남아 화면이 짐작을 사실처럼 말하지 않게 된다.
+       * llama.cpp 의 /props 나 TGI 의 /info 는 여기 있을 리가 없으므로 안 두드린다 —
+       * 없는 문을 두드리면 켤 때마다 그만큼 기다린다.
+       */
+      ? [
+        ['모델 상세', `${base}/models/${encodeURIComponent(model)}`, {}, {}],
+        ['모델 목록', `${base}/models`, {}, { 목록: true }],
+      ]
+      : [
       // 이 모델만 콕 집어 묻는다. 있으면 가장 정확하다.
       ['모델 상세', `${base}/models/${encodeURIComponent(model)}`, {}, {}],
       // LM Studio 는 자기 규격에만 '올린 길이' 를 준다. 이게 실제로 쓸 값이다.

package/src/backend/detect.js

@@ -1,6 +1,7 @@
 // 주소만 받아서 "이 서버가 무슨 규격이고 인증을 어떻게 받는지" 알아낸다.
 import { req, headersFor, AUTH_STYLES, serverMessage } from './http.js';
 import { 애저인가, 애저풀기, 애저base, 배포목록 } from './azure.js';
+import { ANTHROPIC_VERSION } from './adapter.js';
 
 // 사람이 대충 적은 주소를 시도해볼 후보들로 넓힌다.
 export function candidates(input) {
@@ -105,12 +106,73 @@ async function tryAzure(input, key) {
   return null;
 }
 
-// OpenAI 호환인지 확인 (GET {base}/models)
-async function tryOpenAI(base, key) {
+/*
+ * 못 붙었을 때 **무엇이 막았는지**를 적어 둔다.
+ *
+ * 여태는 실패한 응답을 그냥 버렸다. 그래서 401(닿았는데 열쇠) · 404(주소가
+ * 아님) · Bedrock 의 AccessDenied(모델 신청을 안 함)가 화면에서 전부
+ * 「연결 실패」 한 마디가 됐다. 셋은 고칠 자리가 완전히 다른데도.
+ *
+ * 값을 채워 주는 자리를 인자로 받는 것은, 두드리는 함수들이 돌려주는 모양을
+ * 안 바꾸려는 것이다 — 그 반환값(붙었나 아닌가)은 부르는 데가 여럿이다.
+ *
+ * **진짜 상태코드를 먼저 적는다.** 후보를 여럿 두드리다 보면 하나는 401 이고
+ * 하나는 0(닿지도 못함)일 수 있는데, 401 쪽이 훨씬 쓸모 있는 단서다 — 적어도
+ * 서버가 거기 있다는 뜻이니까.
+ */
+function 막은것적기(막힌것, r) {
+  if (!막힌것) return;
+  const 말 = (r.status ? serverMessage(r) : r.error) ?? '';
+  if (!막힌것.status && r.status) { 막힌것.status = r.status; 막힌것.why = 말; }
+  else if (!막힌것.status && !막힌것.why) 막힌것.why = 말;
+}
+
+/*
+ * Anthropic 규격인지 확인 (GET {base}/models · 판 머리를 얹어서).
+ *
+ * ── 왜 OpenAI 쪽과 안 헷갈리나 ─────────────────────────────────────────
+ *
+ * 문 이름이 `/models` 로 같다. 그런데 이쪽 서버는 `anthropic-version` 머리가
+ * 없으면 400 을 준다. tryOpenAI 는 그 머리를 안 보내므로 여기 붙을 수가 없다.
+ *
+ * 반대는 성립하지 않는다 — OpenAI 호환 서버는 모르는 머리를 그냥 무시하므로
+ * 이 함수로도 붙어 버린다. 그래서 **뒤에 두드린다.** 다만 열쇠가 sk-ant- 로
+ * 시작하거나 주소가 그 회사면 먼저 본다. 그때는 헷갈릴 일이 없고, 앞에서
+ * 네 가지 인증 방식으로 헛되이 두드리는 시간도 없앤다.
+ *
+ * 인증 방식을 한 가지만 본다. 이 규격은 x-api-key 하나뿐이라, 나머지로
+ * 두드려 봐야 401 만 늘고 사람이 기다리는 시간만 길어진다.
+ */
+async function tryAnthropic(base, key, 막힌것 = null) {
+  if (!key) return null;
+  const r = await req(`${base}/models`, {
+    headers: headersFor('x-api-key', key, { 'anthropic-version': ANTHROPIC_VERSION }),
+    timeout: 12000,
+  });
+  막은것적기(막힌것, r);
+  if (r.ok && Array.isArray(r.json?.data)) {
+    return { kind: 'anthropic', base, auth: 'x-api-key', models: normalizeModels(r.json.data), ms: r.ms };
+  }
+  return 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));
+    return /(^|\.)anthropic\.com$/i.test(u.hostname);
+  } catch { return false; }
+}
+
+// OpenAI 호환인지 확인 (GET {base}/models). 막힌것은 막은것적기 머리말 참고.
+async function tryOpenAI(base, key, 막힌것 = null) {
+  const 적기 = (r) => 막은것적기(막힌것, r);
   for (const style of AUTH_STYLES) {
     if (style.id !== 'none' && !key) continue;
     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)) {
@@ -126,6 +188,16 @@ async function tryOpenAI(base, key) {
     // 로그인 페이지를 200 으로 내주는 일이 흔한데, 예전에는 그걸 "OpenAI 호환
     // 서버 · 모델 0개" 로 잡았다. 그러면 사람은 모델이 안 올라온 줄 알고
     // 엉뚱한 데를 파게 된다 — 실제로는 인증 페이지에 막힌 것이다.
+    /*
+     * 400 인데 「anthropic-version 이 필요하다」 고 하면, 그건 서버가 화가 난
+     * 것이 아니라 **규격이 다르다**는 말이다. 서버가 제 규격을 말해 줬다.
+     *
+     * 여기서 openai 로 잡아 버리면 설치는 초록색으로 끝나고 첫 한마디에서
+     * 400 이 난다 — 그 화면으로는 원인을 알 길이 없다. 열쇠 앞머리가 sk-ant-
+     * 가 아닌 열쇠(사내에서 다시 발급한 것 등)로 그 규격 서버에 붙을 때
+     * 실제로 이 길로 온다.
+     */
+    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) };
@@ -154,7 +226,7 @@ function fmtSize(bytes) {
 
 function normalizeModels(list) {
   return list
-    .map((m) => (typeof m === 'string' ? { id: m } : { id: m.id ?? m.name ?? m.model, note: m.owned_by ?? '' }))
+    .map((m) => (typeof m === 'string' ? { id: m } : { id: m.id ?? m.name ?? m.model, note: m.owned_by ?? m.display_name ?? '' }))
     .filter((m) => m.id);
 }
 
@@ -177,14 +249,40 @@ export async function detect(input, key) {
     };
   }
 
+  // 못 붙으면 무엇이 막았는지를 같이 돌려준다 — 부르는 쪽이 사람 말로 옮긴다
+  // (providers/index.js 의 막힌까닭). tryOpenAI 머리말 참고.
+  const 막힌것 = { status: 0, why: '' };
+
+  // 단서가 있으면 이 규격을 먼저 본다 (tryAnthropic 머리말).
+  if (앤트로픽같나(input, key)) {
+    for (const base of candidates(input)) {
+      tried.push(base);
+      const hit = await tryAnthropic(base, key, 막힌것);
+      if (hit) return { ...hit, tried };
+    }
+  }
+
   // Ollama 를 먼저 본다 — 로컬이면 대개 이쪽이고 확인이 빠르다.
   const oll = await tryOllama(/^https?:\/\//i.test(origin) ? origin : 'http://' + origin);
   if (oll) return { ...oll, tried };
 
   for (const base of candidates(input)) {
-    tried.push(base);
-    const hit = await tryOpenAI(base, key);
+    if (!tried.includes(base)) tried.push(base);
+    const hit = await tryOpenAI(base, key, 막힌것);
     if (hit) return { ...hit, tried };
   }
-  return { kind: null, tried };
+
+  /*
+   * 마지막으로 이 규격도 본다.
+   *
+   * 사내 게이트웨이가 이 규격만 열어 둔 경우가 있다. 여기까지 왔다는 것은
+   * OpenAI 쪽으로는 안 붙었다는 뜻이라, 이제 헷갈릴 일이 없다.
+   */
+  if (key && !앤트로픽같나(input, key)) {
+    for (const base of candidates(input)) {
+      const hit = await tryAnthropic(base, key, 막힌것);
+      if (hit) return { ...hit, tried };
+    }
+  }
+  return { kind: null, tried, status: 막힌것.status, why: 막힌것.why };
 }