u1s1-cli 1.18.0 → 1.20.0

package/dist/chat-protocol/sse.d.ts

@@ -0,0 +1,19 @@
+/** One upstream SSE event cap: longer events are a broken or hostile upstream. */
+export declare const MAX_SSE_EVENT_CHARS: number;
+/** Comment frame SSE clients ignore; forwarded so idle timers reset. */
+export declare const SSE_KEEPALIVE_COMMENT = ": keepalive\n\n";
+export interface SseEvent {
+    data: string;
+    event: string;
+}
+export declare class SseEventTooLargeError extends Error {
+    constructor();
+}
+/** Incremental SSE parser: feed decoded text, get complete events regardless of chunk boundaries. */
+export declare class SseParser {
+    private buffered;
+    private readonly maxEventChars;
+    constructor(maxEventChars?: number);
+    push(text: string): SseEvent[];
+    finish(text?: string): SseEvent[];
+}

package/dist/chat-protocol/sse.js

@@ -0,0 +1,67 @@
+// GENERATED from workers/gateway/src/chat-protocol/sse.ts; do not edit here. Edit the canonical file, then run: node scripts/sync-chat-protocol.mjs
+// Server-sent events parsing for the converters (see json.ts for the rules of this directory).
+/** One upstream SSE event cap: longer events are a broken or hostile upstream. */
+export const MAX_SSE_EVENT_CHARS = 1 * 1_024 * 1_024;
+/** Comment frame SSE clients ignore; forwarded so idle timers reset. */
+export const SSE_KEEPALIVE_COMMENT = ": keepalive\n\n";
+// Enumerate two consecutive SSE line endings explicitly. A compositional
+// `(CRLF|CR|LF){2}` regex can backtrack and misread one CRLF as CR + LF.
+const SSE_EVENT_BOUNDARY = /\r\n\r\n|\r\n\n|\r\n\r|\n\r\n|\n\n|\n\r|\r\r\n|\r\r/;
+export class SseEventTooLargeError extends Error {
+    constructor() {
+        super("upstream SSE event exceeded limit");
+        this.name = "SseEventTooLargeError";
+    }
+}
+function eventFields(frame) {
+    const data = [];
+    let event = "";
+    for (const line of frame.split(/\r\n|\r|\n/)) {
+        if (!line || line.startsWith(":"))
+            continue;
+        const separator = line.indexOf(":");
+        const field = separator < 0 ? line : line.slice(0, separator);
+        let value = separator < 0 ? "" : line.slice(separator + 1);
+        if (value.startsWith(" "))
+            value = value.slice(1);
+        if (field === "data")
+            data.push(value);
+        else if (field === "event")
+            event = value;
+    }
+    return { data: data.join("\n"), event };
+}
+/** Incremental SSE parser: feed decoded text, get complete events regardless of chunk boundaries. */
+export class SseParser {
+    buffered = "";
+    maxEventChars;
+    constructor(maxEventChars = MAX_SSE_EVENT_CHARS) {
+        this.maxEventChars = maxEventChars;
+    }
+    push(text) {
+        this.buffered += text;
+        const events = [];
+        let boundary = SSE_EVENT_BOUNDARY.exec(this.buffered);
+        while (boundary?.index !== undefined) {
+            if (boundary.index > this.maxEventChars) {
+                this.buffered = "";
+                throw new SseEventTooLargeError();
+            }
+            events.push(eventFields(this.buffered.slice(0, boundary.index)));
+            this.buffered = this.buffered.slice(boundary.index + boundary[0].length);
+            boundary = SSE_EVENT_BOUNDARY.exec(this.buffered);
+        }
+        if (this.buffered.length > this.maxEventChars) {
+            this.buffered = "";
+            throw new SseEventTooLargeError();
+        }
+        return events;
+    }
+    finish(text = "") {
+        const events = this.push(text);
+        if (this.buffered.trim())
+            events.push(eventFields(this.buffered));
+        this.buffered = "";
+        return events;
+    }
+}

package/dist/chat-protocol/thinking.d.ts

