weifuwu 0.94.0 → 0.95.0

package/dist/client/vdom/middlewares/api.d.ts

@@ -1,46 +0,0 @@
-/**
- * vdom middlewares — api（请求客户端——ctx.api 注入面）
- *
- * 设计：fetch 封装——JSON 序列化/解析——超时（AbortController）——
- * ApiError（status）——onError 钩子——经注入（零全局直接访问——
- * 测试 mock fetch）。
- *
- * W2（VDOM-STREAM-FIX-PLAN）——401 单飞刷新流化（G13 修复的窗口堵死）：
- * - `refreshTrigger$`（Subject）：401 且 token 未变 → 触发事件
- * - `exhaustMap`：单飞刷新（刷新中后续触发被丢弃——**并发 401 只刷一次**）
- *   ——原 G13 快照比对堵不住「同拍双 401 在刷新完成前都走 onUnauthorized
- *   分支」的窗口（两者 tokenNow 都未变）；单飞 = 结构上不可能双刷
- * - `refreshDone$`：刷新结果广播（true=成功可重试）——等待者 take(1)
- * - 旋转 token 双刷新竞态（走查实证）：exhaustMap 内建 single-flight 根治
- */
-export interface ApiOptions {
-    /** 基础路径（前缀拼接） */
-    baseUrl?: string;
-    /** 静态或动态头（动态：每次请求调用） */
-    headers?: Record<string, string> | (() => Record<string, string>);
-    /** 超时（ms——默认 15000） */
-    timeout?: number;
-    /** 错误钩子（请求失败——不吞错误） */
-    onError?: (err: ApiError) => void;
-    /** 自动鉴权 token（函数/静态——注入 Authorization: Bearer 头） */
-    token?: string | (() => string | null);
-    /** 401 钩子（返回 true = 已刷新可重试——false/undefined = 走错误路径） */
-    onUnauthorized?: () => Promise<boolean> | boolean;
-}
-export declare class ApiError extends Error {
-    status?: number;
-    constructor(message: string, status?: number);
-}
-export interface ApiRequestOptions {
-    headers?: Record<string, string>;
-}
-export interface ApiClient {
-    get<T>(url: string, opts?: ApiRequestOptions): Promise<T>;
-    post<T>(url: string, body?: unknown, opts?: ApiRequestOptions): Promise<T>;
-    put<T>(url: string, body?: unknown, opts?: ApiRequestOptions): Promise<T>;
-    delete<T>(url: string, opts?: ApiRequestOptions): Promise<T>;
-    patch<T>(url: string, body?: unknown, opts?: ApiRequestOptions): Promise<T>;
-    request<T>(method: string, url: string, body?: unknown, opts?: ApiRequestOptions): Promise<T>;
-}
-/** 创建 api 客户端（每 serve 实例独立——测试隔离） */
-export declare function api(opts?: ApiOptions): ApiClient;

package/dist/client/vdom/middlewares/auth-i18n.d.ts

