@ai-zen/agents-host 0.0.0-stage → 0.1.0-alpha.0

package/dist/runtime/ScopeRegistry.js

@@ -0,0 +1,259 @@
+/**
+ * `ScopeRegistry` —— workspaceId → `Scope` 的持有者、依赖计数与空闲回收（architecture §4 / PRD D28）。
+ *
+ * 一个 Workspace 一个 Scope（PRD D9）：同一 Workspace 下的多段对话复用同一个 Scope，
+ * 所以这里记的是**依赖计数**而不是「谁在打开它」。计数归零之后不立刻拆，而是起一个
+ * 10 分钟的空闲计时；计时到点才真正销毁 —— 销毁就是 `Scope.dispose()`，它会逆序调用各插件的
+ * `dispose()`，MCP 插件在那里断开它自持的全部连接，于是「Scope 与 MCP 连接同生共死」
+ * 不用第二套代码来表达。
+ *
+ * 计时器只有这一处（architecture §4 A10）：L4 说的「10 分钟无活动」与 D28 说的
+ * 「Scope 空闲 10 分钟」是同一个计时器的两个说法，别处不再另起一份。
+ *
+ * Scope 会被销毁的三种场合（architecture §4）：空闲到点、Workspace 被删、配置变更要重连 MCP。
+ * 三者都收敛到本文件的 `dispose`，区别只在「谁来叫」。
+ *
+ * 时间与 Scope 的创建方式都从构造参数进来：测试用假时钟推进十分钟，接线层提供真实的
+ * SDK 装配（见本文件末尾的 `createWorkspaceScopeFactory`）。
+ */
+import { allInOne, Scope } from "@ai-zen/agents-sdk";
+/** 空闲回收的缺省时长：10 分钟（PRD D28） */
+export const DEFAULT_SCOPE_IDLE_TIMEOUT_MS = 10 * 60 * 1000;
+/**
+ * 真实时钟。无状态，可以放心共享；需要可控时间的地方（测试、或将来把时钟挂到根对象上）
+ * 通过构造参数换成别的实现。
+ */
+export const systemClock = {
+    now: () => Date.now(),
+    setTimeout: (handler, ms) => {
+        const timer = setTimeout(handler, ms);
+        // 空闲回收计时不该单独把进程钉住：真要退出时由根对象按「什么都不欠了」判断
+        timer.unref?.();
+        return () => clearTimeout(timer);
+    },
+};
+/** 一个 Workspace 对应的一条记录 */
+class ScopeEntry {
+    workspaceId;
+    /**
+     * 创建中的 Promise；与 `resolved` 指向同一个 Scope。
+     *
+     * 在构造函数里就把它起来：`acquire` 登记完条目之后才能有人 await 到它，
+     * 而构造函数是同步跑完的，所以不存在「拿到条目但 Promise 还没赋值」的窗口。
+     */
+    created;
+    /** 创建完成后才有值 */
+    resolved;
+    /** 依赖计数：当前有多少个调用方正拿着它 */
+    refs = 1;
+    /** 空闲计时器的取消函数 */
+    cancelIdle;
+    /** 配置变更时它正被持有：等最后一次 release 再销毁（不在别人用着的时候拆能力） */
+    recycleWhenFree = false;
+    /** 正在销毁（幂等） */
+    disposing;
+    constructor(workspaceId, start) {
+        this.workspaceId = workspaceId;
+        this.created = start(this);
+    }
+}
+export class ScopeRegistry {
+    entries = new Map();
+    createScope;
+    idleTimeoutMs;
+    clock;
+    onError;
+    allRecycledListeners = new Set();
+    constructor(options) {
+        this.createScope = options.createScope;
+        this.idleTimeoutMs = options.idleTimeoutMs ?? DEFAULT_SCOPE_IDLE_TIMEOUT_MS;
+        this.clock = options.clock ?? systemClock;
+        this.onError = options.onError;
+    }
+    /**
+     * 借一个 Scope：没有就懒创建，依赖计数 +1，并取消空闲计时。
+     *
+     * 并发的两次 `acquire` 只会创建一次（两个调用方等同一个 Promise）。
+     */
+    acquire(workspaceId) {
+        const existing = this.entries.get(workspaceId);
+        if (existing) {
+            existing.refs += 1;
+            this.cancelIdle(existing);
+            return existing.created;
+        }
+        // 先登记再创建：创建过程中再来的 acquire 会命中这条记录、等同一个 Promise
+        const entry = new ScopeEntry(workspaceId, (created) => this.create(created));
+        this.entries.set(workspaceId, entry);
+        return entry.created;
+    }
+    /** 创建失败时不留下坏条目：下一次 acquire 重新尝试 */
+    async create(entry) {
+        try {
+            const scope = await this.createScope(entry.workspaceId);
+            entry.resolved = scope;
+            return scope;
+        }
+        catch (error) {
+            if (this.entries.get(entry.workspaceId) === entry) {
+                this.entries.delete(entry.workspaceId);
+            }
+            throw error;
+        }
+    }
+    /**
+     * 归还：依赖计数 −1。归零后按两种场合分叉 ——
+     * 平时起 10 分钟空闲计时；若期间发生过配置变更（`recycleAll`）要求它重建，就立刻销毁。
+     */
+    release(workspaceId) {
+        const entry = this.entries.get(workspaceId);
+        if (!entry)
+            return;
+        entry.refs = Math.max(0, entry.refs - 1);
+        if (entry.refs > 0)
+            return;
+        if (entry.recycleWhenFree) {
+            void this.dispose(entry);
+            return;
+        }
+        this.scheduleIdle(entry);
+    }
+    /** 看而不借：已经建好就返回它，没有或还在建就返回 `undefined` */
+    peek(workspaceId) {
+        return this.entries.get(workspaceId)?.resolved;
+    }
+    /** 当前持有几个 Scope（含正在创建的） */
+    size() {
+        return this.entries.size;
+    }
+    /** 当前持有哪几个（配置改动后要报告「回收了哪些项目的 Scope」） */
+    workspaceIds() {
+        return [...this.entries.keys()];
+    }
+    /**
+     * 全部回收 —— 配置改完要重连 MCP 时用（PRD F-E2：改完即生效，靠重连而不是重启）。
+     *
+     * 没人用的立刻销毁；正被持有的打上标记，等最后一次 `release` 再销毁。这样正在跑的那一轮
+     * 不会在写到一半时被抽掉能力，而它结束后下一段对话拿到的已经是按新配置建的 Scope。
+     */
+    async recycleAll() {
+        const entries = [...this.entries.values()];
+        await Promise.all(entries.map((entry) => {
+            if (entry.refs > 0) {
+                entry.recycleWhenFree = true;
+                return Promise.resolve();
+            }
+            return this.dispose(entry);
+        }));
+    }
+    /**
+     * 销毁某一个 Workspace 的 Scope —— Workspace 被删时用。
+     *
+     * 与 `recycleAll` 的区别：这里不等引用归零，因为 Workspace 已经不在了，
+     * 再留着这个 Scope 也没有下一个调用方。
+     */
+    disposeWorkspace(workspaceId) {
+        const entry = this.entries.get(workspaceId);
+        if (!entry)
+            return Promise.resolve();
+        return this.dispose(entry);
+    }
+    /**
+     * 全部回收之后通知根对象（architecture §4：根对象据此判断进程能不能退出）。
+     *
+     * 返回取消订阅的函数。
+     */
+    onAllRecycled(listener) {
+        this.allRecycledListeners.add(listener);
+        return () => {
+            this.allRecycledListeners.delete(listener);
+        };
+    }
+    scheduleIdle(entry) {
+        this.cancelIdle(entry);
+        entry.cancelIdle = this.clock.setTimeout(() => {
+            entry.cancelIdle = undefined;
+            void this.dispose(entry);
+        }, this.idleTimeoutMs);
+    }
+    cancelIdle(entry) {
+        entry.cancelIdle?.();
+        entry.cancelIdle = undefined;
+    }
+    /**
+     * 销毁：先把条目从表里摘掉（之后 acquire 会重建），再等创建完成并 `dispose()`。
+     *
+     * 创建还没完成就得销毁时也要等它 —— 否则刚建出来的 Scope 没人拆，MCP 连接会漏。
+     */
+    dispose(entry) {
+        entry.disposing ??= this.doDispose(entry);
+        return entry.disposing;
+    }
+    async doDispose(entry) {
+        this.cancelIdle(entry);
+        if (this.entries.get(entry.workspaceId) === entry) {
+            this.entries.delete(entry.workspaceId);
+        }
+        let scope;
+        try {
+            scope = await entry.created;
+        }
+        catch {
+            // 创建本来就失败了：没有东西要拆
+            scope = undefined;
+        }
+        if (scope) {
+            try {
+                // Scope.dispose() 逆序调用各插件的 dispose()：MCP 连接在这里断开（D28 同生共死）
+                await scope.dispose();
+            }
+            catch (error) {
+                this.onError?.(error, entry.workspaceId);
+            }
+        }
+        this.notifyAllRecycled();
+    }
+    notifyAllRecycled() {
+        if (this.entries.size > 0)
+            return;
+        for (const listener of [...this.allRecycledListeners]) {
+            try {
+                listener();
+            }
+            catch {
+                // 通知是「可以判退出了」这种事的广播，一个监听器出问题不该影响别的
+            }
+        }
+    }
+}
+/** 取一组目录（固定值与函数的两种写法收在一个地方） */
+function pathsFor(option, cwd) {
+    if (option === undefined)
+        return undefined;
+    return typeof option === "function" ? option(cwd) : option;
+}
+/** 造一个「按 SDK 装能力」的工厂；返回值直接喂给 `ScopeRegistry` 的 `createScope` */
+export function createWorkspaceScopeFactory(options) {
+    return async (workspaceId) => {
+        const workspace = await options.resolveWorkspace(workspaceId);
+        if (!workspace) {
+            throw new Error(`Workspace "${workspaceId}" not found`);
+        }
+        const config = await options.getConfig();
+        const abilityPaths = {
+            skillsPaths: pathsFor(options.skillsPaths, workspace.cwd),
+            toolsPaths: pathsFor(options.toolsPaths, workspace.cwd),
+            subAgentsPaths: pathsFor(options.subAgentsPaths, workspace.cwd),
+            mcpPaths: options.mcpPaths?.(workspace.cwd),
+        };
+        const scope = new Scope({
+            config,
+            cwd: workspace.cwd,
+            agentsDir: options.agentsDir,
+            deps: options.deps,
+        });
+        scope.use(...allInOne(abilityPaths));
+        await scope.init();
+        return scope;
+    };
+}

