@tea-agent/loop-agent 0.39.0-next.9 → 0.39.0

package/dist/worker/console/chat/mcp-inventory.js

@@ -0,0 +1,221 @@
+/**
+ * Read-only MCP inventory for Operator Chat.
+ *
+ * Pi has no built-in MCP catalog. Console projects two real facts:
+ *   1. mcp.json server specs (configured, may or may not have registered tools)
+ *   2. tools already on the live session that look like MCP registrations
+ *
+ * Never fabricate servers or tools. Missing files stay empty.
+ */
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+const MCP_CONFIG_NAMES = ["mcp.json"];
+export function isMcpToolName(name) {
+    const lower = name.trim().toLowerCase();
+    return lower === "mcp" || lower.startsWith("mcp_") || lower.startsWith("mcp-");
+}
+export function inferMcpServerName(toolName, knownServers = []) {
+    const name = toolName.trim();
+    if (/^mcp$/i.test(name))
+        return undefined;
+    const rest = name.replace(/^mcp[_-]/i, "");
+    if (!rest || rest === name || knownServers.length === 0)
+        return undefined;
+    const ranked = [...knownServers].sort((left, right) => right.length - left.length);
+    const lower = rest.toLowerCase();
+    return ranked.find((server) => {
+        const key = server.toLowerCase();
+        return lower === key || lower.startsWith(`${key}_`) || lower.startsWith(`${key}-`);
+    });
+}
+export function looksLikeMcpTool(tool) {
+    const name = typeof tool.name === "string" ? tool.name : "";
+    if (!name)
+        return false;
+    if (isMcpToolName(name))
+        return true;
+    const source = `${tool.sourceInfo?.source ?? ""} ${tool.sourceInfo?.path ?? ""}`.toLowerCase();
+    return source.includes("mcp");
+}
+function asRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function readEnabled(entry) {
+    return entry.enabled !== false;
+}
+function readTransport(entry) {
+    if (typeof entry.transport === "string" && entry.transport.trim()) {
+        return entry.transport.trim();
+    }
+    if (typeof entry.type === "string" && entry.type.trim()) {
+        return entry.type.trim();
+    }
+    if (typeof entry.url === "string")
+        return "http";
+    if (Array.isArray(entry.command) || typeof entry.command === "string") {
+        return "stdio";
+    }
+    return undefined;
+}
+function readCommand(entry) {
+    if (typeof entry.command === "string" && entry.command.trim()) {
+        const args = Array.isArray(entry.args)
+            ? entry.args.filter((item) => typeof item === "string").join(" ")
+            : "";
+        return args ? `${entry.command} ${args}` : entry.command;
+    }
+    if (Array.isArray(entry.command)) {
+        return entry.command
+            .filter((item) => typeof item === "string")
+            .join(" ")
+            .trim();
+    }
+    return undefined;
+}
+function extractServerMap(parsed) {
+    const root = asRecord(parsed);
+    if (!root)
+        return {};
+    const mcpServers = asRecord(root.mcpServers);
+    if (mcpServers)
+        return mcpServers;
+    const mcp = asRecord(root.mcp);
+    if (mcp)
+        return mcp;
+    const servers = asRecord(root.servers);
+    if (servers)
+        return servers;
+    return {};
+}
+export function parseMcpConfig(raw, scope, configPath) {
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return [];
+    }
+    const servers = [];
+    for (const [name, value] of Object.entries(extractServerMap(parsed))) {
+        if (!name.trim())
+            continue;
+        const entry = asRecord(value) ?? {};
+        const command = readCommand(entry);
+        const url = typeof entry.url === "string" ? entry.url.trim() : undefined;
+        servers.push({
+            name: name.trim(),
+            scope,
+            enabled: readEnabled(entry),
+            ...(readTransport(entry) ? { transport: readTransport(entry) } : {}),
+            ...(command ? { command } : {}),
+            ...(url ? { url } : {}),
+            configPath,
+        });
+    }
+    return servers;
+}
+export function projectSessionMcpTools(tools, activeToolNames = [], knownServers = []) {
+    const active = new Set(activeToolNames.map((name) => name.toLowerCase()));
+    const seen = new Set();
+    const projected = [];
+    for (const tool of tools) {
+        if (!looksLikeMcpTool(tool) || typeof tool.name !== "string")
+            continue;
+        const name = tool.name.trim();
+        if (!name || seen.has(name))
+            continue;
+        seen.add(name);
+        const server = inferMcpServerName(name, knownServers);
+        projected.push({
+            name,
+            description: typeof tool.description === "string" ? tool.description : "",
+            ...(server ? { server } : {}),
+            source: tool.sourceInfo?.source ?? "",
+            scope: tool.sourceInfo?.scope ?? "session",
+            ...(tool.sourceInfo?.path ? { path: tool.sourceInfo.path } : {}),
+            active: active.has(name.toLowerCase()),
+        });
+    }
+    return projected;
+}
+export function assembleMcpInventory(servers, tools) {
+    const byServer = new Map();
+    const unassigned = [];
+    for (const tool of tools) {
+        const key = tool.server?.toLowerCase();
+        if (!key) {
+            unassigned.push(tool);
+            continue;
+        }
+        const list = byServer.get(key) ?? [];
+        list.push(tool);
+        byServer.set(key, list);
+    }
+    const views = servers.map((server) => {
+        const matched = byServer.get(server.name.toLowerCase()) ?? [];
+        byServer.delete(server.name.toLowerCase());
+        const status = !server.enabled
+            ? "disabled"
+            : matched.length > 0
+                ? "loaded"
+                : "configured";
+        return {
+            name: server.name,
+            scope: server.scope,
+            status,
+            enabled: server.enabled,
+            ...(server.transport ? { transport: server.transport } : {}),
+            ...(server.command ? { command: server.command } : {}),
+            ...(server.url ? { url: server.url } : {}),
+            configPath: server.configPath,
+            tools: matched,
+        };
+    });
+    for (const [name, matched] of byServer) {
+        views.push({
+            name,
+            scope: "session",
+            status: "loaded",
+            enabled: true,
+            tools: matched,
+        });
+    }
+    return { servers: views, unassignedTools: unassigned };
+}
+async function readConfigFile(filePath) {
+    try {
+        return await readFile(filePath, "utf8");
+    }
+    catch {
+        return undefined;
+    }
+}
+export async function loadMcpServerSpecs(options) {
+    const candidates = [
+        { path: path.join(options.agentDir, ...MCP_CONFIG_NAMES), scope: "user" },
+        { path: path.join(options.cwd, ".pi", ...MCP_CONFIG_NAMES), scope: "project" },
+        { path: path.join(options.cwd, ".mcp.json"), scope: "project" },
+    ];
+    const servers = [];
+    const seen = new Set();
+    for (const candidate of candidates) {
+        const raw = await readConfigFile(candidate.path);
+        if (!raw)
+            continue;
+        for (const server of parseMcpConfig(raw, candidate.scope, candidate.path)) {
+            const key = `${server.scope}:${server.name.toLowerCase()}`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            servers.push(server);
+        }
+    }
+    return servers;
+}
+export async function readMcpInventory(options) {
+    const servers = await loadMcpServerSpecs(options);
+    const tools = projectSessionMcpTools(options.tools ?? [], options.activeToolNames ?? [], servers.map((server) => server.name));
+    return assembleMcpInventory(servers, tools);
+}