@@ -1,73 +0,0 @@
-import { type Observable } from '../observable/index.ts';
-/**
- * vdom middlewares — auth/i18n（ctx.auth 令牌管理 + ctx.i18n 国际化）
- *
- * - auth：token 管理（get/set/headers 注入——logout——storage 经注入——
- *   默认内存——零全局 localStorage 直接访问）
- * - i18n：locale/messages——t(key, params) 插值——setLocale 切换
- */
-/** 存储适配（auth token 持久化——默认内存——生产可传 localStorage 适配） */
-export interface StorageAdapter {
-    get(key: string): string | null;
-    set(key: string, value: string): void;
-}
-export interface AuthClient {
-    getToken(): string | null;
-    setToken(token: string | null): void;
-    /** 请求头注入（Authorization: Bearer） */
-    headers(): Record<string, string>;
-    logout(): void;
-    /** 当前用户（userKey 持久化——login/setUser 写——未登录 null） */
-    user: unknown;
-    /** 是否已登录（token 存在） */
-    isLoggedIn: boolean;
-    /** **token 值流（波次 7——login/setToken/logout 触发——BehaviorSubject
-     *  语义——订阅即收当前 token——应用层监听登录态变化）** */
-    token$: Observable<string | null>;
-    /** 登录（token/user/refreshToken 持久化——onAuth 钩子接线） */
-    login(token: string, user: unknown, refreshToken?: string | null): void;
-    /** 更新用户信息（原地写——userKey 持久化） */
-    setUser(user: unknown): void;
-    /** 刷新 token（onRefresh 钩子——成功重写 token 返回 true） */
-    refresh(): Promise<boolean>;
-}
-export interface AuthOptions {
-    storage?: StorageAdapter;
-    /** 存储 key（默认 'wf-auth-token'） */
-    key?: string;
-    /** token 前缀（默认 'Bearer'） */
-    scheme?: string;
-    /** token 存储 key（默认取 key） */
-    tokenKey?: string;
-    /** 用户存储 key（默认 'wf-auth-user'） */
-    userKey?: string;
-    /** refresh token 存储 key（默认 'wf-auth-refresh'） */
-    refreshTokenKey?: string;
-    /** 登录钩子（外部接线——如 api 刷新链） */
-    onAuth?: (auth: AuthClient) => void;
-    /** 刷新钩子（refresh() 调用——成功返回 true） */
-    onRefresh?: () => Promise<boolean> | boolean;
-}
-/** 创建 auth 客户端（每 serve 实例独立） */
-export declare function auth(opts?: AuthOptions): AuthClient;
-/** 消息字典（locale → key → 文本） */
-export type Messages = Record<string, Record<string, string>>;
-export interface I18nOptions {
-    locale?: string;
-    /** 消息字典（可选——仅 locale 切换场景可省——t 缺失返回 key） */
-    messages?: Messages;
-}
-export interface I18nState {
-    locale: string;
-    setLocale(locale: string): void;
-    /** **locale 值流（波次 7——setLocale 事件源——Subject 语义——无自动
-     *  渲染纪律保持：订阅方自行决定渲染时机）** */
-    locale$: Observable<string>;
-    /** 取文本（{name} 插值——缺失 key 返回 key 本身——不静默） */
-    t(key: string, params?: Record<string, unknown>): string;
-    /** 组件文案面（ui-dom 兼容——SheetGrid/SlideCanvas 读组件级文案——
-     *  可选——无注入时 undefined） */
-    components?: Record<string, Record<string, string>>;
-}
-/** 创建 i18n（locale/messages——t 插值） */
-export declare function i18n(opts?: I18nOptions): I18nState;

package/dist/client/vdom/middlewares/ws.d.ts

@@ -1,77 +0,0 @@
-import { type Observable } from '../observable/index.ts';
-/**
- * vdom middlewares — ws（WebSocket 客户端——ctx.ws 注入面）
- *
- * 设计：WebSocket 构造经 opts 注入（jsdom 无 WS——测试 mock——
- * 零全局直接访问）；onMessage 订阅（返回退订）；unmount 关闭。
- *
- * 可靠性面（2026-08——A2 消息断线补拉的地基）：
- * - autoReconnect：断线自动重连（指数退避 1s/2s/4s...封顶 maxMs——
- *   onopen 重置计数）——**close() 手动关闭不重连**（主动语义）
- * - onStatusChange：状态翻转通知（onopen/onclose 触发——订阅即回放当前
- *   态——应用层感知「重连成功 → 补拉数据」）
- * - **心跳看门狗（2026-08——网络硬断静默挂起根因歼灭）**：浏览器对
- *   网络断（WiFi 闪断/离线仿真）**不触发 close/error**——socket 静默
- *   挂起——onclose 永不执行 → 重连调度永不启动——断线期间消息永远丢失
- *   （chat 断线补拉失效实证——CDP setOffline 场景）。修复：onopen 后
- *   周期发 ping，任何入站（pong/消息）刷新活性；超时未活性 → 强制
- *   close → onclose → setConnected(false) + 重连调度（应用层感知断线
- *   → 补拉）。此外 onerror 也走 close 路径（error→onclose 链）。
- */
-export interface WsReconnectOptions {
-    /** 重连基延迟（ms——指数退避起点——默认 1000） */
-    baseMs?: number;
-    /** 重连间隔上限（ms——默认 30000） */
-    maxMs?: number;
-}
-export interface WsPingOptions {
-    /** 心跳间隔（ms——默认 15000） */
-    intervalMs?: number;
-    /** 活性超时（ms——超过无入站即判死——默认 35000） */
-    timeoutMs?: number;
-    /** 心跳载荷（默认 { type: 'ping' }——标准 WS 协议） */
-    payload?: () => unknown;
-}
-export interface WsOptions {
-    /** WebSocket 构造器（注入——测试 mock——默认全局 WebSocket） */
-    WebSocketCtor?: new (url: string) => WsLike;
-    /** 默认连接 URL（未传时 connect(url) 必需） */
-    url?: string;
-    /** 断线自动重连（指数退避——默认关——显式开启不突改既有行为） */
-    autoReconnect?: boolean | WsReconnectOptions;
-    /** 心跳看门狗（网络硬断静默挂起检测——默认关） */
-    ping?: WsPingOptions;
-}
-/** 最小 WS 形状（兼容浏览器 WebSocket 与测试 mock） */
-export interface WsLike {
-    send(data: string): void;
-    close(): void;
-    /** 连接状态（浏览器 WebSocket 标准——CONNECTING=0 OPEN=1——Mock 需实现） */
-    readyState: number;
-    onmessage: ((e: {
-        data: unknown;
-    }) => void) | null;
-    onopen: (() => void) | null;
-    onclose: (() => void) | null;
-    onerror: ((e: unknown) => void) | null;
-}
-export interface WsClient {
-    /** 连接（切换 URL——旧连接关闭——未传用 opts.url） */
-    connect(url?: string): void;
-    /** 连接状态（onopen 置 true——onclose 置 false） */
-    isConnected: boolean;
-    /** 发送（JSON 序列化） */
-    send(data: unknown): void;
-    /** 消息订阅（返回退订） */
-    onMessage(cb: (data: unknown) => void): () => void;
-    /** 状态翻转订阅（订阅时回放当前态——onopen/onclose 触发——返回退订） */
-    onStatusChange(cb: (connected: boolean) => void): () => void;
-    /** **消息流视图（波次 7——onMessage 同源——可 pipe/takeUntil）** */
-    messages$: Observable<unknown>;
-    /** **状态流视图（波次 7——BehaviorSubject 语义——订阅即回放当前态）** */
-    status$: Observable<boolean>;
-    /** 关闭（主动——不触发自动重连） */
-    close(): void;
-}
-/** 创建 ws 客户端（每 serve 实例独立） */
-export declare function ws(opts?: WsOptions): WsClient;

