u1s1-cli 1.17.0 → 1.19.0

package/dist/custom-endpoint-proxy.js

@@ -0,0 +1,461 @@
+import { Readable } from "node:stream";
+import { anthropicErrorBody, anthropicRequestToChat, chatCompletionToAnthropic, chatSseToAnthropic, } from "./chat-protocol/anthropic.js";
+import { asRecord } from "./chat-protocol/json.js";
+import { openAIResponseToResponses, responsesContext, responsesFinalError, responsesRequestToChat, } from "./chat-protocol/responses.js";
+import { estimateTokensFromText } from "./chat-protocol/thinking.js";
+import { lookupCustomModel } from "./agents/custom-models.js";
+import { describeFetchFailure, isConnectPhaseFailure } from "./gateway-route.js";
+import { tr } from "./i18n.js";
+/** 本地路由只看这三条;其余路径(/v1/models、/v1/agents/…)照旧走网关。 */
+export function customProtocolFor(method, pathname) {
+    if ((method ?? "GET").toUpperCase() !== "POST")
+        return null;
+    if (pathname === "/v1/messages")
+        return "messages";
+    if (pathname === "/v1/messages/count_tokens")
+        return "count_tokens";
+    if (pathname === "/v1/responses")
+        return "responses";
+    return null;
+}
+/**
+ * 这个请求要不要本地处理。只有 model 是 `ep…/…` 写法时才是;端点或模型已不在时也本地报错
+ * (网关不认识这种 id,发过去只会多一次网关请求)。body 里连 `"ep` 都没有时不解析 JSON。
+ */
+export function matchCustomRoute(method, pathname, rawBody, endpoints) {
+    const protocol = customProtocolFor(method, pathname);
+    if (!protocol || !rawBody || !rawBody.includes('"ep'))
+        return null;
+    let body;
+    try {
+        body = asRecord(JSON.parse(rawBody.toString("utf8")));
+    }
+    catch {
+        return null;
+    }
+    if (!body)
+        return null;
+    const lookup = lookupCustomModel(endpoints, body.model);
+    return lookup.kind === "gateway" ? null : { protocol, body, lookup };
+}
+// ---------------------------------------------------------------- reasoning
+const LEVEL_ORDER = ["off", "minimal", "low", "medium", "high", "xhigh", "max"];
+/** 支持档位里离 want 最近的一档;等距取高的一档(与网关 anthropic-thinking.ts 同一规则)。 */
+function nearestLevel(want, supported) {
+    const target = LEVEL_ORDER.indexOf(want);
+    let best;
+    for (const level of supported) {
+        if (best === undefined) {
+            best = level;
+            continue;
+        }
+        const gap = Math.abs(LEVEL_ORDER.indexOf(level) - target);
+        const bestGap = Math.abs(LEVEL_ORDER.indexOf(best) - target);
+        if (gap < bestGap || (gap === bestGap && LEVEL_ORDER.indexOf(level) > LEVEL_ORDER.indexOf(best)))
+            best = level;
+    }
+    return best;
+}
+/**
+ * 客户端请求的思考设置 → Chat 请求里的推理参数(自定义端点只发 `reasoning_effort`;不发 DeepSeek 的顶层
+ * `thinking`、不发 chat_template_kwargs:有的端点见到 thinking 直接 400)。
+ *   - 非推理模型、客户端没表态(level = null):什么都不发,用端点默认;
+ *   - 关思考:发 "none"(省略等于让后端按默认开着想);
+ *   - 其余档位:原样发(max 收到 xhigh,OpenAI 兼容端点不认 max)。
+ * 模型带思考契约(ModelDef.thinking:levels / canDisable / levelMap,后台「推理参数格式」字段)时,
+ * 档位取它支持的最近一档、按 levelMap 改写;关不掉的模型收到「关」退到最低一档。requestFormat 不影响
+ * 字段名:自定义端点一律 reasoning_effort。
+ */
+export function chatReasoningFields(model, level) {
+    if (!model.reasoning || level === null)
+        return {};
+    const caps = model.thinking;
+    if (!caps || !caps.levels.length)
+        return { reasoning_effort: level === "off" ? "none" : level === "max" ? "xhigh" : level };
+    const onLevels = caps.levels.filter((l) => l !== "off");
+    if (level === "off" && caps.canDisable)
+        return { reasoning_effort: caps.levelMap.off ?? "none" };
+    const chosen = level === "off" ? onLevels[0] : nearestLevel(level, onLevels);
+    if (!chosen)
+        return {};
+    return { reasoning_effort: caps.levelMap[chosen] ?? (chosen === "max" ? "xhigh" : chosen) };
+}
+function reasoningFieldsFor(model) {
+    return (_modelId, level) => chatReasoningFields(model, level);
+}
+// ---------------------------------------------------------------- outbound request
+/** 客户端会话 id → x-session-id(端点按它把同一会话固定到同一后端,提高缓存命中)。只认这几个头。 */
+const SESSION_HEADERS = ["x-claude-code-session-id", "session_id", "session-id", "x-session-id"];
+const SESSION_ID_RE = /^[A-Za-z0-9._:-]{1,128}$/;
+export function clientSessionId(headers) {
+    for (const name of SESSION_HEADERS) {
+        const value = headers[name];
+        const first = Array.isArray(value) ? value[0] : value;
+        if (typeof first === "string" && SESSION_ID_RE.test(first))
+            return first;
+    }
+    return undefined;
+}
+/** 发往端点的请求头:从零构造,见文件头的安全说明。 */
+export function endpointRequestHeaders(endpoint, stream, sessionId) {
+    const headers = new Headers({
+        "content-type": "application/json",
+        accept: stream ? "text/event-stream" : "application/json",
+    });
+    if (endpoint.apiKey)
+        headers.set("authorization", `Bearer ${endpoint.apiKey}`);
+    if (sessionId)
+        headers.set("x-session-id", sessionId);
+    return headers;
+}
+export function chatCompletionsUrl(baseUrl) {
+    return `${baseUrl.replace(/\/+$/, "")}/chat/completions`;
+}
+/** 转换后的 Chat 体 → 真正发给端点的体:模型 id 换成端点自己的,流式要 usage,输出上限不超过模型登记的值。 */
+export function endpointChatBody(chat, model) {
+    const out = { ...chat, model: model.id };
+    // 网关管道里给上游会话亲和用的字段;通用端点不一定认,不发
+    delete out.prompt_cache_key;
+    if (out.stream === true)
+        out.stream_options = { include_usage: true };
+    if (typeof out.max_tokens === "number" && model.maxTokens > 0 && out.max_tokens > model.maxTokens) {
+        out.max_tokens = model.maxTokens;
+    }
+    return out;
+}
+const CONTEXT_ERROR_RE = /context length|context window|maximum context|too many tokens|prompt is too long|reduce the length/i;
+function endpointLabel(endpoint) {
+    return tr(`自定义端点「${endpoint.name}」`, `Custom endpoint "${endpoint.name}"`);
+}
+function errorMessageOf(text) {
+    try {
+        const parsed = asRecord(JSON.parse(text));
+        const error = parsed?.error;
+        if (typeof error === "string" && error)
+            return error.slice(0, 1_000);
+        const record = asRecord(error);
+        if (typeof record?.message === "string" && record.message)
+            return record.message.slice(0, 1_000);
+        if (typeof parsed?.message === "string" && parsed.message)
+            return parsed.message.slice(0, 1_000);
+        if (typeof parsed?.detail === "string" && parsed.detail)
+            return parsed.detail.slice(0, 1_000);
+    }
+    catch {
+        // not JSON: raw text below
+    }
+    return text.replace(/\s+/g, " ").trim().slice(0, 300);
+}
+export function httpFailure(endpoint, status, text) {
+    const detail = errorMessageOf(text);
+    const what = endpointLabel(endpoint);
+    if (status === 400 && CONTEXT_ERROR_RE.test(detail)) {
+        return {
+            kind: "context",
+            status: 400,
+            // Claude Code 认「Prompt is too long」开头的错误做上下文处理
+            message: `Prompt is too long: ${tr(`${what}报告超出上下文窗口`, `${what} reports the context window is exceeded`)}${detail ? ` (${detail})` : ""}`,
+            retry: false,
+        };
+    }
+    const retry = status === 408 || status === 409 || status === 429 || status >= 500;
+    return {
+        kind: "http",
+        status: status >= 400 && status <= 599 ? status : 502,
+        message: tr(`${what}返回 HTTP ${status}${detail ? `:${detail}` : ""}(这是你自己配置的端点,不是 u1s1 服务)`, `${what} returned HTTP ${status}${detail ? `: ${detail}` : ""} (this is your own endpoint, not the u1s1 service)`),
+        retry,
+    };
+}
+export function transportFailure(endpoint, error) {
+    const failure = describeFetchFailure(error);
+    const what = endpointLabel(endpoint);
+    const timeout = /TIMEOUT|ETIMEDOUT/i.test(failure.code) || (error instanceof Error && error.name === "TimeoutError");
+    if (timeout && !isConnectPhaseFailure(failure)) {
+        return {
+            kind: "timeout",
+            status: 504,
+            message: tr(`${what}响应超时(${failure.detail})`, `${what} timed out (${failure.detail})`),
+            retry: true,
+        };
+    }
+    return {
+        kind: "connect",
+        status: 502,
+        message: tr(`连不上${what}(${failure.detail}),检查端点地址和网络。`, `Can't reach ${what} (${failure.detail}). Check its URL and your network.`),
+        retry: false,
+    };
+}
+export function malformedFailure(endpoint, what) {
+    return {
+        kind: "malformed",
+        status: 502,
+        message: tr(`${endpointLabel(endpoint)}的返回不是 OpenAI Chat Completions 格式(${what}),检查端点地址是否指向 …/v1。`, `${endpointLabel(endpoint)} did not answer in OpenAI Chat Completions format (${what}). Check that its URL points at …/v1.`),
+        retry: false,
+    };
+}
+function missingFailure(lookup) {
+    return {
+        kind: "http",
+        status: 404,
+        message: tr(`找不到自定义模型 ${lookup.endpointId}/${lookup.modelId}:端点或模型可能已在控制台删除或改名。`, `Custom model ${lookup.endpointId}/${lookup.modelId} not found: the endpoint or model may have been removed or renamed in the console.`),
+        retry: false,
+    };
+}
+/** Anthropic 错误形状(Claude Code):`{type: "error", error: {type, message}}` + x-should-retry。 */
+export function anthropicFailureResponse(failure) {
+    return new Response(JSON.stringify(anthropicErrorBody(failure.status, failure.message)), {
+        status: failure.status,
+        headers: { "content-type": "application/json", "x-should-retry": String(failure.retry) },
+    });
+}
+/**
+ * Responses 错误形状(Codex)。不重试的错误用网关同款的最终形状(HTTP 400 invalid_prompt,Codex 只发一次、
+ * 显示 message);超窗给 context_length_exceeded;能重试的(超时、429、5xx)按网关「上游失败」的口径:
+ * 流式请求回流内 response.failed(Codex 重试 6 次而不是 30 次),非流式回原状态码。
+ */
+export async function responsesFailureResponse(failure, ctx) {
+    if (failure.kind === "context") {
+        return openAIResponseToResponses(errorResponse(400, failure.message, "context_length_exceeded"), ctx);
+    }
+    if (!failure.retry) {
+        return responsesFinalError({ code: "invalid_prompt", type: "invalid_request_error" }, failure.status, failure.message);
+    }
+    const code = failure.status === 429 ? "rate_limit_exceeded" : "upstream_error";
+    return openAIResponseToResponses(errorResponse(failure.status, failure.message, code), ctx);
+}
+function errorResponse(status, message, code) {
+    return new Response(JSON.stringify({ error: { message, code } }), {
+        status,
+        headers: { "content-type": "application/json" },
+    });
+}
+async function callEndpoint(found, chat, sessionId, signal, fetchImpl) {
+    const body = endpointChatBody(chat, found.model);
+    let response;
+    try {
+        response = await fetchImpl(chatCompletionsUrl(found.endpoint.baseUrl), {
+            method: "POST",
+            headers: endpointRequestHeaders(found.endpoint, body.stream === true, sessionId),
+            body: JSON.stringify(body),
+            signal,
+            redirect: "error",
+        });
+    }
+    catch (error) {
+        if (signal.aborted)
+            throw error;
+        return { ok: false, failure: transportFailure(found.endpoint, error) };
+    }
+    if (!response.ok) {
+        const text = await readTextCapped(response).catch(() => "");
+        return { ok: false, failure: httpFailure(found.endpoint, response.status, text) };
+    }
+    return { ok: true, response };
+}
+const MAX_JSON_BYTES = 16 * 1024 * 1024;
+async function readTextCapped(response, max = MAX_JSON_BYTES) {
+    if (!response.body)
+        return "";
+    const reader = response.body.getReader();
+    const chunks = [];
+    let total = 0;
+    for (;;) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        total += value.byteLength;
+        if (total > max) {
+            await reader.cancel().catch(() => undefined);
+            throw new Error("response too large");
+        }
+        chunks.push(value);
+    }
+    return Buffer.concat(chunks).toString("utf8");
+}
+/** 非流式的成功响应:读成 JSON;不是 JSON、或 200 里装着 error 都算失败。 */
+async function readCompletion(found, response) {
+    let text;
+    try {
+        text = await readTextCapped(response);
+    }
+    catch (error) {
+        return { ok: false, failure: transportFailure(found.endpoint, error) };
+    }
+    let payload = null;
+    try {
+        payload = asRecord(JSON.parse(text));
+    }
+    catch {
+        payload = null;
+    }
+    if (!payload)
+        return { ok: false, failure: malformedFailure(found.endpoint, tr("不是 JSON", "not JSON")) };
+    if (payload.error !== undefined && payload.error !== null) {
+        return { ok: false, failure: httpFailure(found.endpoint, 502, text) };
+    }
+    if (!Array.isArray(payload.choices))
+        return { ok: false, failure: malformedFailure(found.endpoint, tr("没有 choices", "no choices")) };
+    return { ok: true, payload };
+}
+function isEventStream(response) {
+    return (response.headers.get("content-type") ?? "").includes("text/event-stream");
+}
+const encoder = new TextEncoder();
+/**
+ * 端点的 SSE 原文,读到一半出错(断线、超时)时补一帧 Chat 形状的 error,让下游转换器按「流中途失败」
+ * 收尾(Claude Code 收到 error 事件,Codex 收到 response.failed),而不是静默截断。
+ */
+export function guardedEventStream(body, endpoint) {
+    const reader = body.getReader();
+    return new ReadableStream({
+        async pull(controller) {
+            try {
+                const { done, value } = await reader.read();
+                if (done)
+                    controller.close();
+                else
+                    controller.enqueue(value);
+            }
+            catch (error) {
+                const failure = transportFailure(endpoint, error);
+                const frame = { error: { message: tr(`${endpointLabel(endpoint)}的流中途断开:${failure.message}`, `${endpointLabel(endpoint)} stream broke off: ${failure.message}`), code: failure.status } };
+                controller.enqueue(encoder.encode(`\n\ndata: ${JSON.stringify(frame)}\n\n`));
+                controller.close();
+            }
+        },
+        cancel(reason) {
+            return reader.cancel(reason);
+        },
+    });
+}
+// ---------------------------------------------------------------- protocols
+function collectText(value) {
+    if (typeof value === "string")
+        return value;
+    if (Array.isArray(value))
+        return value.map(collectText).join("");
+    const record = asRecord(value);
+    if (!record)
+        return "";
+    return Object.entries(record)
+        .filter(([key]) => key !== "role" && key !== "type" && key !== "id" && key !== "tool_call_id")
+        .map(([, field]) => collectText(field))
+        .join("");
+}
+async function serveMessages(match, found, deps) {
+    const clientModel = found.id;
+    const chat = anthropicRequestToChat(match.body, reasoningFieldsFor(found.model));
+    if (match.protocol === "count_tokens") {
+        const text = collectText(chat.messages) + collectText(chat.tools ?? "");
+        return Response.json({ input_tokens: estimateTokensFromText(text) });
+    }
+    const call = await callEndpoint(found, chat, deps.sessionId, deps.signal, deps.fetchImpl);
+    if (!call.ok)
+        return anthropicFailureResponse(call.failure);
+    if (chat.stream === true && isEventStream(call.response) && call.response.body) {
+        const body = guardedEventStream(call.response.body, found.endpoint).pipeThrough(chatSseToAnthropic(clientModel));
+        return new Response(body, { status: 200, headers: { "content-type": "text/event-stream", "cache-control": "no-cache" } });
+    }
+    const read = await readCompletion(found, call.response);
+    if (!read.ok)
+        return anthropicFailureResponse(read.failure);
+    const message = chatCompletionToAnthropic(read.payload, clientModel);
+    if (chat.stream !== true)
+        return Response.json(message);
+    // 要了流式、端点却回了整段 JSON:按 Anthropic 事件序列补成流
+    return new Response(anthropicMessageAsSse(message), { status: 200, headers: { "content-type": "text/event-stream", "cache-control": "no-cache" } });
+}
+/** 一条完整的 Anthropic message → 等价的 SSE 事件序列(端点不支持流式时用)。 */
+export function anthropicMessageAsSse(message) {
+    const frames = [];
+    const emit = (type, data) => frames.push(`event: ${type}\ndata: ${JSON.stringify({ type, ...data })}\n\n`);
+    const content = Array.isArray(message.content) ? message.content : [];
+    emit("message_start", { message: { ...message, content: [], stop_reason: null, usage: { input_tokens: 0, output_tokens: 0 } } });
+    content.forEach((block, index) => {
+        if (block.type === "thinking") {
+            emit("content_block_start", { index, content_block: { type: "thinking", thinking: "", signature: "" } });
+            emit("content_block_delta", { index, delta: { type: "thinking_delta", thinking: block.thinking } });
+        }
+        else if (block.type === "text") {
+            emit("content_block_start", { index, content_block: { type: "text", text: "" } });
+            emit("content_block_delta", { index, delta: { type: "text_delta", text: block.text } });
+        }
+        else if (block.type === "tool_use") {
+            emit("content_block_start", { index, content_block: { ...block, input: {} } });
+            emit("content_block_delta", { index, delta: { type: "input_json_delta", partial_json: JSON.stringify(block.input ?? {}) } });
+        }
+        emit("content_block_stop", { index });
+    });
+    emit("message_delta", { delta: { stop_reason: message.stop_reason, stop_sequence: null }, usage: message.usage });
+    emit("message_stop", {});
+    return frames.join("");
+}
+async function serveResponses(match, found, deps) {
+    const { body: chat, notes } = responsesRequestToChat(match.body, reasoningFieldsFor(found.model));
+    const ctx = responsesContext(match.body, notes);
+    // 与网关 responses-route.ts 一样只做无状态子集
+    if (ctx.previousResponseId || ctx.conversation) {
+        return responsesFinalError({ code: "invalid_prompt", param: ctx.previousResponseId ? "previous_response_id" : "conversation" }, 400, tr("自定义端点只支持无状态请求:请在 input 里带上完整对话(store=false),不要用 previous_response_id / conversation。", "Custom endpoints are stateless: send the whole conversation in `input` (store=false) instead of previous_response_id / conversation."));
+    }
+    const call = await callEndpoint(found, chat, deps.sessionId, deps.signal, deps.fetchImpl);
+    if (!call.ok)
+        return responsesFailureResponse(call.failure, ctx);
+    if (chat.stream === true && isEventStream(call.response) && call.response.body) {
+        const guarded = guardedEventStream(call.response.body, found.endpoint);
+        return openAIResponseToResponses(new Response(guarded, { status: 200, headers: { "content-type": "text/event-stream" } }), ctx);
+    }
+    const read = await readCompletion(found, call.response);
+    if (!read.ok)
+        return responsesFailureResponse(read.failure, ctx);
+    if (chat.stream !== true)
+        return openAIResponseToResponses(Response.json(read.payload), ctx);
+    // 要了流式、端点却回了整段 JSON:把它当成只有一帧的 Chat 流,交给同一个流式转换器
+    const sse = `data: ${JSON.stringify(completionAsChunk(read.payload))}\n\ndata: [DONE]\n\n`;
+    return openAIResponseToResponses(new Response(sse, { status: 200, headers: { "content-type": "text/event-stream" } }), ctx);
+}
+/** chat.completion → 等价的单个 chat.completion.chunk(message 换成 delta,工具调用补 index)。 */
+export function completionAsChunk(payload) {
+    const choices = (Array.isArray(payload.choices) ? payload.choices : []).map((item) => {
+        const choice = asRecord(item) ?? {};
+        const message = asRecord(choice.message) ?? {};
+        const calls = Array.isArray(message.tool_calls)
+            ? message.tool_calls.map((call, index) => ({ index, ...asRecord(call) }))
+            : undefined;
+        return { index: choice.index ?? 0, delta: { ...message, ...(calls ? { tool_calls: calls } : {}) }, finish_reason: choice.finish_reason ?? "stop" };
+    });
+    return { id: payload.id, object: "chat.completion.chunk", choices, ...(payload.usage ? { usage: payload.usage } : {}) };
+}
+/** 处理一个本地路由的请求,得到给客户端的 Web Response。 */
+export async function customRouteResponse(match, input) {
+    const deps = {
+        sessionId: clientSessionId(input.headers),
+        signal: input.signal,
+        fetchImpl: input.fetchImpl ?? ((url, init) => fetch(url, init)),
+    };
+    if (match.lookup.kind === "missing") {
+        const failure = missingFailure(match.lookup);
+        if (match.protocol === "responses")
+            return responsesFailureResponse(failure, responsesContext(match.body, emptyNotes()));
+        return anthropicFailureResponse(failure);
+    }
+    const found = match.lookup.found;
+    return match.protocol === "responses" ? serveResponses(match, found, deps) : serveMessages(match, found, deps);
+}
+function emptyNotes() {
+    return { skippedItems: [], skippedTools: [], customTools: [], namespaces: [], aliases: {}, toolSearch: false };
+}
+/** Web Response → 本机 http 响应(流式逐块写)。 */
+export async function writeWebResponse(res, response) {
+    const headers = {};
+    response.headers.forEach((value, name) => {
+        if (name !== "content-length" && name !== "transfer-encoding" && name !== "connection")
+            headers[name] = value;
+    });
+    res.writeHead(response.status, headers);
+    if (response.body) {
+        for await (const chunk of Readable.fromWeb(response.body)) {
+            res.write(chunk);
+        }
+    }
+    res.end();
+}