package/dist/worker/console/chat/operation-card.js

@@ -64,7 +64,14 @@ function safeRunSummary(value) {
             const status = String(node.status ?? "");
             if (!id || !status)
                 return [];
-            return [{ id, status }];
+            const failureCategory = String(node.failureCategory ?? "");
+            return [
+                {
+                    id,
+                    status,
+                    ...(failureCategory ? { failureCategory } : {}),
+                },
+            ];
         })
             .slice(0, 20);
     }

package/dist/worker/console/chat/pi-console-config.js

@@ -1,6 +1,13 @@
 import { createHash, randomBytes } from "node:crypto";
 import { open, readFile, rename, writeFile } from "node:fs/promises";
 import path from "node:path";
+/** 新建模型时，未显式提供的字段使用的默认值（仅含 6 个定义参数）。 */
+const DEFAULT_MODEL_FIELDS = {
+    contextWindow: 32000,
+    maxTokens: 8192,
+    reasoning: false,
+    input: ["text"],
+};
 const revision = (raw) => createHash("sha256").update(raw).digest("hex");
 export async function readModelsConfig(agentDir) {
     let raw = "{}";
@@ -29,6 +36,18 @@ export async function readModelsConfig(agentDir) {
                     return {
                         id: String(item.id ?? ""),
                         name: typeof item.name === "string" ? item.name : undefined,
+                        contextWindow: typeof item.contextWindow === "number"
+                            ? item.contextWindow
+                            : undefined,
+                        maxTokens: typeof item.maxTokens === "number"
+                            ? item.maxTokens
+                            : undefined,
+                        input: Array.isArray(item.input)
+                            ? item.input.filter((entry) => typeof entry === "string")
+                            : undefined,
+                        reasoning: typeof item.reasoning === "boolean"
+                            ? item.reasoning
+                            : undefined,
                     };
                 })
                     .filter((model) => model.id)