package/dist/client/vdom/testing.d.ts

@@ -1,46 +0,0 @@
-/**
- * vdom — 测试不变量 helper（覆盖标准 §1.2/§2——禁止手抄/禁止只查存在性）
- *
- * 每个渲染测试强制断言的不变量：
- * - **同构**：childNodes.length === 期望形态序列长度（占位锚 ↔ 真实节点
- *   互换长度恒定——塌缩即 bug）
- * - **位置**：数组第 i 项 ⟷ childNodes 第 i 个（位置错位即 bug）
- * - **引用**：同 key/同位置复用项 DOM 节点引用不变（重建即 bug）
- * - **资源**：remove/done 后事件表/ref 表/portal 容器清理（残留即 bug）
- */
-export type Shape = 'element' | 'text' | 'hole' | 'comment';
-/** 节点形态判定（跨 realm 安全——nodeType 而非 instanceof） */
-export declare function shapeOf(node: Node): Shape;
-/**
- * 同构断言：container.childNodes 与期望形态序列**逐位一致**
- * （长度 + 位置 + 类型）——childNodes.length 恒等于序列长度
- */
-export declare function assertIsomorphic(container: HTMLElement, expectShapes: Shape[], msg?: string): void;
-/** 位置断言：第 i 个 childNode 是期望类型（边界位置——位置 0/末尾重点） */
-export declare function assertSlot(container: HTMLElement, index: number, expect: Shape, msg?: string): void;
-/** 引用断言：复用项 DOM 节点引用不变（重建即 bug——焦点/状态丢失） */
-export declare function assertKept<T extends Node>(container: HTMLElement, selector: string, before: T, msg?: string): asserts before is T;
-/** 往返断言：状态切换后回到原 DOM 形态（可逆性——状态不漂移） */
-export declare function assertRoundTrip(toggle: () => void, assertOff: () => void, assertOn: () => void, waitFor: (fn: () => boolean) => Promise<void>, rounds?: number, msg?: string): Promise<void>;
-import type { VNode } from './core/vnode.ts';
-import type { UIContext } from './context/UIContext.ts';
-/** 两阶段组件渲染到 VNode 层（只一层——子组件保留函数引用——断言 type） */
-export declare function renderVNode(Comp: any, props: Record<string, any>, ctx: UIContext): Promise<VNode | null>;
-/** 同实例渲染器（mount 一次——re-render 保留内部 let 状态） */
-export declare function mountComponent(Comp: any, props: Record<string, any>, ctx: UIContext): Promise<() => VNode | null>;
-/** 深度遍历 VNode 树（含嵌套数组 children） */
-export declare function walkVNode(vnode: unknown, visit: (n: any) => void): void;
-/** 按谓词查询第一个匹配节点（深度优先） */
-export declare function findVNode(vnode: unknown, pred: (n: any) => boolean): any;
-/** 收集所有 class token 精确匹配的节点（split(' ')——includes 误匹配前缀） */
-export declare function findByClass(vnode: unknown, cls: string): any[];
-/** mount：vnode → 全量命令流 → apply（容器内渲染——等挂载完成） */
-export declare function mountToDom(container: Element, vnode: any, _ctx: any): Promise<void>;
-/** patch：prev → next diff 精准（同树 patch——容器缓存 registry） */
-export declare function patchToDom(container: Element, _node: Node | null, prev: any, next: any, _ctx: any): Promise<any>;
-/** 卸载清理（applier.dispose——移除 document 事件监听——测试防泄漏——
- *  多 mount 残留监听导致 pointerup 等触发旧实例（拖拽多次 commit——
- *  真实事故）） */
-export declare function disposeToDom(container: Element): void;
-/** build（无调用方语义——兼容签名：返回 vnode 本身） */
-export declare function buildToDom(vnode: any, _ctx: any): Promise<any>;