package/dist/runtime/TransientRunner.d.ts

@@ -0,0 +1,90 @@
+/**
+ * 临时对话（PRD D3 / F-A2 / R1 / R49）：一次请求跑一轮，零痕迹。
+ *
+ * 五件「没有」就是它的定义：**没有 id、不落库、不进对话列表、不可 attach、不推流式事件**。
+ * 所以本文件的结构是刻意做窄的 —— 它没有库、没有事件出口、没有轮次注册表，只有「借一个
+ * Scope、跑一轮、把结果一次交回去」。做不到的事情（落库、推流）在这里不是被判断掉，而是
+ * 根本没有可用的通道。
+ *
+ * ## 为什么单独一个文件而不是给 `ChatRunner` 加开关
+ *
+ * `ChatRunner` 的骨架是「落库 + 推流 + 边流边写」，这三件事对临时对话全是多余的；
+ * 加开关会让每一条写库路径后面都跟一个 `if`，而临时对话在语义上又确实是一次「跑一轮」。
+ * 于是执行逻辑复用 core 的同一套（`agent.send()` 跑完整组内循环），落库与推送这一层换掉。
+ *
+ * ## Scope 的借用口径
+ *
+ * D3 的原话是「只借 Scope，与 Workspace 无关」：临时对话没有 Workspace 身份，它只认一个
+ * `cwd`（相对路径的解析基准）。所以这里不用 `workspaceId` 去借，而是用
+ * `transientScopeKey(cwd)` 这个**按目录**的键（见 {@link transientScopeKey}）：
+ *
+ *   - 同一个目录连着跑两次临时对话，会命中同一个 Scope（借还计数加一减一）；
+ *   - 键里带着 cwd，于是 Scope 的创建方（接线层）能直接从键里解析出目录来装配能力；
+ *   - 回收仍然交给持有那份空闲计时的 `ScopeRegistry`（A10：计时器只有一处），
+ *     本文件不自建缓存、也不自建计时器。
+ */
+import type { AgentNS } from "@ai-zen/agents-core";
+import type { ConfigManager, Scope } from "@ai-zen/agents-sdk";
+import type { Language } from "../i18n/index.js";
+import type { AgentFactory, ChatAgent } from "./ChatRunner.js";
+import type { ConversationTransientParams, ConversationTransientResult } from "../wire/index.js";
+/**
+ * 临时对话借 Scope 用的键：按目录，不按 Workspace。
+ *
+ * 前缀不可省：接线层拿到的键要能区分「这是某个 Workspace」还是「这是某个目录的临时借用」，
+ * 否则一个名叫 `transient:/x` 的 Workspace id 就能和临时借用撞在一起。
+ */
+export declare function transientScopeKey(cwd: string): string;
+/** 从借用键里取回目录；不是临时键时返回 `null`（接线层的 Scope 工厂用它分流） */
+export declare function cwdOfTransientScopeKey(key: string): string | null;
+/** 借 / 还 Scope 的窄接口（结构上 `ScopeRegistry` 满足） */
+export interface TransientScopeBorrower {
+    acquire(key: string): Promise<Scope>;
+    release(key: string): void;
+}
+/** 装配临时对话用的 agent：比 `AgentFactory` 少两个身份字段（它没有对话、没有 Workspace） */
+export type TransientAgentFactory = (context: {
+    scope: Scope;
+    agentId: string;
+    modelId: string | null;
+    /** 这一轮开始前的历史；临时对话永远是空数组 */
+    history: AgentNS.Message[];
+}) => Promise<ChatAgent>;
+/**
+ * 把通用的 `AgentFactory` 适配成临时对话用的那个形状。
+ *
+ * `conversationId` / `workspaceId` 填一个显式占位：工厂里可能把它们写进钩子载荷（日志、
+ * 交接服务的决策），填 `""` 会让日志里出现一个空身份，填占位符至少看得出来这是临时对话。
+ * `thinkingLevel` 恒为 `null`：临时对话没有会话行，也就没有会话级档位，跟助手定义上的那份。
+ */
+export declare function transientAgentFactoryFrom(createAgent: AgentFactory): TransientAgentFactory;
+export interface TransientRunnerDeps {
+    /** 借 Scope 的入口（接的是持有空闲计时的那一个，A10） */
+    scopes: TransientScopeBorrower;
+    createAgent: TransientAgentFactory;
+    /** 配置唯一入口：没点名助手时用它读默认助手（`AppConfig.defaultAgent`） */
+    configManager: ConfigManager;
+    now?: () => number;
+}
+/** 一次临时对话的结果里，`problem` 是「跑完了但这轮不算成功」时的那份说明 */
+export declare class TransientRunner {
+    private readonly scopes;
+    private readonly createAgent;
+    private readonly configManager;
+    private readonly now;
+    constructor(deps: TransientRunnerDeps);
+    /**
+     * 跑一轮，把结果一次交回去。
+     *
+     * `cwd` 必填（契约要求）：临时对话的目录基准不能靠进程工作目录猜 —— 宿主是常驻进程，
+     * 它的 cwd 由启动方式决定，与调用方想的那个目录没有关系。
+     *
+     * 失败走 `HostError`（没有会话可回看，说不出「哪一轮失败了」）；跑完但结局不好
+     * （消息停在 error / aborted）时用 `problem` 说明，`message` 照样带回去。
+     */
+    run(params: ConversationTransientParams, language?: Language): Promise<ConversationTransientResult>;
+    /** 这一轮用哪个助手：入参点名优先，否则配置里的默认助手（没有就说不清用哪个） */
+    private resolveAgentId;
+    /** 执行 / 装配抛出的东西收敛成宿主的错误：临时对话没有会话可回看，只能在这一句里说清 */
+    private toHostError;
+}

