@lwmxiaobei/xbcode 1.0.0

package/dist/config.js

@@ -0,0 +1,516 @@
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { isPlainRecord } from "./utils.js";
+const CONFIG_DIR = path.join(os.homedir(), ".xbcode");
+const SETTINGS_PATH = path.join(CONFIG_DIR, "settings.json");
+const CREDENTIALS_PATH = path.join(CONFIG_DIR, "credentials.json");
+let cachedSettings = null;
+let cachedSettingsWarnings = [];
+export function getSettingsPath() {
+    return SETTINGS_PATH;
+}
+export function getCredentialsPath() {
+    return CREDENTIALS_PATH;
+}
+export function loadSettings() {
+    if (cachedSettings)
+        return cachedSettings;
+    const defaultSettings = { providers: {}, mcp: { servers: [] } };
+    try {
+        if (!fs.existsSync(SETTINGS_PATH)) {
+            cachedSettingsWarnings = [];
+            cachedSettings = defaultSettings;
+            return defaultSettings;
+        }
+        const raw = fs.readFileSync(SETTINGS_PATH, "utf8");
+        const parsed = JSON.parse(raw);
+        const warnings = [];
+        cachedSettings = normalizeSettings(parsed, warnings);
+        cachedSettingsWarnings = warnings;
+        return cachedSettings;
+    }
+    catch (error) {
+        cachedSettingsWarnings = [`[config] Failed to load settings: ${error instanceof Error ? error.message : String(error)}`];
+        cachedSettings = defaultSettings;
+        return defaultSettings;
+    }
+}
+/**
+ * Read and normalize a settings file from an explicit path.
+ *
+ * Why this exists:
+ * - Most runtime code uses the global settings path, but targeted update helpers
+ *   and tests need the same normalization behavior for arbitrary files.
+ * - Keeping the file-path variant local to this module avoids exposing another
+ *   caching surface while still reusing the exact same parser rules.
+ */
+function loadSettingsFromFile(filePath) {
+    const defaultSettings = { providers: {}, mcp: { servers: [] } };
+    try {
+        if (!fs.existsSync(filePath)) {
+            return defaultSettings;
+        }
+        const raw = fs.readFileSync(filePath, "utf8");
+        return normalizeSettings(JSON.parse(raw), []);
+    }
+    catch {
+        return defaultSettings;
+    }
+}
+export function reloadSettings() {
+    cachedSettings = null;
+    cachedSettingsWarnings = [];
+    return loadSettings();
+}
+export function getSettingsWarnings() {
+    return [...cachedSettingsWarnings];
+}
+export function getProviderNames() {
+    const settings = loadSettings();
+    return Object.keys(settings.providers);
+}
+export function normalizeModelEntry(entry) {
+    if (typeof entry === "string")
+        return { id: entry };
+    return entry;
+}
+export function getProviderModels(providerName) {
+    const settings = loadSettings();
+    return (settings.providers[providerName]?.models ?? []).map((m) => normalizeModelEntry(m).id);
+}
+export function loadCredentialsFile(filePath = CREDENTIALS_PATH) {
+    const empty = { providers: {} };
+    try {
+        if (!fs.existsSync(filePath)) {
+            return empty;
+        }
+        const raw = JSON.parse(fs.readFileSync(filePath, "utf8"));
+        return normalizeCredentialsFile(raw);
+    }
+    catch {
+        return empty;
+    }
+}
+export async function writeCredentialsFile(filePath, credentials) {
+    await fs.promises.mkdir(path.dirname(filePath), { recursive: true });
+    await fs.promises.writeFile(filePath, `${JSON.stringify(normalizeCredentialsFile(credentials), null, 2)}\n`, "utf8");
+}
+/**
+ * Persist normalized settings back to disk.
+ *
+ * Why this exists:
+ * - Runtime flows such as OAuth model discovery need to update the user's
+ *   provider configuration after the process has already started.
+ * - Writing normalized settings keeps the stored file aligned with the same
+ *   schema validation rules used during reads, which avoids persisting partial
+ *   or malformed provider state.
+ * - Resetting the cache after the write ensures later reads in the same process
+ *   see the new configuration immediately.
+ */
+export async function writeSettingsFile(filePath, settings) {
+    const normalized = normalizeSettings(settings, []);
+    await fs.promises.mkdir(path.dirname(filePath), { recursive: true });
+    await fs.promises.writeFile(filePath, `${JSON.stringify(normalized, null, 2)}\n`, "utf8");
+    cachedSettings = null;
+    cachedSettingsWarnings = [];
+}
+/**
+ * Update the model list for a single provider while preserving the rest of the
+ * settings file as-is.
+ *
+ * Why this exists:
+ * - OAuth login can discover the exact API-visible model IDs for the active
+ *   provider and should write only that slice of configuration.
+ * - Reusing a focused helper keeps the login flow small and avoids duplicating
+ *   settings-file merge logic in UI code.
+ * - The helper normalizes incoming model IDs so callers can pass any raw API
+ *   list without worrying about duplicate whitespace or empty entries.
+ */
+export async function updateProviderModels(filePath, providerName, modelIds) {
+    const settings = loadSettingsFromFile(filePath);
+    const provider = settings.providers[providerName];
+    if (!provider) {
+        return;
+    }
+    const normalizedModels = modelIds
+        .map((modelId) => modelId.trim())
+        .filter((modelId, index, values) => Boolean(modelId) && values.indexOf(modelId) === index);
+    await writeSettingsFile(filePath, {
+        ...settings,
+        providers: {
+            ...settings.providers,
+            [providerName]: {
+                ...provider,
+                models: normalizedModels,
+            },
+        },
+    });
+}
+export async function clearProviderCredentials(filePath, providerName) {
+    const current = loadCredentialsFile(filePath);
+    if (!(providerName in current.providers)) {
+        return;
+    }
+    const nextProviders = { ...current.providers };
+    delete nextProviders[providerName];
+    await writeCredentialsFile(filePath, { providers: nextProviders });
+}
+function resolveApiMode(baseURL, explicit) {
+    const mode = (explicit ?? "").trim().toLowerCase();
+    if (["chat", "chat-completions", "chat_completions"].includes(mode)) {
+        return "chat-completions";
+    }
+    if (mode === "responses") {
+        return "responses";
+    }
+    const lowerBaseURL = baseURL.toLowerCase();
+    // Auto-detect providers that only support Chat Completions API
+    if (lowerBaseURL.includes("deepseek.com") || lowerBaseURL.includes("dashscope.aliyuncs.com")) {
+        return "chat-completions";
+    }
+    return "responses";
+}
+export function resolveConfig(providerName, modelName) {
+    const settings = loadSettings();
+    // Determine which provider to use: explicit arg > defaultProvider > first available key
+    const providerKeys = Object.keys(settings.providers);
+    const targetProvider = providerName || settings.defaultProvider || providerKeys[0] || "";
+    const provider = settings.providers[targetProvider];
+    const availableModels = (provider?.models ?? []).map((m) => normalizeModelEntry(m).id);
+    /**
+     * Resolve the active model from the strongest available source so startup can
+     * skip the interactive picker when the user has already chosen a stable
+     * default model.
+     *
+     * Why this order matters:
+     * - Explicit runtime switches must win for the current session.
+     * - `MODEL_ID` remains the strongest shell-level override.
+     * - `defaultModel` gives `settings.json` a persistent default model.
+     */
+    const model = modelName ?? process.env.MODEL_ID ?? settings.defaultModel ?? "";
+    const apiKey = provider?.apiKey ?? "";
+    const baseURL = provider?.baseURL ?? "https://api.openai.com/v1";
+    const apiMode = resolveApiMode(baseURL, provider?.apiMode);
+    const showThinking = settings.showThinking ?? false;
+    return {
+        model,
+        apiKey,
+        baseURL,
+        apiMode,
+        showThinking,
+        providerName: targetProvider,
+        availableModels,
+    };
+}
+/**
+ * Evaluate whether a resolved startup config is complete enough to skip the
+ * interactive model picker.
+ *
+ * Why this exists:
+ * - The UI needs a deterministic rule, but tests should not have to depend on
+ *   the real `~/.xbcode/settings.json` on the current machine.
+ * - Splitting the pure decision from filesystem-backed config loading keeps the
+ *   startup path easy to verify without mutating user state.
+ * - The shell-level override must remain a first-class bypass so ad-hoc runs
+ *   can pin a model even before settings metadata catches up.
+ */
+export function shouldPromptForModelSelection(resolved, hasShellModelOverride = false) {
+    if (!resolved.providerName || !resolved.model) {
+        return true;
+    }
+    if (hasShellModelOverride) {
+        return false;
+    }
+    return !resolved.availableModels.includes(resolved.model);
+}
+/**
+ * Decide whether startup must ask the user to pick a model interactively.
+ *
+ * Why this exists:
+ * - Startup needs one consistent rule that matches the documented precedence:
+ *   explicit arg > `MODEL_ID` > `settings.defaultModel`.
+ * - `MODEL_ID` is intentionally a shell-level override, so it must be allowed to
+ *   bypass the picker even when the local settings file has not listed that
+ *   model yet.
+ * - Persistent config values should still be validated against the configured
+ *   provider model list so broken saved settings continue to fall back to the
+ *   chooser instead of failing later with a surprising runtime state.
+ */
+export function needsModelSelection(providerName, modelName) {
+    const resolved = resolveConfig(providerName, modelName);
+    return shouldPromptForModelSelection(resolved, !modelName && Boolean(process.env.MODEL_ID));
+}
+function normalizeAuthConfig(value, warningPrefix, warnings) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (!isPlainRecord(value)) {
+        warnings.push(`${warningPrefix} must be an object.`);
+        return undefined;
+    }
+    if (value.type === "oauth") {
+        return { type: "oauth" };
+    }
+    warnings.push(`${warningPrefix}.type must be "oauth".`);
+    return undefined;
+}
+function normalizeModelProfile(value, providerName, warnings) {
+    if (!isPlainRecord(value)) {
+        warnings.push(`[config] provider "${providerName}" must be an object.`);
+        return null;
+    }
+    const models = Array.isArray(value.models) ? value.models : [];
+    if (!Array.isArray(value.models)) {
+        warnings.push(`[config] provider "${providerName}".models must be an array.`);
+    }
+    const normalizedModels = [];
+    for (const entry of models) {
+        if (typeof entry === "string") {
+            normalizedModels.push(entry);
+            continue;
+        }
+        if (isPlainRecord(entry) && typeof entry.id === "string" && entry.id.trim()) {
+            normalizedModels.push({
+                id: entry.id.trim(),
+                name: typeof entry.name === "string" ? entry.name : undefined,
+                description: typeof entry.description === "string" ? entry.description : undefined,
+            });
+            continue;
+        }
+        warnings.push(`[config] provider "${providerName}" has an invalid model entry.`);
+    }
+    return {
+        models: normalizedModels,
+        apiKey: typeof value.apiKey === "string" ? value.apiKey : undefined,
+        baseURL: typeof value.baseURL === "string" ? value.baseURL : undefined,
+        apiMode: value.apiMode === "responses" || value.apiMode === "chat-completions"
+            ? value.apiMode
+            : undefined,
+        auth: normalizeAuthConfig(value.auth, `[config] provider "${providerName}".auth`, warnings),
+    };
+}
+function normalizeStoredOAuthCredentials(value) {
+    if (!isPlainRecord(value) || value.type !== "oauth") {
+        return null;
+    }
+    return {
+        type: "oauth",
+        access_token: typeof value.access_token === "string" ? value.access_token : undefined,
+        refresh_token: typeof value.refresh_token === "string" ? value.refresh_token : undefined,
+        id_token: typeof value.id_token === "string" ? value.id_token : undefined,
+        expires_at: typeof value.expires_at === "string" ? value.expires_at : undefined,
+        client_id: typeof value.client_id === "string" ? value.client_id : undefined,
+        email: typeof value.email === "string" ? value.email : undefined,
+        chatgpt_account_id: typeof value.chatgpt_account_id === "string" ? value.chatgpt_account_id : undefined,
+    };
+}
+export function normalizeCredentialsFile(raw) {
+    if (!isPlainRecord(raw) || !isPlainRecord(raw.providers)) {
+        return { providers: {} };
+    }
+    const providers = Object.entries(raw.providers)
+        .map(([providerName, value]) => [providerName, normalizeStoredOAuthCredentials(value)])
+        .filter((entry) => entry[1] !== null);
+    return { providers: Object.fromEntries(providers) };
+}
+function isCredentialExpired(value, now = new Date()) {
+    if (!value) {
+        return false;
+    }
+    const expiresAt = Date.parse(value);
+    if (Number.isNaN(expiresAt)) {
+        return false;
+    }
+    return expiresAt - now.getTime() <= 60_000;
+}
+export function resolveProviderAuthState(settings, providerName, credentials, now = new Date()) {
+    const provider = settings.providers[providerName];
+    const apiKey = provider?.apiKey ?? "";
+    const oauth = credentials.providers[providerName];
+    if (provider?.auth?.type === "oauth" && oauth?.type === "oauth") {
+        const accessToken = oauth.access_token?.trim() ?? "";
+        if (accessToken && !isCredentialExpired(oauth.expires_at, now)) {
+            return {
+                authMode: "oauth",
+                bearerToken: accessToken,
+                apiKey,
+                oauth,
+            };
+        }
+    }
+    if (apiKey.trim()) {
+        return {
+            authMode: "apiKey",
+            bearerToken: apiKey,
+            apiKey,
+            oauth,
+        };
+    }
+    return {
+        authMode: "none",
+        bearerToken: "",
+        apiKey,
+        oauth,
+    };
+}
+export async function resolveRuntimeAuth({ settings, providerName, credentials = loadCredentialsFile(), refreshOAuthToken, onCredentialsUpdated, now = new Date(), }) {
+    const provider = settings.providers[providerName];
+    const oauth = credentials.providers[providerName];
+    const initialState = resolveProviderAuthState(settings, providerName, credentials, now);
+    if (provider?.auth?.type !== "oauth" || oauth?.type !== "oauth" || !refreshOAuthToken) {
+        return { state: initialState, credentials, didRefresh: false };
+    }
+    const accessToken = oauth.access_token?.trim() ?? "";
+    if (accessToken && !isCredentialExpired(oauth.expires_at, now)) {
+        return { state: initialState, credentials, didRefresh: false };
+    }
+    const refreshToken = oauth.refresh_token?.trim() ?? "";
+    if (!refreshToken) {
+        return { state: initialState, credentials, didRefresh: false };
+    }
+    try {
+        const refreshed = await refreshOAuthToken(oauth);
+        const nextCredentials = {
+            providers: {
+                ...credentials.providers,
+                [providerName]: refreshed,
+            },
+        };
+        if (onCredentialsUpdated) {
+            await onCredentialsUpdated(nextCredentials);
+        }
+        return {
+            state: resolveProviderAuthState(settings, providerName, nextCredentials, now),
+            credentials: nextCredentials,
+            didRefresh: true,
+        };
+    }
+    catch {
+        return { state: initialState, credentials, didRefresh: false };
+    }
+}
+function normalizeStringRecord(value, warningPrefix, warnings) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (!isPlainRecord(value)) {
+        warnings.push(`${warningPrefix} must be an object.`);
+        return undefined;
+    }
+    const entries = Object.entries(value)
+        .filter(([, entryValue]) => entryValue !== undefined && entryValue !== null)
+        .map(([key, entryValue]) => [key, String(entryValue)]);
+    return Object.fromEntries(entries);
+}
+function normalizeStringArray(value, warningPrefix, warnings) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (!Array.isArray(value)) {
+        warnings.push(`${warningPrefix} must be an array.`);
+        return undefined;
+    }
+    return value.map((entry) => String(entry));
+}
+function normalizeMcpServer(value, index, warnings, seenNames) {
+    if (!isPlainRecord(value)) {
+        warnings.push(`[mcp] server[${index}] must be an object.`);
+        return null;
+    }
+    const name = String(value.name ?? "").trim();
+    if (!name) {
+        warnings.push(`[mcp] server[${index}] is missing a non-empty name.`);
+        return null;
+    }
+    if (seenNames.has(name)) {
+        warnings.push(`[mcp] duplicate server name "${name}" was ignored.`);
+        return null;
+    }
+    const transport = value.transport === "stdio" || value.transport === "streamable-http"
+        ? value.transport
+        : null;
+    if (!transport) {
+        warnings.push(`[mcp] server "${name}" has unsupported transport "${String(value.transport ?? "")}".`);
+        return null;
+    }
+    const timeoutValue = value.timeoutMs;
+    const timeoutMs = typeof timeoutValue === "number" && Number.isFinite(timeoutValue) && timeoutValue > 0
+        ? timeoutValue
+        : 30_000;
+    if (timeoutValue !== undefined && timeoutMs !== timeoutValue) {
+        warnings.push(`[mcp] server "${name}" has invalid timeoutMs; defaulting to 30000.`);
+    }
+    const enabled = value.enabled === undefined ? true : Boolean(value.enabled);
+    if (transport === "stdio") {
+        const command = String(value.command ?? "").trim();
+        if (!command) {
+            warnings.push(`[mcp] stdio server "${name}" is missing command.`);
+            return null;
+        }
+        const cwd = typeof value.cwd === "string" ? value.cwd.trim() : undefined;
+        if (value.cwd !== undefined && typeof value.cwd !== "string") {
+            warnings.push(`[mcp] server "${name}".cwd must be a string.`);
+        }
+        else if (cwd && !fs.existsSync(cwd)) {
+            warnings.push(`[mcp] stdio server "${name}" cwd does not exist: ${cwd}.`);
+        }
+        seenNames.add(name);
+        return {
+            name,
+            enabled,
+            transport,
+            command,
+            args: normalizeStringArray(value.args, `[mcp] server "${name}".args`, warnings) ?? [],
+            env: normalizeStringRecord(value.env, `[mcp] server "${name}".env`, warnings),
+            cwd: cwd || undefined,
+            timeoutMs,
+        };
+    }
+    const url = String(value.url ?? "").trim();
+    if (!url) {
+        warnings.push(`[mcp] streamable-http server "${name}" is missing url.`);
+        return null;
+    }
+    seenNames.add(name);
+    return {
+        name,
+        enabled,
+        transport,
+        url,
+        headers: normalizeStringRecord(value.headers, `[mcp] server "${name}".headers`, warnings),
+        timeoutMs,
+    };
+}
+export function normalizeSettings(raw, warnings) {
+    const root = isPlainRecord(raw) ? raw : {};
+    if (root.providers !== undefined && !isPlainRecord(root.providers)) {
+        warnings.push("[config] providers must be an object.");
+    }
+    const providers = isPlainRecord(root.providers)
+        ? Object.fromEntries(Object.entries(root.providers)
+            .map(([providerName, value]) => [providerName, normalizeModelProfile(value, providerName, warnings)])
+            .filter((entry) => entry[1] !== null))
+        : {};
+    const mcpRoot = isPlainRecord(root.mcp) ? root.mcp : undefined;
+    if (root.mcp !== undefined && !mcpRoot) {
+        warnings.push("[mcp] mcp must be an object.");
+    }
+    const rawServers = mcpRoot?.servers;
+    if (rawServers !== undefined && !Array.isArray(rawServers)) {
+        warnings.push("[mcp] mcp.servers must be an array.");
+    }
+    const seenNames = new Set();
+    const servers = Array.isArray(rawServers)
+        ? rawServers
+            .map((value, index) => normalizeMcpServer(value, index, warnings, seenNames))
+            .filter((value) => value !== null)
+        : [];
+    return {
+        providers,
+        defaultProvider: typeof root.defaultProvider === "string" ? root.defaultProvider : undefined,
+        defaultModel: typeof root.defaultModel === "string" ? root.defaultModel : undefined,
+        showThinking: typeof root.showThinking === "boolean" ? root.showThinking : undefined,
+        mcp: { servers },
+    };
+}