package/dist/server/ai/assemble.d.ts

@@ -1,19 +0,0 @@
-/**
- * weifuwu AI — 组装层：provider（AiClient）→ 中间件模块（AiClientModule）
- *
- * 参考 postgres（client.ts 工厂组装 mw）——ai() 与 MemoryAi 共用：
- * 中间件注入（ctx.ai）+ 能力方法挂载（agent 引擎套 provider）。
- */
-import type { Context, Middleware } from '../../server/types.ts';
-import type { AiClient } from './client.ts';
-import type { AIInterface } from './contracts.ts';
-export interface AiInjected {
-    ai: AIInterface;
-}
-/** 模块 = 中间件 + 客户端（queue 式混合：app.use(a) + worker 直接 a.chat()）。
- *  实现 AIInterface 契约（contracts.ts 单一来源）；streamStep 为 agent 内部细节（不在契约） */
-export interface AiClientModule extends Middleware<Context, Context & AiInjected>, AIInterface {
-    /** 内部：单轮 LLM 流式 → emit 事件 + 聚合结果（agent 引擎用——不在契约 AIInterface） */
-    streamStep: AiClient['streamStep'];
-}
-export declare function assemble(client: AiClient): AiClientModule;

package/dist/server/ai/contracts.d.ts

@@ -1,121 +0,0 @@
-/**
- * weifuwu/ai — AI 契约层（接口与实现分离）
- *
- * 消费方（ctx.ai / 业务模块）只依赖 Ai 接口，
- * 自研引擎（src/ai/index.ts 中间件工厂 + client.ts HTTP 客户端 + agent.ts 工具循环）实现它。
- *
- * 配置优先级：显式参数 > env > 默认值。
- *   apiKey:      DEEPSEEK_API_KEY
- *   baseUrl:     DEEPSEEK_BASE_URL      → 'https://api.deepseek.com/v1'
- *   defaultModel: DEEPSEEK_MODEL        → 'deepseek-v4-flash'
- *
- * 裁剪声明（诚实裁剪——CS-05）：
- *   ✅ 对话/流式/SSE 协议（§1）/ agent 工具循环 + HITL 审批 / embedding（可选 provider）
- *   ❌ 附件、多模态、函数调用中间态缓存（agent 状态由调用方持有）
- */
-import type { ChatParams, WfApprovalResponse } from './types.ts';
-import type { ChatResponse } from './client.ts';
-import type { WfEmitter } from './sse.ts';
-import type { AgentConfig, AgentRunner } from './agent.ts';
-/** agent 循环挂起等待审批的请求（协议 §4.5） */
-export interface ApprovalRequest {
-    id: string;
-    toolCallId: string;
-    name: string;
-    args: Record<string, unknown>;
-}
-/**
- * AI 客户端（ctx.ai）：对话 / 流式 / SSE / agent / HITL / embedding / 多模态。
- * 模块即中间件（app.use(a) 注入 ctx.ai），worker/后台场景同一实例直接调用。
- * 参考 PostgresInterface 分层（src/server/postgres/types.ts）：接口与实现分离——
- * 实现见 client.ts（OpenAI 兼容 provider）/ memory.ts（MemoryAi——契约直实现）。
- */
-export interface AIInterface {
-    /** 非流式对话（worker/后台场景） */
-    chat(params: ChatParams, options?: {
-        signal?: AbortSignal;
-    }): Promise<ChatResponse>;
-    /** 流式对话 → SSE Response（协议 §1.1），路由直接 return */
-    stream(params: ChatParams, options?: {
-        signal?: AbortSignal;
-        traceId?: string;
-    }): Response;
-    /** 低层：app 完全控制事件序列（自定义 x:* 事件、HITL 等） */
-    sse(run: (emit: WfEmitter) => Promise<void> | void, options?: {
-        signal?: AbortSignal;
-    }): Response;
-    /** 响应一个挂起的 HITL 审批（协议 §4.5，app 的 POST /approve 路由调用） */
-    approve(response: WfApprovalResponse): boolean;
-    /** 内部：agent 循环挂起等待审批（A4：signal 取消也收尾——挂起不阻塞取消） */
-    waitApproval(req: ApprovalRequest, emit: WfEmitter, timeoutMs?: number, signal?: AbortSignal): Promise<WfApprovalResponse>;
-    /** 单文本嵌入（知识库/语义检索；需 ai({ embedding }) 配置，未配抛 AiError） */
-    embed(text: string): Promise<number[]>;
-    /** 批量文本嵌入（按输入顺序返回） */
-    embedMany(texts: string[]): Promise<number[][]>;
-    /** agent 引擎（工具循环 + HITL 审批） */
-    agent(config: AgentConfig): AgentRunner;
-    /** 文生图（同步——返回图片地址或 data URL——保存/入库由调用方编排） */
-    generateImage(req: ImageGenRequest, options?: {
-        signal?: AbortSignal;
-    }): Promise<ImageGenResult>;
-    /** 文生视频（异步提交——返回任务 ID——provider 状态由 videoStatus 查询） */
-    createVideoTask(req: VideoGenRequest, options?: {
-        signal?: AbortSignal;
-    }): Promise<{
-        taskId: string;
-    }>;
-    /** 视频任务状态（编排层轮询——完成返回 url） */
-    videoStatus(taskId: string, options?: {
-        signal?: AbortSignal;
-    }): Promise<VideoGenStatus>;
-    close(): Promise<void>;
-}
-/** 兼容别名（2027-10 重构：Ai → AIInterface 正名——旧名保留防消费端破坏） */
-export type Ai = AIInterface;
-export interface ImageGenRequest {
-    prompt: string;
-    /** "宽*高"——默认 provider 决定（OpenAI 兼容：1024*1024；MemoryAi：忽略） */
-    size?: string;
-    /** 模型名（默认 provider 决定） */
-    model?: string;
-}
-export interface ImageGenResult {
-    /** 图片地址（provider 返回——HTTP URL） */
-    url?: string;
-    /** base64 data URL（MemoryAi 占位图——1×1 透明 PNG） */
-    dataUrl?: string;
-    /** MIME 类型（默认 image/png） */
-    mime?: string;
-}
-export interface VideoGenRequest {
-    prompt: string;
-    /** 时长秒（3-15——默认 provider 决定） */
-    duration?: number;
-    /** 宽高比（16:9/9:16/1:1……） */
-    ratio?: string;
-    /** 分辨率（480P/720P/1080P） */
-    resolution?: string;
-    /** 水印（默认 true——对齐 agent-platform 原工具行为） */
-    watermark?: boolean;
-    /** 模型名 */
-    model?: string;
-}
-export type VideoGenStatus = {
-    status: 'pending' | 'running';
-    url?: undefined;
-    error?: undefined;
-} | {
-    status: 'done';
-    url: string;
-    error?: undefined;
-} | {
-    status: 'failed';
-    error: string;
-    url?: undefined;
-};
-declare module '../../server/types.ts' {
-    interface Context {
-        /** 注入模块本身（含 agent / approve）——worker 场景直接 a.chat() */
-        ai?: AIInterface;
-    }
-}