package/dist/device-auth.d.ts

@@ -1,6 +1,7 @@
 import { webcrypto } from "node:crypto";
 import { type IncomingMessage } from "node:http";
-import { type CliConfig } from "./config.js";
+import { type CliConfig, type CustomEndpoint } from "./config.js";
+import { type FetchLike } from "./custom-endpoint-proxy.js";
 import { type GatewayFetchFailure } from "./gateway-route.js";
 export declare function hasDeviceCredential(cfg: CliConfig): boolean;
 export declare function generateDeviceKeyPair(): Promise<{
@@ -58,6 +59,16 @@ interface SigningProxy {
     client: ClientSurface;
     agent?: LaunchedAgent;
     attestation: AttestationHolder;
+    customRoutes: CustomRoutes;
+}
+/**
+ * 自定义端点的本地路由(custom-endpoint-proxy.ts):model 是 `ep…/<模型>` 的 /v1/messages、
+ * /v1/responses 在本机转 Chat Completions 直连端点,不经网关。复用同一个代理时以最新一次传入的为准。
+ */
+export interface CustomRoutes {
+    endpoints: readonly CustomEndpoint[];
+    /** 测试注入;默认全局 fetch(与 Pi 直连自定义端点同一个 dispatcher) */
+    fetchImpl?: FetchLike;
 }
 /**
  * Which client the launcher started behind this proxy. Sent as `x-u1s1-agent` /
@@ -104,4 +115,4 @@ export declare function onGatewayFetchFailure(listener: ((failure: GatewayFetchF
  * pi accepts static provider headers only. Keep it behind a loopback proxy that
  * replaces the local bearer credential with a fresh DPoP proof per request.
  */
-export declare function ensureSigningProxy(cfg: CliConfig, fallbackClient?: ClientSurface, attestationSource?: ClientAttestationSource, agent?: LaunchedAgent): Promise<SigningProxy>;
+export declare function ensureSigningProxy(cfg: CliConfig, fallbackClient?: ClientSurface, attestationSource?: ClientAttestationSource, agent?: LaunchedAgent, customRoutes?: CustomRoutes): Promise<SigningProxy>;

package/dist/device-auth.js

@@ -2,6 +2,7 @@ import { createHash, randomBytes, randomUUID, webcrypto } from "node:crypto";
 import { createServer } from "node:http";
 import { arch, platform, release } from "node:os";
 import { VERSION } from "./config.js";
+import { customRouteResponse, matchCustomRoute, writeWebResponse } from "./custom-endpoint-proxy.js";
 import { tr } from "./i18n.js";
 import { describeFetchFailure, gatewayFetch, plainGatewaySender } from "./gateway-route.js";
 const enc = new TextEncoder();
@@ -267,16 +268,20 @@ export function onGatewayFetchFailure(listener) {
  * pi accepts static provider headers only. Keep it behind a loopback proxy that
  * replaces the local bearer credential with a fresh DPoP proof per request.
  */
-export async function ensureSigningProxy(cfg, fallbackClient = "terminal", attestationSource, agent) {
+export async function ensureSigningProxy(cfg, fallbackClient = "terminal", attestationSource, agent, customRoutes) {
     if (!hasDeviceCredential(cfg))
         throw new Error(tr("当前安装需要重新登录，以创建设备凭证", "Please sign in again to create a device credential for this install."));
     const client = clientSurface(fallbackClient);
     const current = signingProxy;
     if (current && current.token === cfg.deviceToken && current.client === client && sameAgent(current.agent, agent)) {
         updateAttestationHolder(current.attestation, attestationSource);
+        if (customRoutes)
+            current.customRoutes = { ...customRoutes };
         return current;
     }
     const attestation = {};
+    // 由下面的 signingProxy 对象持有(复用时会被换掉),请求处理时现取
+    let routesOf = () => customRoutes ?? { endpoints: [] };
     updateAttestationHolder(attestation, attestationSource);
     const localKey = `local-${randomBytes(32).toString("hex")}`;
     const upstreamOrigin = new URL(cfg.baseUrl).origin;
@@ -308,6 +313,32 @@ export async function ensureSigningProxy(cfg, fallbackClient = "terminal", attes
             const pathAndQuery = `${localUrl.pathname}${localUrl.search}`;
             try {
                 const body = await readSigningProxyRequestBody(req);
+                // 自定义端点的模型:本机转换后直连端点。到这里为止只用了本地 token 校验;下面网关那条路上的
+                // 设备凭证、DPoP、客户端证明、x-u1s1-* 头都不会碰到这个请求
+                const routes = routesOf();
+                const custom = matchCustomRoute(req.method, localUrl.pathname, body, routes.endpoints);
+                if (custom) {
+                    try {
+                        const response = await customRouteResponse(custom, {
+                            headers: req.headers,
+                            signal: upstreamAbort.signal,
+                            ...(routes.fetchImpl ? { fetchImpl: routes.fetchImpl } : {}),
+                        });
+                        await writeWebResponse(res, response);
+                    }
+                    catch (error) {
+                        // 端点自己的失败已在 customRouteResponse 里转成客户端的错误形状;到这里的是客户端断开或
+                        // 本机意外。不走下面「连不上 u1s1 服务器」那条(那是网关的话,也不上报网关连通性)
+                        if (res.destroyed)
+                            return;
+                        if (res.headersSent)
+                            return void res.destroy(error);
+                        res.writeHead(502, { "content-type": "application/json" });
+                        const detail = error instanceof Error ? error.message : String(error);
+                        res.end(JSON.stringify({ error: { message: tr(`本机转发自定义端点请求时出错(${detail})`, `Local forwarding to the custom endpoint failed (${detail})`) } }));
+                    }
+                    return;
+                }
                 const outboundHeaders = requestHeaders(req.headers);
                 // Set these at the final local hop so model calls and extension tools share
                 // exactly the same attribution, regardless of their upstream SDK defaults.
@@ -365,13 +396,16 @@ export async function ensureSigningProxy(cfg, fallbackClient = "terminal", attes
     });
     server.unref();
     const port = server.address().port;
-    signingProxy = {
+    const created = {
         baseUrl: `http://127.0.0.1:${port}/v1`,
         localKey,
         token: cfg.deviceToken,
         client,
         ...(agent ? { agent: { ...agent } } : {}),
         attestation,
+        customRoutes: customRoutes ? { ...customRoutes } : { endpoints: [] },
     };
+    routesOf = () => created.customRoutes;
+    signingProxy = created;
     return signingProxy;
 }

package/dist/index.js

@@ -1,4 +1,12 @@
 #!/usr/bin/env node
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
 import { printConsoleBanner } from "./brand.js";
 import { activeSite, loadConfig, pinLegacySiteBaseUrl, readSettings, VERSION } from "./config.js";
 import { siteLinks, siteOf } from "./site.js";
@@ -13,7 +21,7 @@ import { isLauncherWord, launcherHelpRow, runLauncher } from "./launcher.js";
 async function configureStartupHttp() {
     const piEntry = import.meta.resolve("@earendil-works/pi-coding-agent");
     const dispatcherUrl = new URL("./core/http-dispatcher.js", piEntry).href;
-    const dispatcher = await import(dispatcherUrl);
+    const dispatcher = await import(__rewriteRelativeImportExtension(dispatcherUrl));
     dispatcher.applyHttpProxySettings(readSettings().httpProxy);
     dispatcher.configureHttpDispatcher();
 }

package/dist/launcher.js

@@ -6,6 +6,7 @@
  *                                全新用户首次运行出选择器并记住
  *   u1s1 use <客户端>            改默认
  *   u1s1 agents [pin|unpin|install …]  安装状态、版本、是否有更新;锁定版本;只下载不启动
+ *   u1s1 agents models [--json]  各客户端可用的模型(带显示名),给 Hearth 等前端用;不登录、秒回
  *   u1s1 config [list|get|set|unset …]  用户可调的设置(默认客户端、各客户端默认模型、自动更新),见 config-command.ts
  *
  * claude / codex 是否可用完全由网关配置(/v1/agents/:agent/config 的 enabled)决定,这里不写死。
@@ -178,6 +179,12 @@ async function agentsCommand(args) {
         process.exitCode = sub === "pin" ? await pinCommand(version, agent) : unpinCommand(agent);
         return;
     }
+    if (sub === "models") {
+        // 不经 ensureAuth:未登录直接输出 loggedIn:false;联网只做短超时刷新,失败用缓存
+        const { modelsCommand } = await import("./agents/models-list.js");
+        process.exitCode = await modelsCommand(args.slice(1));
+        return;
+    }
     if (sub === "install") {
         if (agent === "pi" && version === undefined) {
             console.log(tr("pi 随 u1s1 一起安装,不用单独下载。", "pi ships with u1s1; nothing to download."));
@@ -208,6 +215,7 @@ function agentsHelpLines() {
         tr("  u1s1 agents install <客户端>      下载或更新到可用版本,不启动(claude / codex)", "  u1s1 agents install <client>      Download or update to a usable version without launching (claude / codex)"),
         tr("  u1s1 agents pin <客户端> <版本>   锁定版本(不超出允许的范围)", "  u1s1 agents pin <client> <ver>    Pin a version (within the allowed range)"),
         tr("  u1s1 agents unpin <客户端>        解除锁定,恢复自动更新", "  u1s1 agents unpin <client>        Remove the pin and resume automatic updates"),
+        tr("  u1s1 agents models [--json]       列出各客户端可用的模型(带显示名);--offline 只读本地缓存", "  u1s1 agents models [--json]       List each client's models with display names; --offline reads local caches only"),
     ];
 }
 // ---------------------------------------------------------------- help

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "u1s1-cli",
-  "version": "1.17.0",
-  "description": "u1s1 — 有一说一,最省心的 AI 编程搭子。终端里用中文说需求,AI 帮你读文件、改代码、跑命令。",
+  "version": "1.19.0",
+  "description": "u1s1 — an AI coding buddy in your terminal. Describe what you need; it reads files, edits code and runs commands.",
   "type": "module",
   "bin": {
     "u1s1": "dist/index.js"
@@ -39,7 +39,7 @@
     "u1s1"
   ],
   "license": "MIT",
-  "homepage": "https://u1s1app.com",
+  "homepage": "https://u1s1.dev",
   "dependencies": {
     "@earendil-works/pi-agent-core": "1.5.2",
     "@earendil-works/pi-ai": "1.5.2",
@@ -58,6 +58,6 @@
     "typescript": "^5.9.3"
   },
   "u1s1": {
-    "defaultSite": "cn"
+    "defaultSite": "intl"
   }
 }