@bolloon/bolloon-agent 0.4.33 → 0.5.1

package/dist/ios/sw.js

@@ -6,7 +6,7 @@
  * 现在: 代码类资源 (html/js/css/json) 一律 **network-first** (拿不到网才回退缓存),
  *   缓存名带版本号, activate 时清掉所有旧缓存; 图标等静态资源仍 cache-first。
  */
-const CACHE = 'bolloon-mobile-v1.1';
+const CACHE = 'bolloon-mobile-v0.5.1';
 const SHELL = [
   './mobile.html',
   './mobile.css',

package/dist/ios/task-frame-server.js

@@ -0,0 +1,211 @@
+/**
+ * task-frame-server.ts — bolloon-task/1 任务帧接收端 (P3, 2026-09-21)
+ *
+ * 把 `task-transport` 发来的帧 (request / accept / reject / result) 接到**本机收件箱与台账**:
+ *   · 每个信封都**必须过验签** (`verifyTaskEnvelope` + 帧里带来的公钥), 验不过 → 如实拒, 不落盘;
+ *   · `task_request` 只落**待处理收件箱** (`~/.bolloon/tasks/inbox/`): 不执行、不付款、不自动接单;
+ *   · 状态推进一律走 `task-contract.checkTaskMove` (非法迁移拒绝, 不静默修正);
+ *   · 与 `agent-delegate-server` 同一套 express + JSON 形状 (薄; 不含业务判断)。
+ *
+ * 起法 (E2E / 长跑节点):
+ *   npx tsx scripts/task-frame-node.ts --port 54901 --home /tmp/nodeA
+ *
+ * 安全口径 (如实): 收帧端点**不设身份认证** —— 它就是一个"信箱": 收到的东西一律先验签, 再只能落
+ * 待处理收件箱 (没有任何执行/付款副作用)。要不要接单是**本机用户**用 `bolloon task accept` 决定的事。
+ */
+import express from 'express';
+import { validateTaskRequest, verifyTaskEnvelope, checkTaskMove, } from '../agents/task-contract.js';
+import { verifierFor } from '../agents/local-signer.js';
+import { saveIncomingRequest, readInboxItem, patchInboxItem, readLocalTask, patchLocalTask, saveLocalTask, saveResult, saveBody, listInbox, } from '../agents/task-inbox.js';
+import { parseTaskFrame } from '../agents/task-transport.js';
+/** 校验一帧的信封签名 (帧里带的是公钥 hex; 这是公开材料, 不涉及任何私钥) */
+async function verifyFrame(frame) {
+    const v = verifierFor(frame.signer?.publicKeyHex || '');
+    if (!v)
+        return false;
+    return await verifyTaskEnvelope(frame.envelope, v);
+}
+/** 按 14 态状态机逐步推进 (非法就停, 返回停在哪一步) */
+function advance(state, steps) {
+    let cur = state;
+    const applied = [];
+    for (const to of steps) {
+        if (cur === to)
+            continue;
+        const mv = checkTaskMove(cur, to);
+        if (!mv.ok)
+            return { state: cur, applied, rejected: mv.reason };
+        cur = to;
+        applied.push(to);
+    }
+    return { state: cur, applied };
+}
+/**
+ * 处理一帧 —— 唯一入口 (HTTP / iroh / 测试都走这里, 语义只有一套)。
+ */
+export async function handleTaskFrame(frame, opts = {}) {
+    const home = opts.home;
+    const env = frame.envelope;
+    const verified = await verifyFrame(frame);
+    switch (frame.frame) {
+        case 'task_request': {
+            if (!verified) {
+                return { ok: false, error: 'SIGNATURE_INVALID', detail: '任务请求信封验签不过 (用帧里 signer.publicKeyHex 验的), 不落盘' };
+            }
+            const req = env;
+            const v = validateTaskRequest(req, { now: Date.now() });
+            if (!v.ok) {
+                // 契约层说不行 → 如实拒 (版本/字段/预算/deadline/签名逐条在 issues 里)
+                return { ok: false, error: 'INVALID_REQUEST', detail: v.issues.join('; ').slice(0, 400) };
+            }
+            const saved = saveIncomingRequest(req, {
+                home,
+                requestVerified: true,
+                buyerPublicKeyHex: frame.signer.publicKeyHex,
+                replyTo: frame.replyTo || null,
+            });
+            if (!saved.ok)
+                return { ok: false, error: 'INBOX_WRITE_FAILED', detail: saved.error };
+            const known = !opts.capabilities?.length || opts.capabilities.includes(req.capability);
+            return {
+                ok: true,
+                duplicate: saved.dup,
+                note: saved.dup
+                    ? `同一 requestId 已在收件箱 (幂等: 不重复接受/不重复执行/不重复收费) — ${saved.reason}`
+                    : `已落待处理收件箱 (不执行、不付款、不自动接单)${known ? '' : ` · 本机没有声明能力 '${req.capability}' (接单时会被拒)`}`,
+                facts: { requestId: req.requestId, taskId: req.taskId, state: saved.item?.state ?? 'pending', receivedAt: saved.item?.receivedAt },
+            };
+        }
+        case 'task_accept': {
+            if (!verified)
+                return { ok: false, error: 'SIGNATURE_INVALID', detail: '接受回执验签不过' };
+            const acc = env;
+            const cur = readLocalTask(acc.requestId, home);
+            if (!cur) {
+                // 没有本地台账: 只存回执本身, 并如实标注"没有对应台账"
+                const rec = {
+                    protocol: 'bolloon-task/1',
+                    requestId: acc.requestId,
+                    taskId: acc.taskId,
+                    capability: '',
+                    instruction: '',
+                    buyerDid: '',
+                    providerDid: acc.providerDid,
+                    target: frame.signer.did,
+                    transportKind: 'inbound',
+                    state: 'accepted',
+                    sentAt: frame.sentAt,
+                    updatedAt: Date.now(),
+                    requestSignature: '',
+                    accept: acc,
+                    notes: ['本机没有对应的本地任务台账 (只存了对端回执; 不伪造本地发送记录)'],
+                };
+                saveLocalTask(rec, home);
+                return { ok: true, note: '已存对端接受回执 (本机没有对应的本地台账)', facts: { requestId: acc.requestId, state: 'accepted' } };
+            }
+            const mv = advance(cur.state, ['accepted']);
+            if (mv.rejected) {
+                return { ok: false, error: 'TASK_TRANSITION_REJECTED', detail: `对端回执 accepted 与本机状态 ${cur.state} 不合: ${mv.rejected}` };
+            }
+            patchLocalTask(acc.requestId, { state: mv.state, accept: acc, providerPublicKeyHex: frame.signer.publicKeyHex, notes: [...cur.notes, `收到接受回执 ${new Date(frame.sentAt).toISOString()}`] }, home);
+            const inb = readInboxItem(acc.requestId, home);
+            if (inb)
+                patchInboxItem(acc.requestId, { state: 'accepted', accept: acc, providerPublicKeyHex: frame.signer.publicKeyHex }, home);
+            return { ok: true, note: `接受回执已入库 (state=${mv.state})`, facts: { requestId: acc.requestId, state: mv.state } };
+        }
+        case 'task_reject': {
+            if (!verified)
+                return { ok: false, error: 'SIGNATURE_INVALID', detail: '拒绝回执验签不过' };
+            const rej = env;
+            const cur = readLocalTask(rej.requestId, home);
+            if (!cur) {
+                return { ok: true, note: '收到拒绝对端回执, 本机没有对应台账 (不伪造)', facts: { requestId: rej.requestId, state: 'rejected', reason: rej.reason } };
+            }
+            const mv = advance(cur.state, ['rejected']);
+            if (mv.rejected)
+                return { ok: false, error: 'TASK_TRANSITION_REJECTED', detail: `对端回执 rejected 与本机状态 ${cur.state} 不合: ${mv.rejected}` };
+            patchLocalTask(rej.requestId, { state: mv.state, reject: rej, notes: [...cur.notes, `被拒: ${String(rej.reason).slice(0, 200)}`] }, home);
+            const inb = readInboxItem(rej.requestId, home);
+            if (inb)
+                patchInboxItem(rej.requestId, { state: 'rejected', reject: rej }, home);
+            return { ok: true, note: `拒绝回执已入库 (state=${mv.state})`, facts: { requestId: rej.requestId, state: mv.state, reason: rej.reason } };
+        }
+        case 'task_result': {
+            if (!verified)
+                return { ok: false, error: 'SIGNATURE_INVALID', detail: '结果信封验签不过 (不落地未验签的结果)' };
+            const res = env;
+            // ① 存结果信封 (真实内容哈希/CID + 签名)
+            const w = saveResult(res, home);
+            if (!w.ok)
+                return { ok: false, error: 'RESULT_WRITE_FAILED', detail: w.error };
+            // ② 正文 (若随帧带来): 落**私有一层**, 并用签名里的 contentHash 复核
+            let bodyFacts = { bodyPresent: false };
+            if (typeof frame.body === 'string' && frame.body.length) {
+                const saved = saveBody(res.taskId, frame.body, home);
+                const matches = !!saved.contentHash && !!res.contentHash && saved.contentHash === res.contentHash;
+                bodyFacts = {
+                    bodyPresent: true,
+                    bodyBytes: saved.bytes,
+                    bodyHashMatches: matches,
+                    bodyNote: matches ? '正文哈希与签名里的 contentHash 一致' : '正文哈希与签名里的 contentHash **不一致** (如实记录)',
+                };
+            }
+            // ③ 状态推进: submitted/accepted → running → delivered (逐条过 checkTaskMove)
+            const cur = readLocalTask(res.requestId, home);
+            if (cur) {
+                const mv = advance(cur.state, ['accepted', 'running', 'delivered']);
+                if (mv.rejected)
+                    return { ok: false, error: 'TASK_TRANSITION_REJECTED', detail: `结果回执与本机状态 ${cur.state} 不合: ${mv.rejected}` };
+                patchLocalTask(res.requestId, {
+                    state: mv.state, result: res, resultVerified: verified,
+                    providerPublicKeyHex: frame.signer.publicKeyHex,
+                    notes: [...cur.notes, `收到结果 ${new Date(frame.sentAt).toISOString()} (contentHash=${(res.contentHash || '').slice(0, 12)}…)`],
+                }, home);
+                const inb = readInboxItem(res.requestId, home);
+                if (inb)
+                    patchInboxItem(res.requestId, { state: 'delivered', result: res, resultVerified: verified, providerPublicKeyHex: frame.signer.publicKeyHex }, home);
+                return { ok: true, note: `结果已入库 (state=${mv.state}, 签名验过=${verified})`, facts: { requestId: res.requestId, taskId: res.taskId, state: mv.state, protocolVerified: verified, ...bodyFacts } };
+            }
+            const inb = readInboxItem(res.requestId, home);
+            if (inb) {
+                patchInboxItem(res.requestId, { state: 'delivered', result: res, resultVerified: verified, providerPublicKeyHex: frame.signer.publicKeyHex }, home);
+                return { ok: true, note: `结果已入库到收件箱条目 (state=delivered)`, facts: { requestId: res.requestId, taskId: res.taskId, protocolVerified: verified, ...bodyFacts } };
+            }
+            return { ok: true, note: '结果信封已存, 但本机没有对应的请求/台账 (不伪造状态)', facts: { taskId: res.taskId, protocolVerified: verified, ...bodyFacts } };
+        }
+        default:
+            return { ok: false, error: 'UNKNOWN_FRAME', detail: `未知帧类型: ${String(frame.frame)}` };
+    }
+}
+/** express app: POST /api/task/frame + GET /api/task/health */
+export function createTaskFrameApp(opts = {}) {
+    const app = express();
+    app.use(express.json({ limit: '2mb' }));
+    app.get('/api/task/health', (_req, res) => {
+        res.json({
+            ok: true,
+            schema: 'bolloon-task-frame/1',
+            selfDid: opts.selfDid || null,
+            capabilities: opts.capabilities || [],
+            inboxPending: listInbox(opts.home).filter((i) => i.state === 'pending').length,
+            note: '任务帧端点 (只落待处理收件箱; 不执行、不付款)',
+        });
+    });
+    app.post('/api/task/frame', async (req, res) => {
+        const raw = req.body?.frame;
+        if (!raw)
+            return res.status(400).json({ ok: false, error: 'BAD_FRAME', detail: '缺 frame' });
+        const parsed = parseTaskFrame(typeof raw === 'string' ? raw : JSON.stringify(raw));
+        if (!parsed.ok)
+            return res.status(400).json({ ok: false, error: 'BAD_FRAME', detail: parsed.error });
+        try {
+            const reply = await handleTaskFrame(parsed.frame, opts);
+            // 帧级失败用 200 + ok:false 表达 (与 CLI 信封同一条纪律: 失败也结构化, 不靠 HTTP 状态猜)
+            return res.status(200).json({ ok: reply.ok, ...(reply.duplicate !== undefined ? { duplicate: reply.duplicate } : {}), ...(reply.note ? { note: reply.note } : {}), ...(reply.error ? { error: reply.error } : {}), ...(reply.detail ? { detail: reply.detail } : {}), ...(reply.facts ? { facts: reply.facts } : {}) });
+        }
+        catch (e) {
+            return res.status(500).json({ ok: false, error: 'HANDLER_THREW', detail: String(e?.message || e).slice(0, 300) });
+        }
+    });
+    return app;
+}

package/dist/llm/config-store.js

@@ -6,6 +6,7 @@ import * as fs from 'fs/promises';
 import * as path from 'path';
 import * as os from 'os';
 import * as fsSync from 'fs';
+import { absorbLegacyProviderEntries, ensureProviderRegistryMetadataSource, getProviderRegistryEntry, normalizeCustomProviders, setCustomProviderSnapshot } from './provider-registry.js';
 /** 2026-09-16 (M1): 不再在模块加载时固定 HOME —— 独立宿主/测试注入/长驻进程都走同一个解析 */
 function configDir() {
     const env = process.env.BOLLOON_HOME?.trim();
@@ -256,6 +257,11 @@ class LLMConfigStore {
         return next;
     }
     async initialize() {
+        // 2026-09-26 (P3): 任何一次配置读都顺手把注册表的元数据填充点接上。
+        //   为什么不放模块体: 本模块与注册表之间是循环 import, 模块体的执行时机取决于"谁是入口",
+        //   实测会撞上对方模块 `metadataSources` 的 TDZ (整个进程起不来)。配置路径是所有读模型
+        //   元数据的前置步骤, 放这里既能自动接上, 又不依赖 import 顺序 (详见 provider-registry)。
+        ensureProviderRegistryMetadataSource();
         // 目录变了 (换 HOME / 独立宿主 / 测试注入): 内存缓存作废, 重新读盘
         const dir = configDir();
         const sig = this.fileSignature();
@@ -290,19 +296,46 @@ class LLMConfigStore {
                     loadedConfig.providers[provider] = { ...DEFAULT_PROVIDER_CONFIGS[provider] };
                 }
             }
+            // 2026-09-26 (P3): 自定义供应商在**内存里**规范化 (数组形 → map / 别名 / 从 providers 吸收),
+            //   **不写盘** —— "读一下就把用户文件改了"是另一种意外。写回只发生在显式 add/update/remove。
+            const normCustom = normalizeCustomProviders(loadedConfig.customProviders);
+            const absorbed = absorbLegacyProviderEntries(loadedConfig.providers, normCustom.providers);
+            loadedConfig.customProviders = absorbed.providers;
+            if (normCustom.rejected.length) {
+                console.warn(`[config-store] customProviders 有 ${normCustom.rejected.length} 条被拒: `
+                    + normCustom.rejected.map((r) => `${r.key}(${r.reason})`).join('; '));
+            }
+            // 注册表的同步读口 (元数据填充点/长期任务门) 靠这份快照 —— 配置一读完就刷新, 不留陈旧结论
+            setCustomProviderSnapshot(absorbed.providers);
             // 确保有 activeProvider
             const activeProvider = loadedConfig.activeProvider;
-            if (!activeProvider || !DEFAULT_PROVIDER_CONFIGS[activeProvider]) {
+            if (!activeProvider || !this.isSelectableProvider(activeProvider, loadedConfig)) {
                 loadedConfig.activeProvider = 'ollama';
             }
             this.config = loadedConfig;
         }
         catch {
             this.config = getDefaultConfig();
+            setCustomProviderSnapshot({});
             await this.save();
         }
         this.initialized = true;
     }
+    /**
+     * 这个 provider id 现在**能当 activeProvider** 吗。
+     *
+     * 2026-09-26 (P3) 之前: 只认内置表 → 用户把自定义端点当默认模型时会被**静默改成 ollama**
+     * (旧配置直接失效)。现在: 内置, 或已注册的自定义供应商, 或配置里**真有这一格且写了地址/模型**
+     * (旧的"手写 provider 条目"写法) 都算数; 三者都不是才退到 ollama。
+     */
+    isSelectableProvider(id, cfg) {
+        if (DEFAULT_PROVIDER_CONFIGS[id])
+            return true;
+        if (cfg.customProviders && cfg.customProviders[id])
+            return true;
+        const own = cfg.providers[id];
+        return !!own && (String(own.baseUrl || '').trim().length > 0 || String(own.model || '').trim().length > 0);
+    }
     async save() {
         if (!this.config)
             return;
@@ -341,31 +374,87 @@ class LLMConfigStore {
     }
     async setActiveProvider(provider) {
         await this.initialize();
-        if (!this.config?.providers[provider]) {
+        const hit = this.providerRowFor(String(provider));
+        if (!hit) {
             throw new Error(`Unknown provider: ${provider}`);
         }
-        const providerConfig = this.config.providers[provider];
+        const providerConfig = hit.row;
         if (providerConfig.requiresApiKey && !providerConfig.apiKey) {
             throw new Error(`${provider} requires an API key but none is configured`);
         }
         await this.withWriteLock(async () => {
+            if (!hit.existing)
+                this.config.providers[String(provider)] = hit.row;
             this.config.activeProvider = provider;
             await this.save();
         });
     }
     async updateProvider(provider, updates) {
         await this.initialize();
-        if (!this.config?.providers[provider]) {
+        const hit = this.providerRowFor(String(provider));
+        if (!hit) {
             throw new Error(`Unknown provider: ${provider}`);
         }
         await this.withWriteLock(async () => {
-            this.config.providers[provider] = {
-                ...this.config.providers[provider],
+            this.config.providers[String(provider)] = {
+                ...hit.row,
                 ...updates
             };
             await this.save();
         });
     }
+    /**
+     * 取（必要时**算出**）一个 provider 的配置行。`existing=false` 表示这一行还不存在, 由调用方
+     * 在自己的写锁里落进 map（本方法**不改任何状态** —— 校验失败时就该什么都不发生）。
+     *
+     * 2026-09-26 (P6): 统一入口现在**接受自定义供应商 id** (从注册表校验, 不再只看内置表),
+     * 于是切换时会把 `model/baseUrl/apiKey` 写进 `providers.<自定义 id>` 这一格 —— 而这一格此前
+     * 根本不存在, 旧实现直接 `Unknown provider` 抛错。
+     *
+     * 规矩 (不编默认值):
+     *   · 内置供应商 / 配置里本来就有这一格 → 原样返回 (老行为一字不变);
+     *   · 已注册的**自定义供应商** → 用它的**声明**起手 (地址/模型), 凭据那一格留空等写入 ——
+     *     不拿内置默认去顶;
+     *   · 其余 (既不是内置, 也不在 `customProviders` 里) → `null` (调用方照旧抛 Unknown provider)。
+     */
+    providerRowFor(id) {
+        const rows = this.config?.providers;
+        if (!rows)
+            return null;
+        if (rows[id])
+            return { row: rows[id], existing: true };
+        const spec = this.config?.customProviders?.[id];
+        if (!spec) {
+            // 2026-09-27 (目录驱动): **目录里的家**也走这条 —— 新家只要在目录里就能切进来 (不改代码)。
+            //   起手行只放目录**声明过的**东西: 基址 = 目录里的 api (目录没给就是空串, 让校验层如实报
+            //   "需自定义 baseUrl"); 模型留空 (公开目录没有"默认模型"这回事, 不许抓一个凑数);
+            //   凭据那一格留空, 等写入或等环境变量 (目录只给环境变量**名**)。
+            const catEntry = getProviderRegistryEntry(id);
+            if (!catEntry || catEntry.kind !== 'catalog')
+                return null;
+            return {
+                existing: false,
+                row: {
+                    enabled: true,
+                    apiKey: '',
+                    baseUrl: catEntry.defaultBaseUrl,
+                    model: '',
+                    requiresApiKey: catEntry.requiresApiKey !== false,
+                },
+            };
+        }
+        const entry = getProviderRegistryEntry(id);
+        return {
+            existing: false,
+            row: {
+                enabled: true,
+                apiKey: '',
+                baseUrl: spec.baseUrl,
+                model: String(spec.model || spec.models?.[0] || ''),
+                requiresApiKey: entry ? entry.requiresApiKey : true,
+            },
+        };
+    }
     async testProvider(provider) {
         await this.initialize();
         const config = this.config?.providers[provider];
@@ -494,6 +583,57 @@ class LLMConfigStore {
     getAllProviderInfo() {
         return PROVIDER_INFO;
     }
+    /**
+     * 2026-09-26: 丢弃内存缓存, 下一次 initialize() 强制重新读盘。
+     * 用途: 统一入口在做"读出→改写→写回"时, 必须在拿到跨进程锁之后重读,
+     * 否则两个进程各自拿旧内存值写回, 后写的会把先写的那份改动覆盖掉。
+     * 回滚路径同样需要它 (把文件还原后, 内存里的那一份也得跟着回来)。
+     */
+    invalidate() {
+        this.initialized = false;
+        this.config = null;
+        this.loadedDir = null;
+        this.loadedSig = null;
+    }
+    /** 配置文件绝对路径 (统一入口/锁/迁移都从这里取, 不再各自拼) */
+    configFilePath() {
+        return CONFIG_PATH;
+    }
+    /** 旧文件名 (迁移输入) */
+    legacyConfigFilePath() {
+        return LEGACY_CONFIG_PATH;
+    }
+    /**
+     * 现在在册的自定义供应商 (规范化后的内存视图; 读盘由 `initialize()` 保证已经发生过)。
+     * 凭据原样在里面 —— 调用方展示前必须走脱敏 (`custom-provider-store.redactCustomProviders`)。
+     */
+    async getCustomProviders() {
+        await this.initialize();
+        return { ...(this.config?.customProviders || {}) };
+    }
+    /**
+     * 覆盖 `customProviders` 一格 (唯一写口)。
+     *
+     * 只动这一格 —— 内置 `providers` / `activeProvider` 一个字节都不碰; 于是"加个自定义供应商"
+     * 不会顺手把用户在别处刚改的模型选择覆盖掉。写前调用方负责 `invalidate()` + `initialize()`
+     * (拿到跨进程锁之后重读), 否则两个进程各自拿旧内存值写回。
+     */
+    async setCustomProviders(map) {
+        await this.initialize();
+        const norm = normalizeCustomProviders(map && typeof map === 'object' ? map : {});
+        if (norm.rejected.length) {
+            throw new Error(`customProviders 规范化失败: ${norm.rejected.map((r) => `${r.key}(${r.reason})`).join('; ')}`);
+        }
+        await this.withWriteLock(async () => {
+            this.config.customProviders = norm.providers;
+            setCustomProviderSnapshot(norm.providers);
+            await this.save();
+        });
+    }
+    /** 配置目录 (锁文件、session 绑定都落在这里) */
+    configDirPath() {
+        return configDir();
+    }
 }
 export const llmConfigStore = new LLMConfigStore();
 export function getPiSDKConfig() {