package/dist/runtime/TransientRunner.js

@@ -0,0 +1,179 @@
+/**
+ * 临时对话（PRD D3 / F-A2 / R1 / R49）：一次请求跑一轮，零痕迹。
+ *
+ * 五件「没有」就是它的定义：**没有 id、不落库、不进对话列表、不可 attach、不推流式事件**。
+ * 所以本文件的结构是刻意做窄的 —— 它没有库、没有事件出口、没有轮次注册表，只有「借一个
+ * Scope、跑一轮、把结果一次交回去」。做不到的事情（落库、推流）在这里不是被判断掉，而是
+ * 根本没有可用的通道。
+ *
+ * ## 为什么单独一个文件而不是给 `ChatRunner` 加开关
+ *
+ * `ChatRunner` 的骨架是「落库 + 推流 + 边流边写」，这三件事对临时对话全是多余的；
+ * 加开关会让每一条写库路径后面都跟一个 `if`，而临时对话在语义上又确实是一次「跑一轮」。
+ * 于是执行逻辑复用 core 的同一套（`agent.send()` 跑完整组内循环），落库与推送这一层换掉。
+ *
+ * ## Scope 的借用口径
+ *
+ * D3 的原话是「只借 Scope，与 Workspace 无关」：临时对话没有 Workspace 身份，它只认一个
+ * `cwd`（相对路径的解析基准）。所以这里不用 `workspaceId` 去借，而是用
+ * `transientScopeKey(cwd)` 这个**按目录**的键（见 {@link transientScopeKey}）：
+ *
+ *   - 同一个目录连着跑两次临时对话，会命中同一个 Scope（借还计数加一减一）；
+ *   - 键里带着 cwd，于是 Scope 的创建方（接线层）能直接从键里解析出目录来装配能力；
+ *   - 回收仍然交给持有那份空闲计时的 `ScopeRegistry`（A10：计时器只有一处），
+ *     本文件不自建缓存、也不自建计时器。
+ */
+import { AgentNS as AgentNSValue, Message } from "@ai-zen/agents-core";
+import { DEFAULT_LANGUAGE, render } from "../i18n/index.js";
+import { injectedContextOf } from "./ChatRunner.js";
+import { HostError } from "../wire/errors.js";
+/**
+ * 临时对话借 Scope 用的键：按目录，不按 Workspace。
+ *
+ * 前缀不可省：接线层拿到的键要能区分「这是某个 Workspace」还是「这是某个目录的临时借用」，
+ * 否则一个名叫 `transient:/x` 的 Workspace id 就能和临时借用撞在一起。
+ */
+export function transientScopeKey(cwd) {
+    return `transient:${cwd}`;
+}
+/** 从借用键里取回目录；不是临时键时返回 `null`（接线层的 Scope 工厂用它分流） */
+export function cwdOfTransientScopeKey(key) {
+    return key.startsWith("transient:") ? key.slice("transient:".length) : null;
+}
+/** 临时对话在装配时用的身份占位（`AgentFactory` 的入参里有这两项，临时对话没有真值） */
+const TRANSIENT_IDENTITY = "conversation.transient";
+/**
+ * 把通用的 `AgentFactory` 适配成临时对话用的那个形状。
+ *
+ * `conversationId` / `workspaceId` 填一个显式占位：工厂里可能把它们写进钩子载荷（日志、
+ * 交接服务的决策），填 `""` 会让日志里出现一个空身份，填占位符至少看得出来这是临时对话。
+ * `thinkingLevel` 恒为 `null`：临时对话没有会话行，也就没有会话级档位，跟助手定义上的那份。
+ */
+export function transientAgentFactoryFrom(createAgent) {
+    return async (context) => await createAgent({
+        conversationId: TRANSIENT_IDENTITY,
+        workspaceId: TRANSIENT_IDENTITY,
+        agentId: context.agentId,
+        modelId: context.modelId,
+        thinkingLevel: null,
+        scope: context.scope,
+        history: context.history,
+    });
+}
+/** 一次临时对话的结果里，`problem` 是「跑完了但这轮不算成功」时的那份说明 */
+export class TransientRunner {
+    scopes;
+    createAgent;
+    configManager;
+    now;
+    constructor(deps) {
+        this.scopes = deps.scopes;
+        this.createAgent = deps.createAgent;
+        this.configManager = deps.configManager;
+        this.now = deps.now ?? Date.now;
+    }
+    /**
+     * 跑一轮，把结果一次交回去。
+     *
+     * `cwd` 必填（契约要求）：临时对话的目录基准不能靠进程工作目录猜 —— 宿主是常驻进程，
+     * 它的 cwd 由启动方式决定，与调用方想的那个目录没有关系。
+     *
+     * 失败走 `HostError`（没有会话可回看，说不出「哪一轮失败了」）；跑完但结局不好
+     * （消息停在 error / aborted）时用 `problem` 说明，`message` 照样带回去。
+     */
+    async run(params, language = DEFAULT_LANGUAGE) {
+        const cwd = typeof params.cwd === "string" ? params.cwd.trim() : "";
+        if (cwd.length === 0) {
+            throw new HostError("invalid_params", {
+                params: { field: "cwd" },
+                detail: { field: "cwd", reason: "empty" },
+            });
+        }
+        const agentId = await this.resolveAgentId(params.agentId);
+        const scopeKey = transientScopeKey(cwd);
+        const scope = await this.scopes.acquire(scopeKey);
+        try {
+            const agent = await this.createAgent({
+                scope,
+                agentId,
+                modelId: params.modelId ?? null,
+                history: [],
+            });
+            // F-D9：临时对话也一样告诉模型「当前目录是哪儿」。它不落库，所以这条 `hidden` 消息
+            // 只活在内存里（与那段落库的 cwd 消息同一个形状）；目录就是入参里的那个 cwd
+            agent.append(new Message({
+                role: AgentNSValue.Role.User,
+                content: injectedContextOf(cwd, language),
+                status: AgentNSValue.MessageStatus.Completed,
+                hidden: true,
+            }));
+            await agent.send(params.input.content);
+            const message = lastAssistant(agent.messages);
+            if (!message) {
+                throw new HostError("internal", {
+                    messageKey: "error.transientFailed",
+                    params: { reason: "no assistant message came back" },
+                    detail: { cwd, agentId },
+                });
+            }
+            return { message, subagents: [], problem: problemOf(message, language) };
+        }
+        catch (error) {
+            throw this.toHostError(error, cwd, language);
+        }
+        finally {
+            // 与一轮普通对话一致：跑完就还（agent 本身跑完即弃，D28）
+            this.scopes.release(scopeKey);
+        }
+    }
+    /** 这一轮用哪个助手：入参点名优先，否则配置里的默认助手（没有就说不清用哪个） */
+    async resolveAgentId(agentId) {
+        if (typeof agentId === "string" && agentId.trim().length > 0)
+            return agentId.trim();
+        const config = await this.configManager.read();
+        const fallback = config.defaultAgent;
+        if (!fallback) {
+            throw new HostError("config_invalid", {
+                detail: { reason: "no_agent", field: "agentId" },
+            });
+        }
+        return fallback;
+    }
+    /** 执行 / 装配抛出的东西收敛成宿主的错误：临时对话没有会话可回看，只能在这一句里说清 */
+    toHostError(error, cwd, language) {
+        if (HostError.is(error))
+            return error;
+        const reason = error instanceof Error ? error.message : String(error);
+        return new HostError("internal", {
+            messageKey: "error.transientFailed",
+            params: { reason },
+            detail: { cwd, reason, message: render(language, "error.transientFailed", { reason }) },
+            cause: error,
+        });
+    }
+}
+/** 这一轮产出的那条助手消息：取最后一条（工具轮次会有多条，最后一条才是最终答复） */
+function lastAssistant(messages) {
+    for (let index = messages.length - 1; index >= 0; index -= 1) {
+        const message = messages[index];
+        if (message && message.role === AgentNSValue.Role.Assistant)
+            return message;
+    }
+    return null;
+}
+/** 跑完了但结局不好：消息自己的状态就是事实（core 的口径），这里把它翻成一句说明 */
+function problemOf(message, language) {
+    const status = message.status;
+    if (status !== AgentNSValue.MessageStatus.Error && status !== AgentNSValue.MessageStatus.Aborted) {
+        return null;
+    }
+    const reason = status === AgentNSValue.MessageStatus.Aborted ? "aborted" : "error";
+    const params = { reason };
+    return {
+        code: `transient.${reason}`,
+        messageKey: "error.transientFailed",
+        params,
+        message: render(language, "error.transientFailed", params),
+        detail: { status, finishReason: message.finish_reason ?? null },
+    };
+}

