@rien7/agent-center-host 0.0.0-stage → 0.1.0

package/dist/center-tools.js

@@ -0,0 +1,882 @@
+/**
+ * The tools an agent gets from Center, served by the host over MCP (`serveMcpTools`, a
+ * loopback HTTP server per agent) instead of attaching core's `/mcp` directly. Core has
+ * ~100 tools (~130 KB of schemas per request); the model gets five:
+ *
+ * - `tools_search({query?, domain?})`  names + one-line descriptions, no schemas
+ * - `tool_describe({name})`            one tool's full input schema
+ * - `tool_call({name, input})`         run it (proxied to core /mcp with the agent's token)
+ * - `today_overview({date?})`          a day's events, reminders and visits in one call
+ * - `agent_search_query({q, …})`       full-text search over past conversations
+ *
+ * The agent's token (its scopes) is what really bounds what it can do; the host adds a
+ * small denylist of tools an agent has no business calling (sync plumbing, settings,
+ * host/admin ops).
+ */
+import { coreToolTitle, domainTitles } from "./tool-titles.js";
+/** Center with an agent's own token: core `/mcp` and `/v1/ops`. */
+export class CenterApi {
+    server;
+    token;
+    fetcher;
+    rpcId = 0;
+    constructor(server, token, options = {}) {
+        this.server = server.replace(/\/+$/, "");
+        this.token = token;
+        this.fetcher = options.fetch ?? fetch;
+    }
+    async rpc(method, params, signal) {
+        const response = await this.fetcher(`${this.server}/mcp`, {
+            method: "POST",
+            headers: {
+                authorization: `Bearer ${this.token}`,
+                "content-type": "application/json",
+                accept: "application/json, text/event-stream",
+            },
+            body: JSON.stringify({
+                jsonrpc: "2.0",
+                id: ++this.rpcId,
+                method,
+                params,
+            }),
+            signal,
+        });
+        let text = await response.text();
+        // Streamable HTTP may answer as SSE: take the last data line.
+        if (response.headers.get("content-type")?.includes("text/event-stream"))
+            text =
+                text
+                    .split("\n")
+                    .filter((l) => l.startsWith("data:"))
+                    .map((l) => l.slice(5).trim())
+                    .at(-1) ?? "";
+        let body;
+        try {
+            body = JSON.parse(text);
+        }
+        catch {
+            throw new Error(`core /mcp ${method} failed with ${response.status}`);
+        }
+        if (body.error || body.result === undefined)
+            throw new Error(body.error?.message ??
+                `core /mcp ${method} failed (${response.status})`);
+        return body.result;
+    }
+    async listTools() {
+        const tools = [];
+        let cursor;
+        do {
+            const page = await this.rpc("tools/list", cursor ? { cursor } : {});
+            for (const t of page.tools)
+                tools.push({
+                    name: t.name,
+                    description: t.description ?? "",
+                    inputSchema: t.inputSchema ?? { type: "object" },
+                    readOnly: t.annotations?.readOnlyHint === true,
+                });
+            cursor = page.nextCursor;
+        } while (cursor);
+        return tools;
+    }
+    /** core.domain.list: the domains this token can read, with titles and descriptions. */
+    async domains() {
+        const data = await this.op("core.domain.list", {});
+        return data.domains.map((d) => ({
+            domain: d.domain,
+            title: d.ui?.title ?? domainTitles[d.domain] ?? d.title ?? d.domain,
+            description: d.description ?? "",
+            order: d.ui?.order ?? 100,
+        }));
+    }
+    callTool(name, args, signal) {
+        return this.rpc("tools/call", { name, arguments: args }, signal);
+    }
+    async op(name, input, signal) {
+        const response = await this.fetcher(`${this.server}/v1/ops/${name}`, {
+            method: "POST",
+            headers: {
+                authorization: `Bearer ${this.token}`,
+                "content-type": "application/json",
+            },
+            body: JSON.stringify(input),
+            signal,
+        });
+        const body = (await response.json().catch(() => ({})));
+        if (!response.ok || body.data === undefined)
+            throw new Error(body.error?.message ?? `${name} failed with ${response.status}`);
+        return body.data;
+    }
+}
+/**
+ * Why an agent may not call a core tool, or null. Scopes stay the real boundary; this
+ * keeps out what is plumbing or the owner's business even when a token could reach it.
+ */
+export function deniedReason(name) {
+    if (/^core_(sync|change|command|principal|token|oauth|scope|device)_/.test(name))
+        return "同步/凭据类内部接口";
+    if (name === "core_link_scan")
+        return "同步/凭据类内部接口";
+    if (/_settings_update$/.test(name))
+        return "存储设置只能由用户在 App 里改";
+    if (/^agent_/.test(name) &&
+        !/^agent_(search_query|agent_list|conversation_list|message_list)$/.test(name))
+        return "助手域的写入和 host 操作";
+    if (/^inbox_app_icons?$/.test(name))
+        return "二进制图标";
+    return null;
+}
+const firstSentence = (text, max = 120) => {
+    const one = text.replace(/\s+/g, " ").trim();
+    const cut = one.search(/(?<=[.。！？!?])\s|(?<=[。！？])/);
+    const sentence = cut > 0 ? one.slice(0, cut).trim() : one;
+    const chars = Array.from(sentence);
+    return chars.length > max ? `${chars.slice(0, max).join("")}…` : sentence;
+};
+const verbWords = [
+    [/_(create|add)$/, "新建 添加 加 创建 记 add create new"],
+    [/_(update|set|move)$/, "修改 改 更新 调整 edit update change"],
+    [/_(delete|remove)$/, "删除 删掉 去掉 remove delete"],
+    [/_complete$/, "完成 做完 勾掉 done complete"],
+    [/_uncomplete$/, "重新打开 取消完成"],
+    [
+        /_(list|get|getMany|summary|metric|series|days|balance)$/,
+        "查询 查看 看 列出 有哪些 list get",
+    ],
+    [/_(search|query)$/, "搜索 搜 找 查找 search find"],
+];
+const cjk = /[\u3400-\u9fff]/;
+function score(haystack, terms) {
+    let total = 0;
+    for (const term of terms) {
+        if (haystack.includes(term)) {
+            total += 2;
+            continue;
+        }
+        if (cjk.test(term) && Array.from(term).length > 1) {
+            // 「加提醒」: every character somewhere beats most of them.
+            const chars = Array.from(term).filter((c) => cjk.test(c));
+            const hits = chars.filter((c) => haystack.includes(c)).length;
+            if (hits === chars.length)
+                total += 1.5;
+            else if (hits * 2 >= chars.length)
+                total += 1;
+        }
+    }
+    return total;
+}
+const pad = (n) => String(n).padStart(2, "0");
+/** Minutes east of UTC of `timeZone` at `instant`. */
+function offsetMinutes(timeZone, instant) {
+    const parts = Object.fromEntries(new Intl.DateTimeFormat("en-US", {
+        timeZone,
+        hourCycle: "h23",
+        year: "numeric",
+        month: "2-digit",
+        day: "2-digit",
+        hour: "2-digit",
+        minute: "2-digit",
+        second: "2-digit",
+    })
+        .formatToParts(new Date(instant))
+        .map((p) => [p.type, p.value]));
+    const local = Date.UTC(Number(parts.year), Number(parts.month) - 1, Number(parts.day), Number(parts.hour), Number(parts.minute), Number(parts.second));
+    return Math.round((local - Math.floor(instant / 1000) * 1000) / 60_000);
+}
+/** The local calendar date `YYYY-MM-DD` of `instant` in `timeZone`. */
+export function localDate(timeZone, instant = Date.now()) {
+    return new Intl.DateTimeFormat("en-CA", {
+        timeZone,
+        year: "numeric",
+        month: "2-digit",
+        day: "2-digit",
+    }).format(new Date(instant));
+}
+/** [start, end) of a local day as UTC instants. */
+export function dayRange(date, timeZone) {
+    const [y, m, d] = date.split("-").map(Number);
+    const midnight = (day) => {
+        const guess = Date.UTC(y, m - 1, day);
+        let t = guess - offsetMinutes(timeZone, guess) * 60_000;
+        const again = offsetMinutes(timeZone, t);
+        t = guess - again * 60_000;
+        return new Date(t).toISOString();
+    };
+    return { from: midnight(d), to: midnight(d + 1) };
+}
+/** `2026-11-03 周二 18:40` in `timeZone`. */
+export function localNow(timeZone, instant = Date.now()) {
+    const parts = Object.fromEntries(new Intl.DateTimeFormat("en-US", {
+        timeZone,
+        hourCycle: "h23",
+        weekday: "short",
+        hour: "2-digit",
+        minute: "2-digit",
+    })
+        .formatToParts(new Date(instant))
+        .map((p) => [p.type, p.value]));
+    const week = {
+        Sun: "周日",
+        Mon: "周一",
+        Tue: "周二",
+        Wed: "周三",
+        Thu: "周四",
+        Fri: "周五",
+        Sat: "周六",
+    };
+    return `${localDate(timeZone, instant)} ${week[parts.weekday] ?? ""} ${pad(Number(parts.hour))}:${parts.minute}`;
+}
+const textOf = (result) => result.content
+    .filter((c) => c.type === "text" && typeof c.text === "string")
+    .map((c) => c.text)
+    .join("\n");
+const keep = [
+    "id",
+    "title",
+    "name",
+    "start",
+    "end",
+    "allDay",
+    "due",
+    "dueHasTime",
+    "completedAt",
+    "location",
+    "placeName",
+    "arrivedAt",
+    "departedAt",
+    "arrival",
+    "departure",
+    "minutes",
+    "category",
+    "notes",
+];
+/** Trim a record to what a day overview needs. */
+function brief(item) {
+    if (!item || typeof item !== "object")
+        return item;
+    const out = {};
+    for (const key of keep) {
+        const value = item[key];
+        if (value === undefined || value === null || value === "")
+            continue;
+        out[key] =
+            typeof value === "string" && value.length > 200
+                ? `${value.slice(0, 200)}…`
+                : value;
+    }
+    return Object.keys(out).length ? out : item;
+}
+/** What each domain holds, for the catalog (fallback: the contract's description). */
+const domainBlurbs = {
+    reminder: "待办和提醒（到期、地点、完成）",
+    calendar: "日程",
+    memo: "备忘和笔记",
+    people: "联系人",
+    location: "保存的地点、去过哪里（到访记录）",
+    ledger: "账户、交易、分类、报表",
+    inbox: "收到的通知（手机推送、支付提醒、服务器告警）",
+    telemetry: "睡眠、步数等健康数据",
+    agent: "和助手的对话历史",
+    core: "跨域：时间线、按 URI 读记录、记录之间的关联",
+};
+/** Which domains keep their tool list when the catalog must shrink (first kept longest). */
+const catalogPriority = [
+    "reminder",
+    "calendar",
+    "memo",
+    "people",
+    "location",
+    "agent",
+    "core",
+    "telemetry",
+    "inbox",
+    "ledger",
+];
+/** Shown for a domain whose catalog line is shortened. */
+const commonTools = {
+    ledger: [
+        "transaction_list",
+        "transaction_summary",
+        "report_summary",
+        "account_balance",
+    ],
+    inbox: ["notification_list", "notification_get", "today_metric"],
+    telemetry: ["sleep_summary", "steps_metric", "steps_series", "sample_list"],
+};
+/** A context's list tool per domain, when it isn't the first `_list`. */
+const commonList = {
+    reminder: "reminder_item_list",
+    calendar: "calendar_event_list",
+    location: "location_visit_list",
+    memo: "memo_note_list",
+    people: "people_person_list",
+    ledger: "ledger_transaction_list",
+    inbox: "inbox_notification_list",
+};
+/** A context's single write per domain: the everyday create. */
+const commonWrite = {
+    reminder: "reminder_item_create",
+    calendar: "calendar_event_create",
+    memo: "memo_note_create",
+};
+/** Rough token count: ~4 ASCII characters or ~1 CJK character per token. */
+export function estimateTokens(text) {
+    let ascii = 0;
+    let other = 0;
+    for (const ch of text) {
+        if (ch.charCodeAt(0) < 128)
+            ascii++;
+        else
+            other++;
+    }
+    return Math.ceil(ascii / 4) + other;
+}
+/** The domains a chat context is about: the 今天 page → reminder, calendar, location. */
+export function contextDomains(context) {
+    const kind = context?.kind;
+    if (!kind)
+        return [];
+    if (kind.type === "entity" && typeof kind.uri === "string") {
+        const domain = kind.uri.split(":")[0] ?? "";
+        return domain ? [domain] : [];
+    }
+    if (kind.type === "page" && typeof kind.page === "string") {
+        const page = kind.page.toLowerCase();
+        if (["today", "timeline", "home", "今天"].includes(page))
+            return ["reminder", "calendar", "location"];
+        return [page.split(/[./:]/)[0] ?? page];
+    }
+    return [];
+}
+/** A JSON Schema as short parameter lines (no regex patterns, no $schema). */
+export function schemaLines(schema, indent = "") {
+    const props = (schema.properties ?? {});
+    const required = new Set(schema.required ?? []);
+    return Object.entries(props).map(([key, prop]) => {
+        const desc = typeof prop.description === "string"
+            ? ` — ${prop.description.replace(/\s+/g, " ")}`
+            : "";
+        return `${indent}${key}${required.has(key) ? "" : "?"}: ${typeLabel(prop)}${desc}`;
+    });
+}
+function typeLabel(prop) {
+    if (Array.isArray(prop.enum))
+        return prop.enum.map((v) => JSON.stringify(v)).join("|");
+    if ("const" in prop)
+        return JSON.stringify(prop.const);
+    const union = (prop.anyOf ?? prop.oneOf);
+    if (Array.isArray(union))
+        return union.map(typeLabel).join(" | ");
+    let label = String(prop.type ?? "any");
+    if (prop.type === "string") {
+        if (prop.format)
+            label = `string(${prop.format})`;
+        if (prop.maxLength)
+            label += `≤${prop.maxLength}`;
+    }
+    else if (prop.type === "integer" || prop.type === "number") {
+        if (prop.minimum !== undefined || prop.maximum !== undefined)
+            label += ` ${prop.minimum ?? ""}–${prop.maximum ?? ""}`;
+    }
+    else if (prop.type === "array" && prop.items)
+        label = `${typeLabel(prop.items)}[]`;
+    else if (prop.type === "object" && prop.properties)
+        label = `{ ${Object.entries(prop.properties)
+            .map(([k, v]) => `${k}${(prop.required ?? []).includes(k) ? "" : "?"}: ${typeLabel(v)}`)
+            .join(", ")} }`;
+    if (prop.default !== undefined)
+        label += ` = ${JSON.stringify(prop.default)}`;
+    return label;
+}
+/** Strip regex patterns (uuid/date-time) and `$schema` from a schema, deeply. */
+export function compactSchema(value) {
+    if (Array.isArray(value))
+        return value.map(compactSchema);
+    if (!value || typeof value !== "object")
+        return value;
+    const out = {};
+    for (const [k, v] of Object.entries(value)) {
+        if (k === "$schema")
+            continue;
+        if (k === "pattern" && "format" in value)
+            continue;
+        out[k] = compactSchema(v);
+    }
+    return out;
+}
+/** Order inside an expanded domain: the everyday verbs first. */
+const verbRank = (name) => {
+    const order = [
+        /_list$/,
+        /_create$/,
+        /_update$/,
+        /_complete$/,
+        /_delete$/,
+        /_search|_query$/,
+        /_get$/,
+    ];
+    const i = order.findIndex((p) => p.test(name));
+    return i < 0 ? order.length : i;
+};
+/** Core's MCP result text is the op's output, or `{data, commandId}` for a command. */
+const unwrap = (value) => value &&
+    typeof value === "object" &&
+    "data" in value &&
+    Object.keys(value).every((k) => k === "data" || k === "commandId" || k === "dryRun")
+    ? value.data
+    : value;
+/** The host-served tool set for one agent. */
+export class CenterTools {
+    api;
+    timeZone;
+    catalog = [];
+    domainInfo = [];
+    loadedAt = 0;
+    loading = null;
+    refreshMs;
+    now;
+    constructor(options) {
+        this.api = options.api;
+        this.timeZone = options.timeZone;
+        this.refreshMs = options.refreshMs ?? 10 * 60_000;
+        this.now = options.now ?? Date.now;
+    }
+    /** Core tools this agent may use (visible to its token, minus the denylist). */
+    async tools() {
+        if (!this.loadedAt || this.now() - this.loadedAt > this.refreshMs) {
+            this.loading ??= this.load();
+            await this.loading;
+        }
+        return this.catalog;
+    }
+    load() {
+        return Promise.all([
+            this.api.listTools(),
+            this.api.domains().catch(() => this.domainInfo),
+        ])
+            .then(([all, domains]) => {
+            this.catalog = all.filter((t) => !deniedReason(t.name));
+            this.domainInfo = domains;
+            this.loadedAt = this.now();
+        })
+            .finally(() => {
+            this.loading = null;
+        });
+    }
+    async find(name) {
+        return (await this.tools()).find((t) => t.name === name) ?? null;
+    }
+    async isWrite(name) {
+        const tool = await this.find(name);
+        return tool ? !tool.readOnly : false;
+    }
+    /**
+     * One line per domain the token can see: `reminder 提醒：待办和提醒 — item_list,
+     * item_create, …`. Within `budget` (estimated tokens) the less used domains drop their
+     * tool list first and keep a count.
+     */
+    async domainCatalog(budget = 500) {
+        const tools = await this.tools();
+        const byDomain = new Map();
+        for (const t of tools) {
+            const d = t.name.split("_")[0] ?? "";
+            byDomain.set(d, [...(byDomain.get(d) ?? []), t.name.slice(d.length + 1)]);
+        }
+        const byDomainSorted = new Map([...byDomain].map(([d, names]) => [
+            d,
+            [...names].sort((a, b) => verbRank(`_${a}`) - verbRank(`_${b}`) || a.localeCompare(b)),
+        ]));
+        const info = new Map(this.domainInfo.map((d) => [d.domain, d]));
+        const domains = [...byDomain.keys()].sort((a, b) => (a === "core" ? 1 : 0) - (b === "core" ? 1 : 0) ||
+            (info.get(a)?.order ?? 100) - (info.get(b)?.order ?? 100) ||
+            a.localeCompare(b));
+        const brief = new Set();
+        const render = () => domains
+            .map((d) => {
+            const i = info.get(d);
+            const title = i?.title ?? domainTitles[d] ?? d;
+            const blurb = domainBlurbs[d] ?? firstSentence(i?.description ?? "", 60);
+            const names = byDomain.get(d) ?? [];
+            const list = brief.has(d)
+                ? `${names.length} 个工具，常用 ${(commonTools[d]?.filter((n) => names.includes(n)) ?? byDomainSorted.get(d) ?? []).slice(0, 4).join(", ")}…`
+                : names.join(", ");
+            return `${d} ${title}：${blurb} — ${list}`;
+        })
+            .join("\n");
+        let text = render();
+        const shrink = [...domains].sort((a, b) => (catalogPriority.indexOf(b) + 1 || 99) -
+            (catalogPriority.indexOf(a) + 1 || 99));
+        for (const d of shrink) {
+            if (estimateTokens(text) <= budget)
+                break;
+            brief.add(d);
+            text = render();
+        }
+        return text;
+    }
+    /**
+     * Full tools of the domains a turn is about, inlined in its prompt: name, title,
+     * description and parameters, so the model can call them via tool_call right away.
+     */
+    /** A domain's tools, everyday verbs first. */
+    async domainTools(domain) {
+        return (await this.tools())
+            .filter((t) => t.name.startsWith(`${domain}_`) && !/_settings_/.test(t.name))
+            .sort((a, b) => verbRank(a.name) - verbRank(b.name) || a.name.localeCompare(b.name));
+    }
+    /**
+     * What a context expands for a domain: its list and get, plus its most common write
+     * (create). The rest stays a tool_describe away.
+     */
+    async contextTools(domain) {
+        const own = await this.domainTools(domain);
+        const list = own.find((t) => t.name === commonList[domain]) ??
+            own.find((t) => /_list$/.test(t.name));
+        const get = own.find((t) => /_get$/.test(t.name));
+        const write = own.find((t) => t.name === commonWrite[domain]) ??
+            own.find((t) => /_create$/.test(t.name));
+        const shown = [list, get, write].filter((t) => !!t);
+        return { shown, rest: own.filter((t) => !shown.includes(t)) };
+    }
+    async expandDomains(domains) {
+        const blocks = [];
+        for (const d of domains) {
+            const { shown, rest } = await this.contextTools(d);
+            if (!shown.length)
+                continue;
+            blocks.push([
+                `## ${domainTitles[d] ?? d}（${d}）的工具，用 tool_call({name, input}) 调用`,
+                ...shown.map((t) => [
+                    `### ${t.name} ${coreToolTitle(t.name, t.readOnly)}${t.readOnly ? "" : "（写入）"}`,
+                    t.description.replace(/\s+/g, " "),
+                    ...schemaLines(t.inputSchema, "- "),
+                ].join("\n")),
+                ...(rest.length
+                    ? [
+                        `（还有 ${rest.length} 个：${rest
+                            .map((t) => t.name)
+                            .join(", ")}；用 tool_describe 看参数）`,
+                    ]
+                    : []),
+            ].join("\n"));
+        }
+        return blocks.join("\n\n");
+    }
+    /** `name 标题：one sentence`, grouped by domain. */
+    async search(input) {
+        const tools = await this.tools();
+        const domain = input.domain?.trim().toLowerCase();
+        const inDomain = domain
+            ? tools.filter((t) => t.name.startsWith(`${domain}_`) ||
+                domainTitles[t.name.split("_")[0] ?? ""] === input.domain?.trim())
+            : tools;
+        const query = input.query?.trim().toLowerCase();
+        let hits;
+        if (query) {
+            const terms = query.split(/[\s,，、]+/).filter(Boolean);
+            hits = inDomain
+                .map((t) => {
+                const d = t.name.split("_")[0] ?? "";
+                const verbs = verbWords
+                    .filter(([p]) => p.test(t.name))
+                    .map(([, w]) => w)
+                    .join(" ");
+                const hay = `${t.name} ${t.name.replaceAll("_", " ")} ${coreToolTitle(t.name, t.readOnly)} ${domainTitles[d] ?? ""} ${verbs} ${t.description}`.toLowerCase();
+                return { t, s: score(hay, terms) };
+            })
+                .filter((x) => x.s > 0)
+                .sort((a, b) => b.s - a.s)
+                .slice(0, 25)
+                .map((x) => x.t);
+        }
+        else if (domain)
+            hits = inDomain;
+        else {
+            // Overview: every domain with its tool names.
+            const groups = new Map();
+            for (const t of tools) {
+                const d = t.name.split("_")[0] ?? "";
+                groups.set(d, [...(groups.get(d) ?? []), t.name]);
+            }
+            return [
+                "可用的工具（按域）。用 tools_search({query}) 或 tools_search({domain}) 看说明，tool_describe 看参数，tool_call 调用。",
+                ...[...groups].map(([d, names]) => `\n${domainTitles[d] ?? d}（${d}，${names.length} 个）：${names.join(", ")}`),
+            ].join("\n");
+        }
+        if (!hits.length)
+            return `没有找到匹配「${input.query ?? input.domain ?? ""}」的工具。可用的域：${[
+                ...new Set(tools.map((t) => t.name.split("_")[0])),
+            ]
+                .map((d) => `${domainTitles[d ?? ""] ?? d}(${d})`)
+                .join("、")}。换个关键词，或用 tools_search({domain}) 列出一个域的全部工具。`;
+        const lines = [];
+        let current = "";
+        for (const t of [...hits].sort((a, b) => query ? 0 : a.name.localeCompare(b.name))) {
+            const d = t.name.split("_")[0] ?? "";
+            if (!query && d !== current) {
+                current = d;
+                lines.push(`${domainTitles[d] ?? d}（${d}）`);
+            }
+            lines.push(`- ${t.name} ${coreToolTitle(t.name, t.readOnly)}${t.readOnly ? "" : "（写入）"}：${firstSentence(t.description)}`);
+        }
+        lines.push("用 tool_describe({name}) 看参数，再用 tool_call({name, input}) 调用。");
+        return lines.join("\n");
+    }
+    async describe(name) {
+        const tool = await this.find(name);
+        if (!tool)
+            return null;
+        const schema = compactSchema(tool.inputSchema);
+        return JSON.stringify({
+            name: tool.name,
+            title: coreToolTitle(tool.name, tool.readOnly),
+            writes: !tool.readOnly,
+            description: tool.description,
+            inputSchema: schema,
+        }, null, 1);
+    }
+    async call(name, input, signal) {
+        const denied = deniedReason(name);
+        if (denied)
+            return {
+                content: [{ type: "text", text: `不能调用 ${name}：${denied}。` }],
+                isError: true,
+            };
+        if (!(await this.find(name)))
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `没有工具 ${name}（或这个助手没有权限）。先用 tools_search 找工具名。`,
+                    },
+                ],
+                isError: true,
+            };
+        return this.api.callTool(name, input, signal);
+    }
+    /** A day's events, reminders (due that day, plus overdue ones for today) and visits. */
+    async todayOverview(input, signal) {
+        const today = localDate(this.timeZone, this.now());
+        const date = input.date && /^\d{4}-\d{2}-\d{2}$/.test(input.date) ? input.date : today;
+        const { from, to } = dayRange(date, this.timeZone);
+        const tz = this.timeZone;
+        const available = new Set((await this.tools()).map((t) => t.name));
+        const section = async (name, args) => {
+            if (!available.has(name))
+                return { unavailable: true };
+            try {
+                const result = await this.api.callTool(name, args, signal);
+                const text = textOf(result);
+                if (result.isError)
+                    return { error: text.slice(0, 300) };
+                const data = unwrap(JSON.parse(text));
+                const items = data.items;
+                return Array.isArray(items) ? items.map(brief) : data;
+            }
+            catch (error) {
+                return { error: error.message };
+            }
+        };
+        const [events, reminders, overdue, visits] = await Promise.all([
+            section("calendar_event_list", { from, to, limit: 50 }),
+            section("reminder_item_list", { status: "open", from, to, limit: 50 }),
+            date === today
+                ? section("reminder_item_list", { status: "open", to: from, limit: 20 })
+                : Promise.resolve(undefined),
+            section("location_visit_list", { from, to, tz, limit: 30 }),
+        ]);
+        return JSON.stringify({
+            date,
+            timeZone: tz,
+            range: { from, to },
+            events,
+            reminders,
+            ...(overdue !== undefined ? { overdueReminders: overdue } : {}),
+            visits,
+        });
+    }
+}
+const symbols = {
+    reminder: "checklist",
+    calendar: "calendar",
+    memo: "note.text",
+    people: "person.crop.circle",
+    location: "mappin.and.ellipse",
+    ledger: "creditcard",
+    agent: "text.bubble",
+};
+function preview(uri, value) {
+    const str = (key) => typeof value?.[key] === "string" && value[key]
+        ? value[key]
+        : null;
+    const domain = uri.split(":")[0] ?? "";
+    const body = str("body") ?? str("text");
+    const title = str("title") ??
+        str("name") ??
+        (body
+            ? Array.from(body.split("\n")[0] ?? "")
+                .slice(0, 80)
+                .join("")
+            : null) ??
+        domainTitles[domain] ??
+        uri;
+    const date = str("due") ?? str("start") ?? str("at");
+    return {
+        title,
+        summary: str("location") ?? str("notes")?.slice(0, 200) ?? null,
+        symbol: symbols[domain] ?? null,
+        date,
+        dateHasTime: typeof value?.dueHasTime === "boolean"
+            ? value.dueHasTime
+            : typeof value?.allDay === "boolean"
+                ? !value.allDay
+                : true,
+        done: !!value?.completedAt,
+    };
+}
+/**
+ * Record cards for a write: the result of a core command carries its `commandId`
+ * (`{data, commandId}`); `core.command.get` lists the entities it changed and
+ * `core.entity.get` gives their current values. Both run with the agent's token, so only
+ * records it can read become cards. Nothing to show (a read, a dry run, an error): [].
+ */
+export async function recordCards(api, resultText, options = {}) {
+    let body;
+    try {
+        body = JSON.parse(resultText);
+    }
+    catch {
+        return [];
+    }
+    if (typeof body?.commandId !== "string" || body.dryRun)
+        return [];
+    const command = await api.op("core.command.get", { id: body.commandId }, options.signal);
+    const byUri = new Map();
+    for (const change of command.changes ?? []) {
+        if (change.op === "purge")
+            continue;
+        const seen = byUri.get(change.uri);
+        // insert wins over a later update of the same row; delete wins over both.
+        if (!seen ||
+            change.op === "delete" ||
+            (seen === "update" && change.op === "insert"))
+            byUri.set(change.uri, change.op);
+    }
+    const uris = [...byUri.keys()].slice(0, options.max ?? 3);
+    if (!uris.length)
+        return [];
+    const values = await api
+        .op("core.entity.get", { uris, includeDeleted: true }, options.signal)
+        .then((r) => new Map(r.items.map((i) => [i.uri, i.value])))
+        .catch(() => new Map());
+    return uris
+        .filter((uri) => values.has(uri))
+        .map((uri) => {
+        const op = byUri.get(uri);
+        return {
+            type: "record",
+            record: {
+                uri,
+                change: op === "insert"
+                    ? "created"
+                    : op === "update"
+                        ? "modified"
+                        : null,
+                deleted: op === "delete",
+                preview: preview(uri, values.get(uri) ?? null),
+            },
+        };
+    });
+}
+/** Names of the host-served tools whose `input.name` is the real tool. */
+export const proxyTools = new Set(["tool_call", "tool_describe"]);
+export const centerInstructions = "Center 是用户的个人数据中心（提醒、日程、备忘、联系人、地点、账本、通知、健康…）。需要查或改数据时先用 tools_search 找工具，tool_describe 看参数，tool_call 调用；今天的安排直接用 today_overview；以前聊过的事用 agent_search_query。";
+/** The five tools the model sees. */
+export async function centerServedTools(tools) {
+    const search = await tools.find("agent_search_query").catch(() => null);
+    const result = (text, isError = false) => ({
+        content: [{ type: "text", text }],
+        ...(isError ? { isError } : {}),
+    });
+    const served = [
+        {
+            name: "tools_search",
+            description: "查找 Center 的数据工具。domain 列出一个域的全部工具（如 reminder、ledger）；query 按关键词找（中文或英文，如「新建提醒」「睡眠」「search」），两者可以一起用。返回工具名、标题和一句话说明，不含参数；参数用 tool_describe 看。",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    query: { type: "string", description: "关键词" },
+                    domain: { type: "string", description: "域名，如 reminder" },
+                },
+            },
+            handler: async (input) => tools.search({
+                query: typeof input.query === "string" ? input.query : undefined,
+                domain: typeof input.domain === "string" ? input.domain : undefined,
+            }),
+        },
+        {
+            name: "tool_describe",
+            description: "一个工具的完整说明和输入参数（JSON Schema）。调用 tool_call 之前先看。",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    name: {
+                        type: "string",
+                        description: "工具名，如 reminder_item_create",
+                    },
+                },
+                required: ["name"],
+            },
+            handler: async (input) => {
+                const name = String(input.name ?? "");
+                return ((await tools.describe(name)) ??
+                    result(`没有工具 ${name}。先用 tools_search 找工具名。`, true));
+            },
+        },
+        {
+            name: "tool_call",
+            description: "调用一个 Center 工具：name 是 tools_search 找到的工具名，input 是按 tool_describe 的参数写的对象。写入类工具会真的修改用户数据；新建时 id 可省略。",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    name: { type: "string" },
+                    input: { type: "object", description: "工具参数" },
+                },
+                required: ["name"],
+            },
+            handler: async (input, { signal }) => {
+                const name = String(input.name ?? "");
+                let args = input.input ?? {};
+                if (typeof args === "string")
+                    try {
+                        args = JSON.parse(args);
+                    }
+                    catch { }
+                if (!args || typeof args !== "object" || Array.isArray(args))
+                    return result("input 要是一个对象。", true);
+                return tools.call(name, args, signal);
+            },
+        },
+        {
+            name: "today_overview",
+            description: "某一天（默认今天）的概况：日程、当天到期的提醒（今天还包括过期未完成的）、去过的地点。回答「今天/明天有什么安排」这类问题先用它。",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    date: {
+                        type: "string",
+                        description: "YYYY-MM-DD，本地日期；省略为今天",
+                    },
+                },
+            },
+            handler: async (input, { signal }) => tools.todayOverview({ date: typeof input.date === "string" ? input.date : undefined }, signal),
+        },
+    ];
+    if (search)
+        served.push({
+            name: "agent_search_query",
+            description: `搜索以前的对话和工具调用（想不起来的事先搜这里）。${search.description}`,
+            inputSchema: compactSchema(search.inputSchema),
+            handler: (input, { signal }) => tools.api.callTool("agent_search_query", input, signal),
+        });
+    return served;
+}