package/dist/server/ai/index.d.ts

@@ -1,27 +0,0 @@
-/**
- * weifuwu AI — 中间件工厂（provider 选择器）
- *
- * ```ts
- * import { ai, OpenAi, MemoryAi } from 'weifuwu'
- *
- * const a = ai()                          // 选择器：默认 OpenAi（DEEPSEEK_* env）
- * const b = new OpenAi({ apiKey })        // 正门构造（OpenAI 兼容——deepseek/dashscope/mock）
- * const c = new MemoryAi({ onChat })      // 内存确定性（测试/离线）
- * app.use(a)                              // → ctx.ai.chat / ctx.ai.stream / ...
- * ```
- *
- * provider 与模块组装分家（参考 postgres 契约/工厂/引擎分层）：
- *   contracts.ts（AIInterface 契约）/ client+multimodal（OpenAI provider 引擎）/
- *   memory.ts（MemoryAi）/ openai.ts + assemble.ts（模块构造）/ 本文件（选择器）
- */
-export type { Ai, AIInterface, ApprovalRequest } from './contracts.ts';
-export type { ImageGenRequest, ImageGenResult, VideoGenRequest, VideoGenStatus } from './contracts.ts';
-export { OpenAi, type OpenAiOptions } from './openai.ts';
-export { MemoryAi, createMemoryAi, type MemoryAiOptions } from './memory.ts';
-export type { AiClientModule, AiInjected } from './assemble.ts';
-export type { AiEmbeddingOptions } from './client.ts';
-export type { AgentRunResult, AgentStep, AgentTool, AgentConfig, AgentRunner, ToolContext } from './agent.ts';
-export type { WfStreamEvent, WfMessageStart, WfToken, WfUsage, WfDone, WfError, WfErrorCode, WfToolCall, WfToolResult, WfToolProgress, WfStep, WfApprovalRequest, WfApprovalResponse, WfApprovalDecision, ChatMessage, ChatParams, MessageRole, ToolCall, ToolDefinition, } from './types.ts';
-export type { WfEmitter } from './sse.ts';
-export { AiError } from './client.ts';
-export type { AiClient, ChatResponse } from './client.ts';