package/dist/runtime/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 运行时的出口：Scope 的持有与回收、轮次占位、一轮的执行者。
+ *
+ * 这三块是「比 service 更长寿」的那一层（architecture §3）：ScopeRegistry 与 RunRegistry
+ * 随进程存活，ChatRunner 无状态（每轮现造），三者都由单根注入依赖，不导出任何模块级单例。
+ */
+export { createWorkspaceScopeFactory, DEFAULT_SCOPE_IDLE_TIMEOUT_MS, ScopeRegistry, systemClock, } from "./ScopeRegistry.js";
+export type { Clock, ScopeFactory, ScopeRegistryOptions, WorkspaceScopeFactoryOptions, } from "./ScopeRegistry.js";
+export { RunRegistry } from "./RunRegistry.js";
+export type { RunHandle, RunRegistryOptions, RunSummary, RunsView } from "./RunRegistry.js";
+export { ChatRunner, createSdkAgentFactory, DEFAULT_STREAM_WRITE_INTERVAL_MS, } from "./ChatRunner.js";
+export type { AgentBuildContext, AgentFactory, AttachmentPreparation, AttachmentPreparer, ChatAgent, ChatEventEmitter, ChatRunnerOptions, ChatRunParams, ChatTurn, ConversationStore, HandoffProvider, MessageStore, ReconcileResult, SdkAgentFactoryOptions, TurnSettlement, TurnSettledFacts, } from "./ChatRunner.js";
+export { ConversationDrafts } from "./ConversationDrafts.js";
+export type { ConversationDraftStore } from "./ConversationDrafts.js";

package/dist/runtime/index.js

@@ -0,0 +1,10 @@
+/**
+ * 运行时的出口：Scope 的持有与回收、轮次占位、一轮的执行者。
+ *
+ * 这三块是「比 service 更长寿」的那一层（architecture §3）：ScopeRegistry 与 RunRegistry
+ * 随进程存活，ChatRunner 无状态（每轮现造），三者都由单根注入依赖，不导出任何模块级单例。
+ */
+export { createWorkspaceScopeFactory, DEFAULT_SCOPE_IDLE_TIMEOUT_MS, ScopeRegistry, systemClock, } from "./ScopeRegistry.js";
+export { RunRegistry } from "./RunRegistry.js";
+export { ChatRunner, createSdkAgentFactory, DEFAULT_STREAM_WRITE_INTERVAL_MS, } from "./ChatRunner.js";
+export { ConversationDrafts } from "./ConversationDrafts.js";