@@ -0,0 +1,22 @@
+import { type JsonRecord } from "./json.ts";
+/**
+ * Same contract as workers/gateway/src/model-thinking.ts and
+ * packages/cli/src/config.ts THINKING_LEVELS; the gateway passes its own
+ * thinkingWireFields here, so a drift fails its typecheck.
+ */
+export declare const THINKING_LEVELS: readonly ["off", "minimal", "low", "medium", "high", "xhigh", "max"];
+export type ThinkingLevel = (typeof THINKING_LEVELS)[number];
+/** Model id + requested level → reasoning fields of the Chat Completions body. */
+export type ReasoningFields = (modelId: string, level: ThinkingLevel | null) => JsonRecord;
+/**
+ * Anthropic Messages body → requested level. Claude Code sends
+ * `thinking: {type: "adaptive"}` + `output_config.effort`, and
+ * `thinking: {type: "disabled"}` when thinking is off; the legacy
+ * `{type: "enabled", budget_tokens}` is mapped by budget. No opinion → null.
+ */
+export declare function requestedThinkingLevel(body: JsonRecord): ThinkingLevel | null;
+/** Responses `reasoning.effort` → level. */
+export declare const RESPONSES_REASONING_EFFORTS: Readonly<Record<string, ThinkingLevel>>;
+export declare function responsesThinkingLevel(body: JsonRecord): ThinkingLevel | null;
+/** Rough prompt-size estimate (ASCII ~4 chars/token, other ~1.5) for count_tokens style endpoints. */
+export declare function estimateTokensFromText(text: string): number;

package/dist/chat-protocol/thinking.js

@@ -0,0 +1,58 @@
+// GENERATED from workers/gateway/src/chat-protocol/thinking.ts; do not edit here. Edit the canonical file, then run: node scripts/sync-chat-protocol.mjs
+// Thinking levels as clients request them (see json.ts for the rules of this directory).
+import { asRecord } from "./json.js";
+/**
+ * Same contract as workers/gateway/src/model-thinking.ts and
+ * packages/cli/src/config.ts THINKING_LEVELS; the gateway passes its own
+ * thinkingWireFields here, so a drift fails its typecheck.
+ */
+export const THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"];
+/**
+ * Anthropic Messages body → requested level. Claude Code sends
+ * `thinking: {type: "adaptive"}` + `output_config.effort`, and
+ * `thinking: {type: "disabled"}` when thinking is off; the legacy
+ * `{type: "enabled", budget_tokens}` is mapped by budget. No opinion → null.
+ */
+export function requestedThinkingLevel(body) {
+    const thinking = asRecord(body.thinking);
+    if (thinking?.type === "disabled")
+        return "off";
+    const effort = asRecord(body.output_config)?.effort;
+    if (typeof effort === "string" && effort !== "off" && THINKING_LEVELS.includes(effort)) {
+        return effort;
+    }
+    if (thinking?.type === "enabled") {
+        const budget = Number(thinking.budget_tokens);
+        if (!Number.isFinite(budget) || budget <= 0)
+            return null;
+        return budget <= 4096 ? "low" : budget <= 16_384 ? "medium" : "high";
+    }
+    return null;
+}
+/** Responses `reasoning.effort` → level. */
+export const RESPONSES_REASONING_EFFORTS = {
+    none: "off",
+    minimal: "minimal",
+    low: "low",
+    medium: "medium",
+    high: "high",
+    xhigh: "xhigh",
+};
+export function responsesThinkingLevel(body) {
+    const effort = asRecord(body.reasoning)?.effort;
+    return typeof effort === "string" ? RESPONSES_REASONING_EFFORTS[effort] ?? null : null;
+}
+/** Rough prompt-size estimate (ASCII ~4 chars/token, other ~1.5) for count_tokens style endpoints. */
+export function estimateTokensFromText(text) {
+    if (!text)
+        return 0;
+    let ascii = 0;
+    let wide = 0;
+    for (const char of text) {
+        if (char.charCodeAt(0) < 0x80)
+            ascii += 1;
+        else
+            wide += 1;
+    }
+    return Math.ceil(ascii / 4 + wide / 1.5);
+}