package/dist/server/ai/types.d.ts

@@ -1,156 +0,0 @@
-/**
- * weifuwu AI 协议共享类型 —— 与 docs/server.md 规范一一对应
- *
- * 纯类型，零运行时成本。两端同源：
- *   - 后端：从 weifuwu 主包导入（src/index.ts re-export）
- *   - 前端：从 weifuwu/client/vdom 导入（src/client/vdom/index.ts re-export）
- *
- * 修改本文件 = 修改协议，需同步更新 docs/server.md。
- */
-export interface WfMessageStart {
-    id: string;
-}
-export interface WfToken {
-    /** 增量文本，前端直接 append */
-    text: string;
-}
-export interface WfUsage {
-    prompt_tokens: number;
-    completion_tokens: number;
-    total_tokens?: number;
-}
-export interface WfDone {
-    content: string;
-    usage?: WfUsage;
-    /** thinking 模式的推理过程（reasoning_content），收尾时一次性下发（v1 不进流式） */
-    reasoning?: string;
-}
-export type WfErrorCode = 'auth_failed' | 'rate_limited' | 'context_length' | 'timeout' | 'provider_error' | 'invalid_request' | 'unsupported' | 'aborted';
-export interface WfError {
-    code: WfErrorCode;
-    message: string;
-}
-export interface WfToolCall {
-    /** 工具调用 id（provider 给 / 后端生成），聚合完成后才发 */
-    id: string;
-    /** 工具名（app 定义的业务语义，协议不解释） */
-    name: string;
-    /** 完整参数 */
-    args: Record<string, unknown>;
-}
-export interface WfToolResult {
-    id: string;
-    ok: boolean;
-    output?: unknown;
-    /** ok:false 时：rejected（人工拒绝）/ timeout（审批超时）/ tool_error / app 自定义 */
-    error?: {
-        code: string;
-        message: string;
-    };
-}
-export interface WfToolProgress {
-    toolCallId: string;
-    step: number;
-    total: number;
-    message?: string;
-    status: 'running' | 'error' | 'done';
-}
-export interface WfStep {
-    type: 'llm' | 'tool';
-    content?: string;
-    toolCallId?: string;
-    name?: string;
-    /** 工具调用参数（JSON 字符串——前端工具卡片展示） */
-    args?: string;
-}
-export interface WfApprovalRequest {
-    id: string;
-    toolCallId: string;
-    name: string;
-    args: Record<string, unknown>;
-    reason?: string;
-    /** 审批超时；到期按 rejected 处理（error.code: 'timeout'） */
-    expiresAt?: number;
-}
-export type WfApprovalDecision = 'approved' | 'rejected' | 'modified';
-/** 上行 POST 载荷（非 SSE 事件） */
-export interface WfApprovalResponse {
-    id: string;
-    decision: WfApprovalDecision;
-    /** 仅 modified：按修改后的参数执行 */
-    modifiedArgs?: Record<string, unknown>;
-    /** 进 agent 上下文 */
-    note?: string;
-}
-/** 所有框架事件联合类型（前端 switch 收窄用） */
-export type WfStreamEvent = {
-    name: 'wf:message_start';
-    data: WfMessageStart;
-} | {
-    name: 'wf:token';
-    data: WfToken;
-} | {
-    name: 'wf:usage';
-    data: WfUsage;
-} | {
-    name: 'wf:done';
-    data: WfDone;
-} | {
-    name: 'wf:error';
-    data: WfError;
-} | {
-    name: 'wf:tool_call';
-    data: WfToolCall;
-} | {
-    name: 'wf:tool_result';
-    data: WfToolResult;
-} | {
-    name: 'wf:tool_progress';
-    data: WfToolProgress;
-} | {
-    name: 'wf:step';
-    data: WfStep;
-} | {
-    name: 'wf:approval_request';
-    data: WfApprovalRequest;
-};
-export type MessageRole = 'system' | 'user' | 'assistant' | 'tool';
-export interface ChatMessage {
-    role: MessageRole;
-    content: string;
-    /** DeepSeek thinking mode：前一轮的 reasoning_content 必须回传 */
-    reasoning_content?: string;
-    tool_call_id?: string;
-    tool_calls?: ToolCall[];
-    name?: string;
-}
-export interface ToolCall {
-    id: string;
-    type: 'function';
-    function: {
-        name: string;
-        arguments: string;
-    };
-}
-export interface ToolDefinition {
-    type: 'function';
-    function: {
-        name: string;
-        description: string;
-        parameters: Record<string, unknown>;
-    };
-}
-export interface ChatParams {
-    model?: string;
-    /** BYOK：per-call 覆盖全局 apiKey（租户自带模型 Key——商业化 G4） */
-    apiKey?: string;
-    /** BYOK：per-call 覆盖全局端点（OpenAI 兼容任意服务商） */
-    baseUrl?: string;
-    messages: ChatMessage[];
-    temperature?: number;
-    max_tokens?: number;
-    stream?: boolean;
-    tools?: ToolDefinition[];
-    tool_choice?: 'auto' | 'none' | 'required';
-    stop?: string[];
-}