package/dist/error-log.js

@@ -0,0 +1,80 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+const LOG_DIR = path.join(os.homedir(), ".xbcode");
+const LOG_PATH = path.join(LOG_DIR, "error.log");
+function ensureLogDir() {
+    try {
+        fs.mkdirSync(LOG_DIR, { recursive: true });
+    }
+    catch {
+        // Best-effort; logging must never crash the agent.
+    }
+}
+function pickHeader(headers, key) {
+    if (!headers)
+        return undefined;
+    // OpenAI SDK exposes headers as a plain object on APIError.
+    const record = headers;
+    const value = record[key] ?? record[key.toLowerCase()];
+    return typeof value === "string" ? value : undefined;
+}
+function describeError(error) {
+    if (!error || typeof error !== "object") {
+        return { message: String(error) };
+    }
+    const err = error;
+    return {
+        name: err.name,
+        message: err.message,
+        status: err.status,
+        requestId: pickHeader(err.headers, "x-request-id"),
+        body: err.error,
+    };
+}
+/**
+ * Append a structured JSON record to ~/.xbcode/error.log.
+ *
+ * Why a file (not stderr): when the user sees a 400 in the TUI we want a
+ * forensic trail to grep through after the fact, including which agent (main /
+ * subagent:<name> / teammate:<name>) made the failing request.
+ */
+export function logApiError(caller, error, request) {
+    ensureLogDir();
+    const record = {
+        ts: new Date().toISOString(),
+        caller,
+        request,
+        error: describeError(error),
+    };
+    try {
+        fs.appendFileSync(LOG_PATH, `${JSON.stringify(record)}\n`, "utf8");
+    }
+    catch {
+        // Best-effort.
+    }
+}
+/**
+ * Wrap an API error so the message carries the caller tag. Preserves the
+ * original error via `cause` and copies status/headers so downstream retry /
+ * abort checks (e.g. isTransientNetworkError) still work.
+ */
+export function wrapApiError(caller, error) {
+    if (!(error instanceof Error)) {
+        return new Error(`[${caller}] ${String(error)}`);
+    }
+    const wrapped = new Error(`[${caller}] ${error.message}`, { cause: error });
+    wrapped.name = error.name;
+    const src = error;
+    const dst = wrapped;
+    if (src.status !== undefined)
+        dst.status = src.status;
+    if (src.headers !== undefined)
+        dst.headers = src.headers;
+    if (src.error !== undefined)
+        dst.error = src.error;
+    return wrapped;
+}
+export function getErrorLogPath() {
+    return LOG_PATH;
+}