package/dist/config-command.d.ts

@@ -1,4 +1,4 @@
-declare const CLIENTS: readonly ["claude", "codex"];
+declare const CLIENTS: readonly ["claude", "codex", "dsh"];
 type Client = (typeof CLIENTS)[number];
 export type ConfigKey = "default-client" | "pi.model" | `${Client}.model` | `${Client}.auto-update` | `${Client}.pin`;
 export declare const CONFIG_KEYS: readonly ConfigKey[];

package/dist/config-command.js

@@ -9,14 +9,16 @@
  *   u1s1 config unset <键>            恢复默认
  *
  * 键:
- *   default-client        pi | claude | codex             同 u1s1 use
+ *   default-client        pi | claude | codex | dsh       同 u1s1 use
  *   pi.model              模型 id 或别名                  同 u1s1 model <模型>
  *   claude.model          模型 id                          u1s1 claude 的默认模型(--settings 的 model)
  *   codex.model           模型 id                          u1s1 codex 的默认模型(config.toml 的 model)
+ *   dsh.model             模型 id                          u1s1 dsh 的默认模型(--patch 里 agent-default-model)
  *   claude.auto-update    on | off                         每天查新、下次启动前更新;缺省 on
  *   codex.auto-update     on | off
  *   claude.pin            版本号                           同 u1s1 agents pin / unpin
  *   codex.pin             版本号
+ *   dsh.auto-update / dsh.pin                             同上
  *
  * 客户端的模型只按网关上次下发的阵容(启动配置缓存)核对:还没启动过、没有缓存时照收,启动时再核对,
  * 不在阵容里就退回默认模型并提示一次(prefs.ts)。
@@ -25,23 +27,26 @@ import { existsSync } from "node:fs";
 import { createInterface } from "node:readline/promises";
 import { agentSettingsFile, isDefaultAgent, loadConfig, readRawConfigFile, saveDefaultAgent, } from "./config.js";
 import { tr } from "./i18n.js";