package/dist/server/core/collect.d.ts

@@ -1,31 +0,0 @@
-/**
- * Trie 遍历收集纯函数（ROUTER-CORE 波次 E 纯移动拆解——2027-10）
- *
- * 自 router.ts Router 类移出（零 this 依赖——树遍历纯函数）。
- * - collectAll/collectAllWs：mount 展平负载（A1 wildcardValue 修复在案）
- * - collectRoutes/collectWsRoutes：routes() 调试清单
- */
-import type { Handler, Middleware } from '../types.ts';
-import type { WebSocketHandler } from './ws.ts';
-import type { TrieNode } from '../../shared/router/trie.ts';
-export type RouteValue = {
-    handlers: Map<string, Handler>;
-    middlewares: Map<string, Middleware[]>;
-};
-export type WsValue = {
-    handler: WebSocketHandler;
-    middlewares: Middleware[];
-};
-export declare function collectAll(node: TrieNode<RouteValue>, prefix?: string): Array<{
-    method: string;
-    path: string;
-    handler: Handler;
-    middlewares: Middleware[];
-}>;
-export declare function collectAllWs(node: TrieNode<WsValue>, prefix?: string): Array<{
-    path: string;
-    handler: WebSocketHandler;
-    middlewares: Middleware[];
-}>;
-export declare function collectRoutes(node: TrieNode<RouteValue>, prefix: string, result: string[]): void;
-export declare function collectWsRoutes(node: TrieNode<WsValue>, prefix: string, result: string[]): void;

package/dist/server/core/hub.d.ts

@@ -1,2 +0,0 @@
-import type { Hub } from './ws.ts';
-export declare function createInMemoryHub(): Hub;