@@ -81,19 +100,25 @@ export async function patchModelsConfig(agentDir, input) {
                 code: "INVALID_INPUT",
                 status: 400,
             });
+        const fields = validateModelFields(input.model);
+        const existingIndex = models.findIndex((model) => model.id === input.model.id);
+        const merged = {
+            // id/name 在前；新建模型用默认字段补齐（保证定义完整），更新保留已有值。
+            id: input.model.id,
+            ...(fields.name !== undefined ? { name: fields.name } : {}),
+            ...(existingIndex >= 0 ? models[existingIndex] : DEFAULT_MODEL_FIELDS),
+            ...fields,
+        };
         provider.models =
             input.action === "remove-model"
                 ? models.filter((model) => model.id !== input.model.id)
-                : [
-                    ...models.filter((model) => model.id !== input.model.id),
-                    {
-                        ...(models.find((model) => model.id === input.model.id) ?? {}),
-                        id: input.model.id,
-                        ...(input.model.name !== undefined
-                            ? { name: input.model.name }
-                            : {}),
-                    },
-                ];
+                : existingIndex >= 0
+                    ? [
+                        ...models.slice(0, existingIndex),
+                        merged,
+                        ...models.slice(existingIndex + 1),
+                    ]
+                    : [...models, merged];
     }
     const body = `${JSON.stringify(parsed, null, 2)}\n`;
     const tmp = path.join(agentDir, `.models.${process.pid}.${randomBytes(4).toString("hex")}.tmp`);
@@ -108,6 +133,52 @@ export async function patchModelsConfig(agentDir, input) {
     await rename(tmp, file);
     return readModelsConfig(agentDir);
 }
+/** Whitelist + validate model fields carried by a client upsert. Never accept
+ *  arbitrary keys; only known numeric/boolean/string-array shape fields. */
+function validateModelFields(model) {
+    const fields = {};
+    if (model.name !== undefined)
+        fields.name = String(model.name);
+    if (model.contextWindow !== undefined) {
+        if (typeof model.contextWindow !== "number" || model.contextWindow < 0)
+            throw invalid("contextWindow must be a non-negative number");
+        fields.contextWindow = model.contextWindow;
+    }
+    if (model.maxTokens !== undefined) {
+        if (typeof model.maxTokens !== "number" || model.maxTokens < 0)
+            throw invalid("maxTokens must be a non-negative number");
+        fields.maxTokens = model.maxTokens;
+    }
+    if (model.reasoning !== undefined) {
+        if (typeof model.reasoning !== "boolean")
+            throw invalid("reasoning must be a boolean");
+        fields.reasoning = model.reasoning;
+    }
+    if (model.input !== undefined) {
+        if (!Array.isArray(model.input) ||
+            !model.input.every((item) => typeof item === "string"))
+            throw invalid("input must be an array of strings");
+        fields.input = model.input.map((item) => String(item));
+    }
+    if (model.cost !== undefined) {
+        if (!model.cost || typeof model.cost !== "object")
+            throw invalid("cost must be an object");
+        const cost = {};
+        for (const key of ["input", "output", "cacheRead", "cacheWrite"]) {
+            const value = model.cost[key];
+            if (value !== undefined) {
+                if (typeof value !== "number" || value < 0)
+                    throw invalid(`cost.${key} must be a non-negative number`);
+                cost[key] = value;
+            }
+        }
+        fields.cost = cost;
+    }
+    return fields;
+}
+function invalid(message) {
+    return Object.assign(new Error(message), { code: "INVALID_INPUT", status: 400 });
+}
 /** Max bytes of a package.json we are willing to read (read-only, bounded). */
 export const MAX_PACKAGE_JSON_BYTES = 64 * 1024;
 /** Max directory levels walked upward from an owned resolved resource path. */