package/dist/http.js

@@ -0,0 +1,89 @@
+import { Agent, EnvHttpProxyAgent } from "undici";
+let streamingDispatcher;
+let proxyOnlyDispatcher;
+export function hasProxyEnvironment() {
+    return [
+        process.env.HTTPS_PROXY,
+        process.env.https_proxy,
+        process.env.HTTP_PROXY,
+        process.env.http_proxy,
+        process.env.ALL_PROXY,
+        process.env.all_proxy,
+    ].some((value) => Boolean(value?.trim()));
+}
+/**
+ * 一次性请求专用 dispatcher：
+ * - 没有代理时返回 undefined，由 Node 默认 fetch 接管（保留原 OAuth 行为）。
+ * - 有代理时用 EnvHttpProxyAgent，让请求遵循 shell 代理变量。
+ */
+export function getProxyOnlyDispatcher() {
+    if (!hasProxyEnvironment())
+        return undefined;
+    if (!proxyOnlyDispatcher)
+        proxyOnlyDispatcher = new EnvHttpProxyAgent();
+    return proxyOnlyDispatcher;
+}
+/**
+ * Streaming 请求专用 dispatcher：
+ * - 没有代理时使用一条短 keep-alive 的 Agent，让闲置连接尽早从池里淘汰，
+ *   避免在工具执行间隔后下一轮 stream 拿到一条已被远端 RST 的连接，
+ *   然后立刻收到 undici 的 `TypeError: terminated`。
+ * - 有代理时延用 EnvHttpProxyAgent，它自己负责池子生命周期。
+ */
+export function getStreamingDispatcher() {
+    if (streamingDispatcher)
+        return streamingDispatcher;
+    streamingDispatcher = hasProxyEnvironment()
+        ? new EnvHttpProxyAgent()
+        : new Agent({
+            keepAliveTimeout: 1_000,
+            keepAliveMaxTimeout: 5_000,
+            connect: { timeout: 30_000 },
+        });
+    return streamingDispatcher;
+}
+export function createSharedFetch() {
+    return async (input, init) => {
+        const requestInit = { ...init, dispatcher: getStreamingDispatcher() };
+        return await fetch(input, requestInit);
+    };
+}
+const TRANSIENT_ERROR_CODES = new Set([
+    "UND_ERR_SOCKET",
+    "UND_ERR_CLOSED",
+    "UND_ERR_BODY_TIMEOUT",
+    "UND_ERR_HEADERS_TIMEOUT",
+    "UND_ERR_CONNECT_TIMEOUT",
+    "ECONNRESET",
+    "ECONNREFUSED",
+    "ETIMEDOUT",
+    "EPIPE",
+    "EAI_AGAIN",
+]);
+/**
+ * 判断错误是否值得重试一次 stream 请求。
+ *
+ * undici 在底层 socket 被远端关闭时抛出 `TypeError: terminated`，
+ * 它的 message 可能是字面 "terminated"，也可能挂在 `cause` 上的 SocketError。
+ * 这里把已知的传输层错误码也一起识别，避免误把模型/4xx 类错误当成可重试。
+ */
+export function isTransientNetworkError(error) {
+    if (!error || typeof error !== "object")
+        return false;
+    const err = error;
+    if (err.message === "terminated")
+        return true;
+    const code = typeof err.code === "string" ? err.code : undefined;
+    if (code && TRANSIENT_ERROR_CODES.has(code))
+        return true;
+    const cause = err.cause;
+    if (cause) {
+        if (cause.message === "terminated")
+            return true;
+        if (typeof cause.code === "string" && TRANSIENT_ERROR_CODES.has(cause.code))
+            return true;
+        if (cause.name === "SocketError")
+            return true;
+    }
+    return false;
+}