oh-my-agent-web 0.2.0 → 0.4.0

package/dist/server/markers/actions.js

@@ -0,0 +1,262 @@
+/**
+ * 「想一想」（换一批建议）用的隐藏指令哨兵。
+ *
+ * 它不是一个 action 标记（命名空间 `agent-web` 不在 KNOWN_TOOLS 里），
+ * 作用只有一个：让历史回放能认出「这条用户消息是我们自己发的重生成请求」并把它丢掉，
+ * 否则用户会在对话里看到一条莫名其妙的「请再给三条建议」。
+ */
+export const REFRESH_ACTIONS_SENTINEL = "[[agent-web:refresh-actions]]";
+/**
+ * 「想一想」要发给模型的指令（纯函数，单测覆盖）。
+ *
+ * 两个刻意的写法：
+ *   - 示例给**空标记** `[[action:suggest:]]`（解析器会忽略空标签）—— 模型即使原样抄回来也不会冒假建议；
+ *   - 明确「4 到 5 条」：ADR-0039 定的条数（3 条里常有一条是废话）。
+ */
+export function buildRefreshActionsPrompt(labels, count) {
+    const avoid = labels.length > 0 ? `（不要和这些重复：${labels.join("、")}）` : "";
+    // 手机上一行放不下 4~5 个按钮：客户端可以指定「就要 3 条」。
+    const wanted = typeof count === "number" && Number.isInteger(count) && count >= 1 && count <= 5 ? count : null;
+    const amount = wanted === null ? "4 到 5 条" : `${wanted} 条`;
+    // **一行**：这条指令在引擎侧会作为一条真实用户消息落盘（DSH web / pi CLI 里也看得见），
+    // 所以压到最短，同时语法自包含（dsh / codex 没有系统提示教它这个格式）。
+    return `${REFRESH_ACTIONS_SENTINEL} 再给 ${amount}不同的下一步建议${avoid}，每行一条 [[action:suggest:]]（把按钮文字填在 suggest: 后面），只输出标记，不要正文。`;
+}
+/** 这条用户消息是不是「想一想」的隐藏请求 */
+export function isRefreshActionsPrompt(text) {
+    return text.trimStart().startsWith(REFRESH_ACTIONS_SENTINEL);
+}
+export const MAX_ACTIONS = 5; // 每轮建议 4~5 条：超过只留最新的那批
+export const MAX_LABEL_CHARS = 80;
+export const MAX_PROMPT_CHARS = 2000;
+/** 已认识的标记命名空间（只剥离这些，避免误删正文里的普通双括号） */
+const KNOWN_TOOLS = ["action", "suggest"];
+/** 匹配 `[[tool:op:body]]`（body 里不允许再出现 `[[`，避免嵌套误伤） */
+// op 段可选：[[suggest:下一步]] 与 [[action:suggest:下一步]] 都要认
+const TOKEN_RE = /\[\[\s*([a-z]+)\s*:\s*(?:([a-z]+)\s*:\s*)?([^[\]]*?)\s*\]\]/gi;
+/** 流式期间：末尾那个还没闭合的半截标记（例如 `[[action:su`）也不该显示出来 */
+const TRAILING_INCOMPLETE_RE = /[ \t]*\[\[\s*(?:action|suggest)(?:\s*:[^\]]*)?$/i;
+function splitBody(body) {
+    const args = [];
+    const kwargs = {};
+    let rest = body;
+    // 先把 kwargs 抽出来（`prompt=xxx` 可能含逗号 → 按 `,key=` 切）
+    const segments = rest.split(",");
+    for (const segment of segments) {
+        const trimmed = segment.trim();
+        if (trimmed === "")
+            continue;
+        const index = trimmed.indexOf("=");
+        const key = index > 0 ? trimmed.slice(0, index).trim() : "";
+        if (key !== "" && /^[A-Za-z][A-Za-z0-9_-]*$/.test(key))
+            kwargs[key.toLowerCase()] = trimmed.slice(index + 1).trim();
+        else
+            args.push(trimmed);
+    }
+    rest = "";
+    void rest;
+    return { args, kwargs };
+}
+/** 纯函数：解析文本里的建议操作标记（畸形标记直接忽略，不当成错误） */
+export function parseActionMarkers(text) {
+    if (!text.includes("[["))
+        return [];
+    const tokens = [];
+    TOKEN_RE.lastIndex = 0;
+    let match;
+    while ((match = TOKEN_RE.exec(text)) !== null) {
+        const [, tool, op, body] = match;
+        const toolName = tool.toLowerCase();
+        // 没写 op 的（[[suggest:文字]] / [[action:文字]]）按 suggest 处理
+        const opName = (op ?? "suggest").toLowerCase();
+        if (!KNOWN_TOOLS.includes(toolName))
+            continue;
+        if (body.includes("[["))
+            continue; // 嵌套/畸形：不认
+        if (opName === "clear") {
+            if (body.trim() === "all" || body.trim() === "")
+                tokens.push({ kind: "clear" });
+            continue;
+        }
+        if (!["suggest", "add", "next", "reply", "choice", "option"].includes(opName))
+            continue;
+        const { args, kwargs } = splitBody(body);
+        const argText = args.join(",").trim();
+        const label = (kwargs.label ?? argText).trim();
+        const prompt = (kwargs.prompt ?? argText).trim();
+        if (label === "" && prompt === "")
+            continue;
+        tokens.push({
+            kind: "suggest",
+            label: (label || prompt).slice(0, MAX_LABEL_CHARS),
+            prompt: (prompt || label).slice(0, MAX_PROMPT_CHARS),
+        });
+    }
+    return tokens;
+}
+/**
+ * 纯函数：从展示文本里剥离标记。
+ * `stripTrailingIncomplete` 用于流式期间（把还没闭合的半截标记也去掉）。
+ */
+export function stripMarkers(text, options = {}) {
+    if (!text.includes("[["))
+        return text;
+    let out = text.replace(TOKEN_RE, (raw, tool, _op, body) => {
+        if (!KNOWN_TOOLS.includes(String(tool).toLowerCase()))
+            return raw;
+        if (body.includes("[["))
+            return raw;
+        return "";
+    });
+    if (options.stripTrailingIncomplete)
+        out = out.replace(TRAILING_INCOMPLETE_RE, "");
+    if (out === text)
+        return text;
+    // 剥离后可能留下空行（标记通常独占一行）
+    return out
+        .replace(/^[ \t]+\n/gm, "\n")
+        .replace(/\n{3,}/g, "\n\n")
+        .trimEnd();
+}
+/** 纯函数：把一段助手文本归约成「干净文本 + 建议列表」 */
+export function reduceActionMarkers(text, current, nextId) {
+    const tokens = parseActionMarkers(text);
+    if (tokens.length === 0)
+        return { text, actions: current };
+    let actions = [...current];
+    for (const token of tokens) {
+        if (token.kind === "clear") {
+            actions = [];
+            continue;
+        }
+        const exists = actions.some((item) => item.label === token.label && item.prompt === token.prompt);
+        if (exists)
+            continue;
+        actions.push({ id: nextId(), label: token.label, prompt: token.prompt });
+        if (actions.length > MAX_ACTIONS)
+            actions = actions.slice(actions.length - MAX_ACTIONS);
+    }
+    return { text: stripMarkers(text), actions };
+}
+/**
+ * 流式过滤器：把「可能是标记开头」的内容先扣住。
+ *
+ * 为什么需要它：模型是逐字吐出来的，`[[action:suggest:继续]]` 会被拆成好几个 chunk。
+ * 如果只在回合结束时剥离，用户会在流式过程中看到原始语法（截图里就这么被撞见过）。
+ * 而「边流边剥」不能靠事后删除（客户端只支持追加重建），只能**先把可能是标记的尾巴扣住**：
+ *   - 遇到 `[[` 就暂停输出，等它闭合；
+ *   - 闭合后：是认识的标记 → 直接丢弃；不是认识的（如 `[[todo:...]]`）→ 当普通文本补上；
+ *   - 长时间不闭合（横文里的双括号）→ 超过上限就当下普通文本吐出，不能把内容卡死。
+ */
+export const MAX_PENDING_CHARS = 500;
+export function createMarkerStreamFilter() {
+    let pending = "";
+    const drain = (final) => {
+        let out = "";
+        for (;;) {
+            const start = pending.indexOf("[[");
+            if (start < 0) {
+                // 没有完整的 "[["：但结尾可能孤立着一个 "["（下一个 chunk 才补上第二个）→ 扣住它
+                if (!final && pending.endsWith("[")) {
+                    out += pending.slice(0, -1);
+                    pending = "[";
+                    return out;
+                }
+                out += pending;
+                pending = "";
+                return out;
+            }
+            out += pending.slice(0, start);
+            const rest = pending.slice(start);
+            const end = rest.indexOf("]]");
+            if (end < 0) {
+                // 还没闭合：扣住等内容（除非已经不可能是个标记）
+                if (final || rest.length > MAX_PENDING_CHARS) {
+                    out += rest;
+                    pending = "";
+                    return out;
+                }
+                pending = rest;
+                return out;
+            }
+            const expression = rest.slice(0, end + 2);
+            pending = rest.slice(end + 2);
+            // 认识的名字空间：丢弃；不认识的：当普通文本吐出（与 stripMarkers 一个口径）
+            const known = /^\[\[\s*(?:action|suggest)\s*:/i.test(expression);
+            if (!known)
+                out += expression;
+        }
+    };
+    return {
+        push(chunk) {
+            if (chunk === "")
+                return "";
+            pending += chunk;
+            return drain(false);
+        },
+        flush() {
+            return drain(true);
+        },
+    };
+}
+/**
+ * 把标记从一条消息里落实：剥离正文里的标记，并把建议项追加到当前列表。
+ * 只改文本块（工具卡与错误块不动）。
+ */
+export function applyMarkersToMessage(message, current, nextId) {
+    const rawText = message.blocks
+        .filter((block) => block.kind === "text")
+        .map((block) => block.text)
+        .join("");
+    if (!rawText.includes("[["))
+        return { blocks: message.blocks, actions: current };
+    const { text: cleaned, actions } = reduceActionMarkers(rawText, current, nextId);
+    // 把全部文本块合并成一块干净文本，并接在第一个文本块的位置上（保序）
+    const firstTextIndex = message.blocks.findIndex((block) => block.kind === "text");
+    const nonTextBefore = message.blocks.slice(0, firstTextIndex).filter((block) => block.kind !== "text");
+    const nonTextAfter = message.blocks.slice(firstTextIndex).filter((block) => block.kind !== "text");
+    const blocks = [
+        ...nonTextBefore,
+        ...(cleaned.trim() === "" ? [] : [{ kind: "text", text: cleaned }]),
+        ...nonTextAfter,
+    ];
+    return { blocks, actions };
+}
+/**
+ * 历史回放清洗（pi / dsh 共用）：
+ *   1. 丢掉「想一想」的隐藏请求（用户不该看到那条内部消息）；
+ *   2. 剥掉正文里残留的 action 标记（历史记录里存的是原文）；
+ *   3. 剥完变空的消息（例如模型只回了三条标记）直接丢掉，不留空气泡。
+ */
+export function sanitizeHistoricalActions(messages) {
+    const out = [];
+    for (const message of messages) {
+        if (message.role === "user") {
+            const text = message.blocks
+                .filter((block) => block.kind === "text")
+                .map((block) => block.text)
+                .join("");
+            if (isRefreshActionsPrompt(text))
+                continue;
+            // 防御：哨兵被引擎包了一层（或模型回显到助手消息里）时也要剥掉
+            const blocks = message.blocks.map((block) => block.kind === "text" && block.text.includes(REFRESH_ACTIONS_SENTINEL)
+                ? { ...block, text: block.text.split(REFRESH_ACTIONS_SENTINEL).join("").trim() }
+                : block);
+            const cleaned = blocks.filter((block) => block.kind !== "text" || block.text.trim() !== "");
+            if (cleaned.length === 0)
+                continue;
+            out.push({ ...message, blocks: cleaned });
+            continue;
+        }
+        if (!message.blocks.some((block) => block.kind === "text")) {
+            out.push(message);
+            continue;
+        }
+        const cleaned = message.blocks.map((block) => block.kind === "text" ? { ...block, text: stripMarkers(block.text) } : block);
+        const blocks = cleaned.filter((block) => block.kind !== "text" || block.text.trim() !== "");
+        if (blocks.length === 0)
+            continue;
+        out.push({ ...message, blocks });
+    }
+    return out;
+}

package/dist/server/protocol-parse.js

@@ -0,0 +1,201 @@
+// ---------------------------------------------------------------------------
+export const REQUEST_TYPES = [
+    "set_engine",
+    "refresh_actions",
+    "send_message",
+    "interrupt",
+    "rename_session",
+    "approve",
+    "get_state",
+    "new_chat",
+    "switch_conversation",
+    "set_settings",
+    "set_model",
+    "set_approval_mode",
+    "list_providers",
+    "upsert_provider",
+    "delete_provider",
+    "test_provider",
+    "set_thinking_level",
+    "update_model",
+    "remove_model",
+    "cancel_queued",
+    "set_enabled_models",
+];
+const DECISIONS = ["once", "always", "deny"];
+function isAttachmentRef(value) {
+    if (!isRecord(value))
+        return false;
+    const { id, kind, name, mime, bytes } = value;
+    return (nonEmptyString(id) &&
+        (kind === "image" || kind === "file") &&
+        typeof name === "string" &&
+        typeof mime === "string" &&
+        typeof bytes === "number");
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}
+function nonEmptyString(value) {
+    return typeof value === "string" && value.length > 0;
+}
+/**
+ * 解析并校验一条上行请求。返回 null 表示「不是合法请求」，
+ * 调用方负责回 `protocol.unknown_type` / `protocol.bad_payload`。
+ */
+export function parseClientRequest(raw) {
+    if (!isRecord(raw))
+        return null;
+    const { id, type } = raw;
+    if (!nonEmptyString(id) || !nonEmptyString(type))
+        return null;
+    if (!REQUEST_TYPES.includes(type))
+        return null;
+    if (type === "get_state")
+        return { id, type: "get_state" };
+    if (type === "new_chat") {
+        const workspace = isRecord(raw.payload) && nonEmptyString(raw.payload.workspace) ? raw.payload.workspace : undefined;
+        return workspace ? { id, type: "new_chat", payload: { workspace } } : { id, type: "new_chat" };
+    }
+    if (type === "refresh_actions") {
+        const payload = isRecord(raw.payload) ? raw.payload : undefined;
+        const conversationId = payload && nonEmptyString(payload.conversationId) ? payload.conversationId : undefined;
+        const rawCount = payload?.count;
+        const count = typeof rawCount === "number" && Number.isInteger(rawCount) && rawCount >= 1 && rawCount <= 5
+            ? rawCount
+            : undefined;
+        return {
+            id,
+            type: "refresh_actions",
+            ...(conversationId || count ? { payload: { ...(conversationId ? { conversationId } : {}), ...(count ? { count } : {}) } } : {}),
+        };
+    }
+    // 这两个请求的 provider 在**顶层**（老的形状），也容忍放进 payload 里
+    if (type === "delete_provider" || type === "test_provider") {
+        const source = isRecord(raw.payload) ? raw.payload.provider : undefined;
+        const rawProvider = typeof raw.provider === "string" ? raw.provider : source;
+        const provider = typeof rawProvider === "string" ? rawProvider.trim() : "";
+        if (provider === "")
+            return null;
+        return type === "delete_provider"
+            ? { id, type: "delete_provider", provider }
+            : { id, type: "test_provider", provider };
+    }
+    const payload = raw.payload;
+    if (!isRecord(payload))
+        return null;
+    if (type === "send_message") {
+        // 附件只校验形状（id/kind/name/mime/bytes）：真正的文件校验在服务端读回时做
+        const attachments = Array.isArray(payload.attachments)
+            ? payload.attachments.filter(isAttachmentRef).slice(0, 5)
+            : undefined;
+        if (!nonEmptyString(payload.text) && !attachments?.length)
+            return null;
+        return {
+            id,
+            type: "send_message",
+            payload: {
+                text: String(payload.text ?? ""),
+                ...(payload.mode === "queue" || payload.mode === "steer" ? { mode: payload.mode } : {}),
+                ...(attachments?.length ? { attachments } : {}),
+            },
+        };
+    }
+    if (type === "list_providers")
+        return { id, type: "list_providers" };
+    if (type === "upsert_provider") {
+        // 细节校验在 providers/validate.ts（这里只做形状校验，避免协议层重复实现业务规则）
+        if (!isRecord(payload))
+            return null;
+        const models = Array.isArray(payload.models) ? payload.models : null;
+        if (models === null)
+            return null;
+        return {
+            id,
+            type: "upsert_provider",
+            payload: {
+                provider: String(payload.provider ?? ""),
+                baseUrl: String(payload.baseUrl ?? ""),
+                ...(typeof payload.api === "string" ? { api: payload.api } : {}),
+                ...(typeof payload.apiKey === "string" ? { apiKey: payload.apiKey } : {}),
+                ...(typeof payload.previousProvider === "string" && payload.previousProvider.trim() !== ""
+                    ? { previousProvider: payload.previousProvider.trim() }
+                    : {}),
+                ...(isRecord(payload.headers)
+                    ? {
+                        headers: Object.fromEntries(Object.entries(payload.headers).filter(([, value]) => typeof value === "string")),
+                    }
+                    : {}),
+                models: models.map((item) => isRecord(item)
+                    ? { id: String(item.id ?? ""), ...(typeof item.name === "string" ? { name: item.name } : {}) }
+                    : { id: "" }),
+            },
+        };
+    }
+    if (type === "update_model") {
+        if (!isRecord(payload))
+            return null;
+        const provider = typeof payload.provider === "string" ? payload.provider.trim() : "";
+        const model = isRecord(payload.model) ? payload.model : null;
+        if (provider === "" || model === null)
+            return null;
+        return { id, type: "update_model", payload: { provider, model } };
+    }
+    if (type === "remove_model") {
+        const provider = typeof payload?.provider === "string" ? payload.provider.trim() : "";
+        const modelId = typeof payload?.modelId === "string" ? payload.modelId.trim() : "";
+        return provider === "" || modelId === "" ? null : { id, type: "remove_model", payload: { provider, modelId } };
+    }
+    if (type === "set_enabled_models") {
+        const provider = typeof payload?.provider === "string" ? payload.provider.trim() : "";
+        if (provider === "" || typeof payload?.enabled !== "boolean")
+            return null;
+        const modelId = typeof payload?.modelId === "string" && payload.modelId.trim() !== "" ? payload.modelId.trim() : undefined;
+        return {
+            id,
+            type: "set_enabled_models",
+            payload: { provider, enabled: payload.enabled, ...(modelId ? { modelId } : {}) },
+        };
+    }
+    if (type === "cancel_queued") {
+        const queueId = typeof payload?.queueId === "string" ? payload.queueId.trim() : "";
+        return queueId === "" ? null : { id, type: "cancel_queued", payload: { queueId } };
+    }
+    if (type === "set_thinking_level") {
+        const level = typeof payload?.level === "string" ? payload.level.trim() : "";
+        return level === "" ? null : { id, type: "set_thinking_level", payload: { level } };
+    }
+    if (type === "set_approval_mode") {
+        const mode = payload.mode;
+        return mode === "ask" || mode === "allow" ? { id, type: "set_approval_mode", payload: { mode } } : null;
+    }
+    if (type === "set_engine") {
+        // 引擎名只做形状校验；「是不是注册过的引擎」由目录判断（未知名字要回一条可读错误）
+        return nonEmptyString(payload.engine) ? { id, type: "set_engine", payload: { engine: payload.engine } } : null;
+    }
+    if (type === "set_model") {
+        return nonEmptyString(payload.modelId) ? { id, type: "set_model", payload: { modelId: payload.modelId } } : null;
+    }
+    if (type === "set_settings") {
+        // 结构有意放宽：真正的归一化在服务端 settings 模块（超长/重复/条数都在那里收敛）
+        return { id, type: "set_settings", payload: payload };
+    }
+    if (type === "switch_conversation") {
+        return nonEmptyString(payload.conversationId)
+            ? { id, type: "switch_conversation", payload: { conversationId: payload.conversationId } }
+            : null;
+    }
+    if (type === "rename_session") {
+        const conversationId = typeof payload.conversationId === "string" ? payload.conversationId.trim() : "";
+        const title = typeof payload.title === "string" ? payload.title.replace(/\s+/g, " ").trim().slice(0, 60) : "";
+        return conversationId === "" ? null : { id, type: "rename_session", payload: { conversationId, title } };
+    }
+    if (type === "interrupt") {
+        return nonEmptyString(payload.conversationId)
+            ? { id, type: "interrupt", payload: { conversationId: payload.conversationId } }
+            : null;
+    }
+    return nonEmptyString(payload.requestId) && DECISIONS.includes(payload.decision)
+        ? { id, type: "approve", payload: { requestId: payload.requestId, decision: payload.decision } }
+        : null;
+}

package/dist/server/protocol-settings.js

@@ -0,0 +1 @@
+export {};

package/dist/server/protocol.js

@@ -0,0 +1,6 @@
+/** 三类消息：ClientRequest / ServerReply / ServerEvent。 */
+export const PROTOCOL_VERSION = 1;
+export const SNAPSHOT_MESSAGE_LIMIT = 100;
+export const MAX_FRAME_BYTES = 64 * 1024;
+export const TOOL_EXCERPT_CHARS = 2000; // 工具输出摘录上限
+export { parseClientRequest } from "./protocol-parse.js";

package/dist/server/providers/catalog-store.js

@@ -0,0 +1,85 @@
+/**
+ * pi 的 provider 目录（`~/.pi/agent/models.json`）—— nexita / nexita-anthropic 这类就住在这里。
+ *
+ * 之前我们只「读」它，界面上把这类 provider 标成「只读，改这里会写坏 pi 的目录」。
+ * 但用户说得对：**能改，改的就是 pi 的配置**，只是要按 pi 的格式正确地写。
+ * 参照 pi 文档（docs/models.md）的字段：
+ *
+ *   { "providers": { "<provider>": {
+ *       "api": "anthropic-messages" | "openai-completions" | …,
+ *       "baseUrl": "https://…",
+ *       "apiKey": "sk-…" | "ENV_VAR" | "!command",
+ *       "headers": { … },
+ *       "models": [{ id, name, reasoning, input: ["text","image"], contextWindow, maxTokens, cost }]
+ *   } } }
+ *
+ * 纪律与 models-store.json 相同：原子写 + 0600（里面有明文 key），且**只动目标 provider**。
+ */
+import { chmod, mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+export const MODELS_FILE = "models.json";
+export async function readCatalog(agentDir) {
+    try {
+        const parsed = JSON.parse(await readFile(join(agentDir, MODELS_FILE), "utf8"));
+        return typeof parsed === "object" && parsed !== null ? parsed : {};
+    }
+    catch {
+        // 不存在 / 坏文件都按空表处理（与其它配置一致：可重建）
+        return {};
+    }
+}
+/** 原子写 + 0600：目录文件里有明文 key */
+export async function writeCatalog(agentDir, catalog) {
+    const path = join(agentDir, MODELS_FILE);
+    await mkdir(dirname(path), { recursive: true });
+    const temporary = `${path}.tmp-${process.pid}-${Date.now()}`;
+    await writeFile(temporary, `${JSON.stringify(catalog, null, 2)}\n`, { mode: 0o600 });
+    await rename(temporary, path);
+    await chmod(path, 0o600);
+}
+/** 纯函数：改一个模型（不存在就追加）；返回新 entry，不改入参 */
+export function patchCatalogModel(entry, modelId, patch) {
+    const models = Array.isArray(entry.models) ? entry.models : [];
+    const index = models.findIndex((model) => model.id === modelId);
+    const current = index >= 0 ? models[index] : { id: modelId };
+    const next = patch(current);
+    if (next === null) {
+        if (index < 0)
+            return entry;
+        return { ...entry, models: models.filter((model) => model.id !== modelId) };
+    }
+    const list = [...models];
+    if (index >= 0)
+        list[index] = next;
+    else
+        list.push(next);
+    return { ...entry, models: list };
+}
+/** 界面表单（ModelSpec 形状）→ pi 目录里的模型字段 */
+export function specToCatalog(spec) {
+    return {
+        name: spec.name,
+        reasoning: spec.reasoning,
+        input: spec.imageInput ? ["text", "image"] : ["text"],
+        ...(spec.contextWindow !== null ? { contextWindow: spec.contextWindow } : {}),
+        ...(spec.maxTokens !== null ? { maxTokens: spec.maxTokens } : {}),
+        ...(spec.cost ? { cost: spec.cost } : {}),
+        ...(spec.costSchedule && spec.costSchedule.length > 0 ? { costSchedule: spec.costSchedule } : {}),
+    };
+}
+/** pi 目录条目里的模型 → 界面用的规格视图（没配过就缺省，不编造 0） */
+/** ModelDefinition → 界面用的规格视图（没配过就缺省，不编造 0） */
+export function specView(model) {
+    return {
+        id: model.id,
+        name: model.name ?? model.id,
+        reasoning: model.reasoning === true,
+        imageInput: Array.isArray(model.input) && model.input.includes("image"),
+        ...(typeof model.contextWindow === "number" ? { contextWindow: model.contextWindow } : {}),
+        ...(typeof model.maxTokens === "number" ? { maxTokens: model.maxTokens } : {}),
+        ...(model.cost ? { cost: model.cost } : {}),
+        ...(Array.isArray(model.costSchedule) && model.costSchedule.length > 0
+            ? { costSchedule: model.costSchedule }
+            : {}),
+    };
+}