-const CLIENTS = ["claude", "codex"];
+const CLIENTS = ["claude", "codex", "dsh"];
 export const CONFIG_KEYS = [
     "default-client",
     "pi.model",
     "claude.model",
     "codex.model",
+    "dsh.model",
     "claude.auto-update",
     "codex.auto-update",
+    "dsh.auto-update",
     "claude.pin",
     "codex.pin",
+    "dsh.pin",
 ];
 export function isConfigKey(value) {
     return typeof value === "string" && CONFIG_KEYS.includes(value);
 }
 function clientOf(key) {
     const prefix = key.split(".")[0];
-    return prefix === "claude" || prefix === "codex" ? prefix : undefined;
+    return CLIENTS.includes(prefix ?? "") ? prefix : undefined;
 }
 function describe(key) {
     const client = clientOf(key);
@@ -97,7 +102,12 @@ async function cachedLineup(client) {
     const config = cached ? parseAgentConfig(cached.body, AGENT_PROFILES[client].gatewayAgent) : undefined;
     if (!config || !config.enabled)
         return undefined;
-    return { ids: config.models.map((m) => m.id), defaultModel: config.defaultModel };
+    // 自定义端点的模型(ep…/<模型>)也能选:按上次拉到的端点缓存核对,不联网
+    const { agentCustomModels } = await import("./agents/custom-models.js");
+    const { loadEndpointsCache } = await import("./config.js");
+    // dsh 走 /v1/chat/completions,本地路由只转 /v1/messages、/v1/responses:不列自定义模型
+    const custom = client === "dsh" ? [] : agentCustomModels(loadEndpointsCache()).map((c) => c.id);
+    return { ids: [...config.models.map((m) => m.id), ...custom], defaultModel: config.defaultModel };
 }
 function parseSwitch(value) {
     const v = value.trim().toLowerCase();
@@ -117,7 +127,7 @@ export async function writeConfigValue(key, value) {
             return 0;
         }
         if (!isDefaultAgent(value)) {
-            console.error(tr("default-client 只能是 pi、claude 或 codex。", "default-client must be pi, claude or codex."));
+            console.error(tr("default-client 只能是 pi、claude、codex 或 dsh。", "default-client must be pi, claude, codex or dsh."));
             return 1;
         }
         saveDefaultAgent(value);
@@ -192,11 +202,11 @@ export function configHelpLines() {
         ["u1s1 config unset <键>", tr("恢复默认", "Restore the default")],
     ];
     const keyRows = [
-        ["default-client", "pi | claude | codex"],
+        ["default-client", "pi | claude | codex | dsh"],
         ["pi.model", tr("模型 id 或别名", "model id or alias")],
-        ["claude.model, codex.model", tr("模型 id;default = 跟随网关默认", "model id; default = gateway default")],
-        ["claude.auto-update, codex.auto-update", "on | off"],
-        ["claude.pin, codex.pin", tr("版本号", "version")],
+        ["claude.model, codex.model, dsh.model", tr("模型 id;default = 跟随网关默认", "model id; default = gateway default")],
+        ["<client>.auto-update", "on | off  (claude / codex / dsh)"],
+        ["<client>.pin", tr("版本号(claude / codex / dsh)", "version (claude / codex / dsh)")],
     ];
     const usage = rows.map(([a, b]) => `  ${tr(a, a.replace("<键>", "<key>").replace("<值>", "<value>")).padEnd(30)}${b}`);
     return [
@@ -265,7 +275,7 @@ function padDisplay(text, width) {
 async function choicesFor(key) {
     const client = clientOf(key);
     if (key === "default-client") {
-        return ["pi", "claude", "codex"].map((a) => ({ label: a, value: a }));
+        return ["pi", "claude", "codex", "dsh"].map((a) => ({ label: a, value: a }));
     }
     if (key.endsWith(".auto-update")) {
         return [

package/dist/config.d.ts

@@ -139,6 +139,26 @@ export declare const CUSTOM_ENDPOINTS: CustomEndpoint[];
 export declare function setCustomEndpoints(endpoints: CustomEndpoint[]): void;
 /** 端点密钥不写进 models.json,走这个环境变量引用(pi 读取时解析)。 */
 export declare function endpointKeyEnvName(endpointId: string): string;
+/**
+ * 自定义模型的「推理参数格式」(dashboard 模型行第 6 栏,/v1/endpoints 的 models[].thinking_format)。
+ * 与 workers/gateway/src/endpoint-validation.ts 的 THINKING_FORMATS 是同一取值空间。
+ * - openai(默认;老服务端不下发该字段):沿用 pi 的通用 OpenAI 行为——只发 reasoning_effort,
+ *   关思考时什么都不发(后端按自己的默认值思考)。
+ * - deepseek:DeepSeek V4 的档位(off / low / high / max,默认 high)。2026-11-13 实测
+ *   LiteLLM + vLLM 部署的 DeepSeek-V4-Flash:顶层 reasoning_effort 原样透传、能控级别,
+ *   "none" 能关思考;顶层 thinking 字段会被 LiteLLM 以 UnsupportedParamsError 400 拒掉。
+ *   所以只发 reasoning_effort(关 = "none");只有官方 api.deepseek.com 用 DeepSeek 自己的
+ *   thinking {type} + reasoning_effort 格式。
+ */
+export declare const CUSTOM_THINKING_FORMATS: readonly ["openai", "deepseek"];
+export type CustomThinkingFormat = (typeof CUSTOM_THINKING_FORMATS)[number];
+/** 未知取值(更新的服务端加了新格式)按默认 openai 处理,不让老 CLI 拒收整个端点。 */
+export declare function parseCustomThinkingFormat(value: unknown): CustomThinkingFormat;
+/**
+ * 推理参数格式 → 交给 pi 的思考能力描述(与网关模型的 thinking 同一结构,toProviderModels 统一翻译)。
+ * openai 返回 undefined = 不声明档位,pi 走原来的通用行为。
+ */
+export declare function customThinkingCapabilities(format: CustomThinkingFormat, baseUrl: string): ThinkingCapabilities | undefined;
 /** 服务端 /v1/endpoints 的一条记录 → CustomEndpoint(补默认值、生成别名)。 */
 export declare function apiEndpointToCustom(e: {
     id: string;
@@ -153,6 +173,8 @@ export declare function apiEndpointToCustom(e: {
         vision?: boolean;
         context_window?: number;
         max_tokens?: number;
+        /** 老服务端没有这个字段 → openai */
+        thinking_format?: string;
     }[];
 }): CustomEndpoint;
 /** 模型引用 = provider 注册键 + 模型 id;provider 是 u1s1 或某个端点 id。 */
@@ -189,7 +211,7 @@ export interface CliConfig {
     /** 默认客户端(`u1s1 use`/首次选择器写入);缺省 = 存量用户,按 Pi 处理(见 launcher.ts)。 */
     defaultAgent?: DefaultAgent;
 }
-export type DefaultAgent = "pi" | "claude" | "codex";
+export type DefaultAgent = "pi" | "claude" | "codex" | "dsh";
 export declare function isDefaultAgent(value: unknown): value is DefaultAgent;
 export declare const u1s1Dir: string;
 export declare const configFile: string;

package/dist/config.js

@@ -216,6 +216,50 @@ export function setCustomEndpoints(endpoints) {
 export function endpointKeyEnvName(endpointId) {
     return `U1S1_EP_KEY_${endpointId}`;
 }
+/**
+ * 自定义模型的「推理参数格式」(dashboard 模型行第 6 栏,/v1/endpoints 的 models[].thinking_format)。
+ * 与 workers/gateway/src/endpoint-validation.ts 的 THINKING_FORMATS 是同一取值空间。
+ * - openai(默认;老服务端不下发该字段):沿用 pi 的通用 OpenAI 行为——只发 reasoning_effort,
+ *   关思考时什么都不发(后端按自己的默认值思考)。
+ * - deepseek:DeepSeek V4 的档位(off / low / high / max,默认 high)。2026-11-13 实测
+ *   LiteLLM + vLLM 部署的 DeepSeek-V4-Flash:顶层 reasoning_effort 原样透传、能控级别,
+ *   "none" 能关思考;顶层 thinking 字段会被 LiteLLM 以 UnsupportedParamsError 400 拒掉。
+ *   所以只发 reasoning_effort(关 = "none");只有官方 api.deepseek.com 用 DeepSeek 自己的
+ *   thinking {type} + reasoning_effort 格式。
+ */
+export const CUSTOM_THINKING_FORMATS = ["openai", "deepseek"];
+/** 未知取值(更新的服务端加了新格式)按默认 openai 处理,不让老 CLI 拒收整个端点。 */
+export function parseCustomThinkingFormat(value) {
+    const v = typeof value === "string" ? value.trim().toLowerCase() : "";
+    return CUSTOM_THINKING_FORMATS.includes(v) ? v : "openai";
+}
+/**
+ * 官方 DeepSeek API 按域名特判:它的开关是 thinking {type: enabled|disabled},不认 reasoning_effort "none";
+ * 自建(vLLM / LiteLLM 等)认 "none" 却会拒 thinking 字段。只认精确主机名,仿冒子域名不算。
+ */
+function isOfficialDeepSeekUrl(baseUrl) {
+    try {
+        return new URL(baseUrl).hostname.toLowerCase() === "api.deepseek.com";
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * 推理参数格式 → 交给 pi 的思考能力描述(与网关模型的 thinking 同一结构,toProviderModels 统一翻译)。
+ * openai 返回 undefined = 不声明档位,pi 走原来的通用行为。
+ */
+export function customThinkingCapabilities(format, baseUrl) {
+    if (format !== "deepseek")
+        return undefined;
+    return {
+        levels: ["off", "low", "high", "max"],
+        defaultLevel: "high",
+        canDisable: true,
+        levelMap: { off: "none", low: "low", high: "high", max: "max" },
+        requestFormat: isOfficialDeepSeekUrl(baseUrl) ? "deepseek" : "openai",
+    };
+}
 /** 服务端 /v1/endpoints 的一条记录 → CustomEndpoint(补默认值、生成别名)。 */
 export function apiEndpointToCustom(e) {
     return {
@@ -229,6 +273,10 @@ export function apiEndpointToCustom(e) {
             name: m.name || m.id,
             aliases: defaultAliases(m.id),
             reasoning: !!m.reasoning,
+            // 只对推理模型生效:非推理模型 pi 本来就不发推理参数
+            ...(m.reasoning
+                ? withThinking(customThinkingCapabilities(parseCustomThinkingFormat(m.thinking_format), e.base_url))
+                : {}),
             vision: !!m.vision,
             contextWindow: m.context_window ?? 128_000,
             maxTokens: m.max_tokens ?? 16_384,
@@ -238,6 +286,9 @@ export function apiEndpointToCustom(e) {
         })),
     };
 }
+function withThinking(thinking) {
+    return thinking ? { thinking } : {};
+}
 /** ref 指向的模型仍然存在吗(服务端下架/端点删除后失效)。 */
 export function refValid(ref) {
     if (ref.provider === PROVIDER_ID)
@@ -271,7 +322,7 @@ export function findModel(query) {
     return undefined;
 }
 export function isDefaultAgent(value) {
-    return value === "pi" || value === "claude" || value === "codex";
+    return value === "pi" || value === "claude" || value === "codex" || value === "dsh";
 }
 export const u1s1Dir = join(homedir(), ".u1s1");
 export const configFile = join(u1s1Dir, "config.json");

package/dist/custom-endpoint-proxy.d.ts

@@ -0,0 +1,92 @@
+/**
+ * 本机签名代理的本地路由:Claude Code / Codex 选了自定义端点的模型(`ep<32 hex>/<模型 id>`,见
+ * agents/custom-models.ts)时,请求不发往网关,在本机转成 OpenAI Chat Completions 直连该端点,
+ * 回来的结果再转回客户端的协议:
+ *   POST /v1/messages               Anthropic Messages ↔ Chat(流式 / 非流式)
+ *   POST /v1/messages/count_tokens  本机粗估,不请求端点
+ *   POST /v1/responses              OpenAI Responses ↔ Chat(流式 / 非流式)
+ * 转换代码与网关共用(chat-protocol/,正本在 workers/gateway/src/chat-protocol)。
+ *
+ * 安全:发往端点的请求头从零构造,只有内容类型、端点自己的 apiKey(为空就不带 Authorization)和客户端的
+ * 会话 id(x-session-id,端点做会话亲和用);u1s1 的设备凭证、DPoP、客户端证明、本地 token、x-u1s1-* 一律不带。
+ * 不经网关,也就不计费。
+ *
+ * 推理参数见 chatReasoningFields:只发 reasoning_effort(关思考发 "none")。
+ */
+import type { IncomingHttpHeaders, ServerResponse } from "node:http";
+import { type JsonRecord } from "./chat-protocol/json.js";
+import { type ResponsesContext } from "./chat-protocol/responses.js";
+import { type ThinkingLevel } from "./chat-protocol/thinking.js";
+import { type CustomModelLookup } from "./agents/custom-models.js";
+import type { CustomEndpoint, ModelDef } from "./config.js";
+export type CustomProtocol = "messages" | "count_tokens" | "responses";
+/** 本地路由只看这三条;其余路径(/v1/models、/v1/agents/…)照旧走网关。 */
+export declare function customProtocolFor(method: string | undefined, pathname: string): CustomProtocol | null;
+export interface CustomRouteMatch {
+    protocol: CustomProtocol;
+    body: JsonRecord;
+    lookup: Exclude<CustomModelLookup, {
+        kind: "gateway";
+    }>;
+}
+/**
+ * 这个请求要不要本地处理。只有 model 是 `ep…/…` 写法时才是;端点或模型已不在时也本地报错
+ * (网关不认识这种 id,发过去只会多一次网关请求)。body 里连 `"ep` 都没有时不解析 JSON。
+ */
+export declare function matchCustomRoute(method: string | undefined, pathname: string, rawBody: Buffer | undefined, endpoints: readonly CustomEndpoint[]): CustomRouteMatch | null;
+/**
+ * 客户端请求的思考设置 → 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 declare function chatReasoningFields(model: Pick<ModelDef, "reasoning" | "thinking">, level: ThinkingLevel | null): JsonRecord;
+export declare function clientSessionId(headers: IncomingHttpHeaders): string | undefined;
+/** 发往端点的请求头:从零构造,见文件头的安全说明。 */
+export declare function endpointRequestHeaders(endpoint: Pick<CustomEndpoint, "apiKey">, stream: boolean, sessionId?: string): Headers;
+export declare function chatCompletionsUrl(baseUrl: string): string;
+/** 转换后的 Chat 体 → 真正发给端点的体:模型 id 换成端点自己的,流式要 usage,输出上限不超过模型登记的值。 */
+export declare function endpointChatBody(chat: JsonRecord, model: ModelDef): JsonRecord;
+export type FailureKind = "connect" | "timeout" | "http" | "malformed" | "context";
+export interface EndpointFailure {
+    kind: FailureKind;
+    /** 给客户端的 HTTP 状态 */
+    status: number;
+    /** 给用户看的话(已带端点名) */
+    message: string;
+    /** 重试有没有可能好:连不上、请求本身有问题、返回不成形都不重试 */
+    retry: boolean;
+}
+export declare function httpFailure(endpoint: Pick<CustomEndpoint, "name">, status: number, text: string): EndpointFailure;
+export declare function transportFailure(endpoint: Pick<CustomEndpoint, "name">, error: unknown): EndpointFailure;
+export declare function malformedFailure(endpoint: Pick<CustomEndpoint, "name">, what: string): EndpointFailure;
+/** Anthropic 错误形状(Claude Code):`{type: "error", error: {type, message}}` + x-should-retry。 */
+export declare function anthropicFailureResponse(failure: EndpointFailure): Response;
+/**
+ * Responses 错误形状(Codex)。不重试的错误用网关同款的最终形状(HTTP 400 invalid_prompt,Codex 只发一次、
+ * 显示 message);超窗给 context_length_exceeded;能重试的(超时、429、5xx)按网关「上游失败」的口径:
+ * 流式请求回流内 response.failed(Codex 重试 6 次而不是 30 次),非流式回原状态码。
+ */
+export declare function responsesFailureResponse(failure: EndpointFailure, ctx: ResponsesContext): Promise<Response>;
+export type FetchLike = (input: string, init: RequestInit) => Promise<Response>;
+/**
+ * 端点的 SSE 原文,读到一半出错(断线、超时)时补一帧 Chat 形状的 error,让下游转换器按「流中途失败」
+ * 收尾(Claude Code 收到 error 事件,Codex 收到 response.failed),而不是静默截断。
+ */
+export declare function guardedEventStream(body: ReadableStream<Uint8Array>, endpoint: Pick<CustomEndpoint, "name">): ReadableStream<Uint8Array>;
+/** 一条完整的 Anthropic message → 等价的 SSE 事件序列(端点不支持流式时用)。 */
+export declare function anthropicMessageAsSse(message: JsonRecord): string;
+/** chat.completion → 等价的单个 chat.completion.chunk(message 换成 delta,工具调用补 index)。 */
+export declare function completionAsChunk(payload: JsonRecord): JsonRecord;
+/** 处理一个本地路由的请求,得到给客户端的 Web Response。 */
+export declare function customRouteResponse(match: CustomRouteMatch, input: {
+    headers: IncomingHttpHeaders;
+    signal: AbortSignal;
+    fetchImpl?: FetchLike;
+}): Promise<Response>;
+/** Web Response → 本机 http 响应(流式逐块写)。 */
+export declare function writeWebResponse(res: ServerResponse, response: Response): Promise<void>;