@agentunion/fastaun-browser 0.5.14 → 0.5.15

package/dist/bundle.js

@@ -460,7 +460,7 @@ var init_indexeddb_store = __esm({
 });
 
 // src/version.ts
-var VERSION = "0.5.13";
+var VERSION = "0.5.15";
 
 // src/types.ts
 var ConnectionState = /* @__PURE__ */ ((ConnectionState2) => {
@@ -778,36 +778,59 @@ var _noopLog = { error: () => {
 }, info: () => {
 }, debug: () => {
 } };
+function createQueueState() {
+  return {
+    handlers: /* @__PURE__ */ new Map(),
+    queue: [],
+    draining: false,
+    drainScheduled: false,
+    handlerDepth: 0,
+    synchronousHandlerDepth: 0,
+    drainPromise: null,
+    drainResolve: null,
+    closing: false,
+    closed: false
+  };
+}
+function cloneEventPayload(value) {
+  if (Array.isArray(value)) return value.map((item) => cloneEventPayload(item));
+  if (value instanceof Error) {
+    const error = value;
+    const rawCode = error.localCode ?? error.stringCode ?? error.code;
+    const code = rawCode === void 0 || rawCode === null || rawCode === "" || rawCode === -1 ? "INTERNAL_ERROR" : rawCode;
+    return { code, message: error.message || error.name };
+  }
+  if (value !== null && typeof value === "object") {
+    const clone = {};
+    for (const [key, item] of Object.entries(value)) clone[key] = cloneEventPayload(item);
+    return clone;
+  }
+  return value;
+}
 var Subscription = class {
-  constructor(dispatcher, event, handler) {
+  constructor(dispatcher, event, handler, protocol = false) {
     __publicField(this, "_dispatcher");
     __publicField(this, "_event");
     __publicField(this, "_handler");
+    __publicField(this, "_protocol");
     __publicField(this, "_active", true);
     this._dispatcher = dispatcher;
     this._event = event;
     this._handler = handler;
+    this._protocol = protocol;
   }
   /** 取消订阅 */
   unsubscribe() {
     if (!this._active) return;
-    this._dispatcher.unsubscribe(this._event, this._handler);
+    this._dispatcher.unsubscribe(this._event, this._handler, this._protocol);
     this._active = false;
   }
 };
 var EventDispatcher = class {
   constructor() {
     __publicField(this, "_log", _noopLog);
-    __publicField(this, "_handlers", /* @__PURE__ */ new Map());
-    __publicField(this, "_queue", []);
-    __publicField(this, "_draining", false);
-    __publicField(this, "_drainScheduled", false);
-    __publicField(this, "_handlerDepth", 0);
-    __publicField(this, "_synchronousHandlerDepth", 0);
-    __publicField(this, "_drainPromise", null);
-    __publicField(this, "_drainResolve", null);
-    __publicField(this, "_closing", false);
-    __publicField(this, "_closed", false);
+    __publicField(this, "_app", createQueueState());
+    __publicField(this, "_protocol", createQueueState());
   }
   setLogger(log) {
     this._log = log;
@@ -820,99 +843,148 @@ var EventDispatcher = class {
    * 对象调用 unsubscribe() 来取消。
    */
   subscribe(event, handler) {
-    const list = this._handlers.get(event) ?? [];
+    return this._subscribe(this._app, event, handler, false);
+  }
+  /** 订阅 SDK 内部协议事件。 */
+  subscribeProtocol(event, handler) {
+    return this._subscribe(this._protocol, event, handler, true);
+  }
+  _subscribe(state, event, handler, protocol) {
+    const list = state.handlers.get(event) ?? [];
     list.push(handler);
-    this._handlers.set(event, list);
-    return new Subscription(this, event, handler);
+    state.handlers.set(event, list);
+    return new Subscription(this, event, handler, protocol);
   }
   /** 取消订阅 */
-  unsubscribe(event, handler) {
-    const list = this._handlers.get(event);
+  unsubscribe(event, handler, protocol = false) {
+    const state = protocol ? this._protocol : this._app;
+    const list = state.handlers.get(event);
     if (!list) return;
     const filtered = list.filter((h) => h !== handler);
     if (filtered.length > 0) {
-      this._handlers.set(event, filtered);
+      state.handlers.set(event, filtered);
     } else {
-      this._handlers.delete(event);
+      state.handlers.delete(event);
     }
   }
+  /** 取消协议事件订阅。 */
+  unsubscribeProtocol(event, handler) {
+    this.unsubscribe(event, handler, true);
+  }
   /**
    * 发布事件。事件总是异步进入 FIFO 队列；调用方 await 时等待该事件处理完成。
    * drain 中派生事件只入队，不等待自身，避免事件处理器互相等待形成死锁。
    */
   async publish(event, payload) {
-    if (this._closed || this._closing) return;
+    await this._publish(this._app, event, payload);
+  }
+  /** 发布协议事件。调用方 await 时等待协议处理完成。 */
+  async publishProtocol(event, payload) {
+    await this._publish(this._protocol, event, payload);
+  }
+  async _publish(state, event, payload) {
+    if (state.closed || state.closing) return;
     let resolveItem;
     const itemDone = new Promise((resolve) => {
       resolveItem = resolve;
     });
-    this._queue.push({
-      run: () => this.dispatchNow(event, payload),
+    state.queue.push({
+      run: () => this.dispatchNow(state, event, payload),
       resolve: resolveItem
     });
-    if (this._handlerDepth > 0) return;
-    if (this._drainPromise === null) {
-      this._drainPromise = new Promise((resolve) => {
-        this._drainResolve = resolve;
+    if (state.handlerDepth > 0) return;
+    if (state.drainPromise === null) {
+      state.drainPromise = new Promise((resolve) => {
+        state.drainResolve = resolve;
       });
     }
-    this.scheduleDrain();
+    this.scheduleDrain(state);
+    if (state === this._app && this._protocol.handlerDepth > 0) return;
     await itemDone;
   }
   /** 将事件放入异步 FIFO 队列，不等待处理器执行完成。 */
   enqueue(event, payload) {
-    void this.publish(event, payload).catch((exc) => {
+    this._enqueue(this._app, event, payload);
+  }
+  /** 将协议事件放入独立异步 FIFO 队列，不等待处理器执行完成。 */
+  enqueueProtocol(event, payload) {
+    this._enqueue(this._protocol, event, payload);
+  }
+  _enqueue(state, event, payload) {
+    const publish = state === this._protocol ? this.publishProtocol(event, payload) : this.publish(event, payload);
+    void publish.catch((exc) => {
       this._log.warn(`event ${event} enqueue failed:`, exc);
     });
   }
   /** 将非事件 observer 放入同一 FIFO 队列。 */
   enqueueTask(task) {
-    if (this._closed || this._closing) return;
-    this._queue.push({
-      run: () => this.dispatchTask(task),
+    this._enqueueTask(this._app, task);
+  }
+  /** 将协议层 observer 放入协议 FIFO 队列。 */
+  enqueueProtocolTask(task) {
+    this._enqueueTask(this._protocol, task);
+  }
+  _enqueueTask(state, task) {
+    if (state.closed || state.closing) return;
+    state.queue.push({
+      run: () => this.dispatchTask(state, task),
       resolve: () => {
       }
     });
-    if (this._drainPromise === null) {
-      this._drainPromise = new Promise((resolve) => {
-        this._drainResolve = resolve;
+    if (state.drainPromise === null) {
+      state.drainPromise = new Promise((resolve) => {
+        state.drainResolve = resolve;
       });
     }
-    this.scheduleDrain();
+    this.scheduleDrain(state);
   }
   /** 关闭调度器，排空已经入队的应用事件后拒绝后续事件。 */
   async close() {
-    if (this._closed) return;
-    this._closing = true;
-    if (this._synchronousHandlerDepth > 0) return;
-    if (this._drainPromise !== null) await this._drainPromise;
-    this.finishClose();
+    await this._close(this._app);
+  }
+  /** 关闭协议调度器，排空已经入队的协议事件后拒绝后续事件。 */
+  async closeProtocol() {
+    await this._close(this._protocol);
+  }
+  async _close(state) {
+    if (state.closed) return;
+    state.closing = true;
+    if (state.synchronousHandlerDepth > 0) return;
+    if (state.drainPromise !== null) await state.drainPromise;
+    this.finishClose(state);
   }
   /** 等待当前队列排空；事件 handler 重入时直接返回，避免自等待。 */
   async flush() {
-    if (this._synchronousHandlerDepth > 0) return;
-    if (this._drainPromise !== null) await this._drainPromise;
+    await this._flush(this._app);
+  }
+  /** 等待协议层当前队列排空。 */
+  async flushProtocol() {
+    await this._flush(this._protocol);
+  }
+  async _flush(state) {
+    if (state.synchronousHandlerDepth > 0) return;
+    if (state.drainPromise !== null) await state.drainPromise;
     await Promise.resolve();
   }
-  finishClose() {
-    if (!this._closing || this._closed || this._draining || this._drainScheduled || this._queue.length > 0) return;
-    this._closed = true;
-    this._handlers.clear();
+  finishClose(state) {
+    if (!state.closing || state.closed || state.draining || state.drainScheduled || state.queue.length > 0) return;
+    state.closed = true;
+    state.handlers.clear();
   }
-  scheduleDrain() {
-    if (this._draining || this._drainScheduled || this._queue.length === 0) return;
-    this._drainScheduled = true;
+  scheduleDrain(state) {
+    if (state.draining || state.drainScheduled || state.queue.length === 0) return;
+    state.drainScheduled = true;
     queueMicrotask(() => {
-      this._drainScheduled = false;
-      void this._drain();
+      state.drainScheduled = false;
+      void this._drain(state);
     });
   }
-  async _drain() {
-    if (this._draining) return;
-    this._draining = true;
+  async _drain(state) {
+    if (state.draining) return;
+    state.draining = true;
     try {
-      while (this._queue.length > 0) {
-        const item = this._queue.shift();
+      while (state.queue.length > 0) {
+        const item = state.queue.shift();
         try {
           await item.run();
         } catch (exc) {
@@ -922,70 +994,74 @@ var EventDispatcher = class {
         }
       }
     } finally {
-      this._draining = false;
-      const resolve = this._drainResolve;
-      this._drainResolve = null;
-      this._drainPromise = null;
+      state.draining = false;
+      const resolve = state.drainResolve;
+      state.drainResolve = null;
+      state.drainPromise = null;
       resolve?.();
-      this.finishClose();
-      if (this._queue.length > 0 && !this._closed) {
-        if (this._drainPromise === null) {
-          this._drainPromise = new Promise((nextResolve) => {
-            this._drainResolve = nextResolve;
+      this.finishClose(state);
+      if (state.queue.length > 0 && !state.closed) {
+        if (state.drainPromise === null) {
+          state.drainPromise = new Promise((nextResolve) => {
+            state.drainResolve = nextResolve;
           });
         }
-        this.scheduleDrain();
+        this.scheduleDrain(state);
       }
     }
   }
   /** 当前是否正在调用应用 handler 或 observer。供生命周期入口识别重入。 */
   isDispatchingHandler() {
-    return this._handlerDepth > 0;
+    return this._app.handlerDepth > 0 || this._protocol.handlerDepth > 0;
   }
-  async dispatchTask(task) {
+  async dispatchTask(state, task) {
     let result;
-    this._handlerDepth += 1;
+    state.handlerDepth += 1;
     try {
-      this._synchronousHandlerDepth += 1;
+      state.synchronousHandlerDepth += 1;
       result = task();
     } catch (exc) {
       this._log.warn("event task execution exception:", exc);
-      this._handlerDepth -= 1;
+      state.handlerDepth -= 1;
       return;
     } finally {
-      this._synchronousHandlerDepth -= 1;
+      state.synchronousHandlerDepth -= 1;
     }
     try {
       await result;
     } catch (exc) {
       this._log.warn("event task execution exception:", exc);
     } finally {
-      this._handlerDepth -= 1;
+      state.handlerDepth -= 1;
     }
   }
-  async dispatchNow(event, payload) {
-    const handlers = [...this._handlers.get(event) ?? []];
+  async dispatchNow(state, event, payload) {
+    const handlers = [...state.handlers.get(event) ?? []];
+    const applicationPayload = state === this._protocol && this._app.handlers.has(event) ? cloneEventPayload(payload) : void 0;
     for (const handler of handlers) {
       let result;
-      this._handlerDepth += 1;
+      state.handlerDepth += 1;
       try {
-        this._synchronousHandlerDepth += 1;
+        state.synchronousHandlerDepth += 1;
         result = handler(payload);
       } catch (exc) {
         this._log.warn(`event ${event} handler execution exception:`, exc);
-        this._handlerDepth -= 1;
+        state.handlerDepth -= 1;
         continue;
       } finally {
-        this._synchronousHandlerDepth -= 1;
+        state.synchronousHandlerDepth -= 1;
       }
       try {
         await result;
       } catch (exc) {
         this._log.warn(`event ${event} handler execution exception:`, exc);
       } finally {
-        this._handlerDepth -= 1;
+        state.handlerDepth -= 1;
       }
     }
+    if (applicationPayload !== void 0) {
+      this.enqueue(event, applicationPayload);
+    }
   }
 };
 
@@ -1292,6 +1368,119 @@ var GatewayDiscovery = class {
   }
 };
 
+// src/logger.ts
+function trafficLogContext(direction, data) {
+  const params2 = data && typeof data === "object" && !Array.isArray(data) ? data : {};
+  const target = params2.target && typeof params2.target === "object" ? params2.target : {};
+  const notify = params2._notify && typeof params2._notify === "object" ? params2._notify : {};
+  const text3 = (value) => typeof value === "string" ? value.trim() : "";
+  const group = text3(params2.group_aid) || text3(params2.group_id) || text3(target.group_aid) || text3(target.group_id);
+  const groupAid = normalizeGroupAid(group);
+  const peerAid = group ? groupAid.includes(".") && !groupAid.includes("/") ? groupAid : "" : direction === "outbound" ? text3(target.aid) || text3(params2.to) || text3(params2.to_aid) || text3(params2.peer_aid) : text3(notify.from_aid) || text3(params2.from_aid) || text3(params2.sender_aid) || text3(params2.from);
+  return { direction, peerAid };
+}
+function withLogContext(logger, context) {
+  return logger.withContext?.(context) ?? logger;
+}
+var LEVEL_ORDER = { DEBUG: 0, INFO: 1, WARN: 2, ERROR: 3 };
+function formatMessage(template, args) {
+  if (args.length === 0) return template;
+  let i = 0;
+  let result = "";
+  let consumed = 0;
+  for (let p = 0; p < template.length; p++) {
+    const ch = template[p];
+    if (ch === "%" && template[p + 1] === "s" && i < args.length) {
+      result += String(args[i++]);
+      consumed++;
+      p++;
+    } else {
+      result += ch;
+    }
+  }
+  if (i < args.length) {
+    const tail = args.slice(i).map((a) => a instanceof Error ? a.message : String(a)).join(" ");
+    if (tail) result += " " + tail;
+  }
+  return result;
+}
+var AUNLogger = class {
+  constructor(opts) {
+    __publicField(this, "_debug");
+    __publicField(this, "_aunPath");
+    __publicField(this, "_deviceId", "-");
+    __publicField(this, "_aid", null);
+    __publicField(this, "_minLevel");
+    this._debug = opts.debug;
+    this._aunPath = String(opts.aunPath || "-");
+    this._minLevel = this._debug ? LEVEL_ORDER.DEBUG : LEVEL_ORDER.INFO;
+  }
+  for(module, context) {
+    const snapshot = context ? { ...context, aid: context.aid ?? this._aid ?? "" } : void 0;
+    return {
+      error: (msg, ...args) => this._emit("ERROR", module, msg, args, snapshot),
+      warn: (msg, ...args) => this._emit("WARN", module, msg, args, snapshot),
+      info: (msg, ...args) => this._emit("INFO", module, msg, args, snapshot),
+      debug: (msg, ...args) => this._emit("DEBUG", module, msg, args, snapshot),
+      isDebugEnabled: () => this.isDebugEnabled(),
+      withContext: (next) => this.for(module, { ...next, aid: next.aid ?? snapshot?.aid })
+    };
+  }
+  isDebugEnabled() {
+    return this._debug && this._minLevel <= LEVEL_ORDER.DEBUG;
+  }
+  bindAid(aid) {
+    this._aid = aid || null;
+  }
+  bindDeviceId(deviceId) {
+    this._deviceId = String(deviceId || "").trim() || "-";
+  }
+  close() {
+  }
+  _emit(level, module, msg, args, context) {
+    if (LEVEL_ORDER[level] < this._minLevel) return;
+    if (level === "DEBUG" && !this._debug) return;
+    const { date, time, ms } = this._now();
+    const head = `[${date} ${time}.${ms}][${level}][${module}][aun_path=${this._aunPath || "-"}][device_id=${this._deviceId || "-"}]`;
+    const aidPart = context ? ` [${context.aid || "-"} ${context.direction === "outbound" ? "->" : "<-"} ${context.peerAid || "-"}]` : this._aid ? ` [${this._aid}]` : "";
+    const formatted = formatMessage(msg, args);
+    const line = `${head}${aidPart} ${formatted}`;
+    let errArg;
+    for (let i = args.length - 1; i >= 0; i--) {
+      if (args[i] instanceof Error) {
+        errArg = args[i];
+        break;
+      }
+    }
+    switch (level) {
+      case "ERROR":
+        if (errArg) {
+          console.error(line, errArg);
+        } else {
+          console.error(line);
+        }
+        break;
+      case "WARN":
+        console.warn(line);
+        break;
+      case "INFO":
+        console.info(line);
+        break;
+      case "DEBUG":
+        console.debug(line);
+        break;
+    }
+  }
+  _now() {
+    const d = /* @__PURE__ */ new Date();
+    const pad = (n, w = 2) => String(n).padStart(w, "0");
+    const date = `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}`;
+    const time = `${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}`;
+    const ms = pad(d.getMilliseconds(), 3);
+    return { date, time, ms };
+  }
+};
+
 // src/transport.ts
 var MAX_WS_PAYLOAD_SIZE = 1e6;
 var MAX_RPC_INFLIGHT = 16;
@@ -1835,6 +2024,7 @@ var RPCTransport = class {
     __publicField(this, "_timeout");
     __publicField(this, "_connectTimeout");
     __publicField(this, "_onDisconnect");
+    __publicField(this, "_onDisconnectIsProtocol", false);
     __publicField(this, "_ws", null);
     __publicField(this, "_closed", true);
     __publicField(this, "_lastCloseCode", null);
@@ -1852,6 +2042,7 @@ var RPCTransport = class {
     // Gateway 在 RPC envelope 注入 _meta 字段（与 result 同级），由 client 层 observer 接收。
     // 注入失败 / 字段缺失时 observer 不会被调用，不影响业务路径。
     __publicField(this, "_metaObserver", null);
+    __publicField(this, "_metaObserverIsProtocol", false);
     // Trace 模式：off / log / diag
     __publicField(this, "_traceMode", "off");
     // Trace observer：observer(traceInfo) 在每次 RPC/事件携带 _trace 时调用
@@ -1861,13 +2052,17 @@ var RPCTransport = class {
     __publicField(this, "_actorTail", Promise.resolve());
     __publicField(this, "_actorBusy", false);
     this._dispatcher = opts.eventDispatcher;
-    this._timeout = opts.timeout ?? 10;
+    this._timeout = opts.timeout ?? 35;
     this._connectTimeout = opts.timeout ?? 10;
     this._onDisconnect = opts.onDisconnect ?? null;
   }
   setLogger(log) {
     this._log = log;
   }
+  setProtocolDisconnectCallback(callback) {
+    this._onDisconnect = callback;
+    this._onDisconnectIsProtocol = true;
+  }
   /** 设置默认超时（秒） */
   setTimeout(timeout) {
     this._timeout = timeout;
@@ -1888,19 +2083,26 @@ var RPCTransport = class {
    */
   setMetaObserver(observer) {
     this._metaObserver = observer;
+    this._metaObserverIsProtocol = false;
+  }
+  setProtocolMetaObserver(observer) {
+    this._metaObserver = observer;
+    this._metaObserverIsProtocol = true;
   }
   _notifyMetaObserver(message) {
     const observer = this._metaObserver;
     if (observer === null) return;
     const meta = message._meta;
     if (!isJsonObject(meta)) return;
-    this._dispatcher.enqueueTask(async () => {
+    const task = async () => {
       try {
         await observer(meta);
       } catch (exc) {
         this._log.debug(`meta_observer raised: ${String(exc)}`);
       }
-    });
+    };
+    if (this._metaObserverIsProtocol) this._dispatcher.enqueueProtocolTask(task);
+    else this._dispatcher.enqueueTask(task);
   }
   /** 设置 trace 模式：off / log / diag */
   setTraceMode(mode) {
@@ -2170,6 +2372,9 @@ var RPCTransport = class {
     const localParams = sendParams;
     const backgroundRpc = background || localParams._rpc_background === true;
     delete localParams._rpc_background;
+    const requestContext = trafficLogContext("outbound", sendParams);
+    const requestLog = withLogContext(this._log, requestContext);
+    const responseLog = withLogContext(requestLog, { direction: "inbound", peerAid: requestContext.peerAid });
     if (effectiveTraceMode !== "off") {
       traceId = typeof crypto !== "undefined" && crypto.randomUUID ? crypto.randomUUID().replace(/-/g, "") : Array.from({ length: 32 }, () => Math.floor(Math.random() * 16).toString(16)).join("");
       const tracePayload = { trace_id: traceId, mode: effectiveTraceMode };
@@ -2177,7 +2382,7 @@ var RPCTransport = class {
         tracePayload.spans = [{ node: "sdk", ts: tStart, action: "send" }];
       }
       localParams._trace = tracePayload;
-      this._log.info(`[trace=${traceId}] rpc_send method=${method} rpc_id=${rpcId}`);
+      requestLog.info(`[trace=${traceId}] rpc_send method=${method} rpc_id=${rpcId}`);
     }
     const payload = JSON.stringify({
       jsonrpc: "2.0",
@@ -2193,7 +2398,7 @@ var RPCTransport = class {
     const promise = new Promise((resolve, reject) => {
       const timer = globalThis.setTimeout(() => {
         this._removeRpc(rpcId, pending);
-        this._log.warn(`RPC timeout: method=${method}, id=${rpcId}, elapsed=${Date.now() - tStart}ms, timeout=${effectiveTimeout}ms`);
+        requestLog.warn(`RPC timeout: method=${method}, id=${rpcId}, elapsed=${Date.now() - tStart}ms, timeout=${effectiveTimeout}ms`);
         reject(new TimeoutError(`rpc timeout: ${method}`, { retryable: true }));
         this._drainRpcQueue();
       }, effectiveTimeout);
@@ -2202,28 +2407,28 @@ var RPCTransport = class {
           clearTimeout(timer);
           const elapsed = Date.now() - tStart;
           if (response.error !== void 0) {
-            this._log.debug(`RPC error response: method=${method}, id=${rpcId}, elapsed=${elapsed}ms, error=${JSON.stringify(response.error)}`);
+            responseLog.debug(`RPC error response: method=${method}, id=${rpcId}, elapsed=${elapsed}ms, error=${JSON.stringify(response.error)}`);
             if (traceId) {
-              this._log.info(`[trace=${traceId}] rpc_recv method=${method} rpc_id=${rpcId} duration_ms=${elapsed} status=error`);
+              responseLog.info(`[trace=${traceId}] rpc_recv method=${method} rpc_id=${rpcId} duration_ms=${elapsed} status=error`);
             }
             const respTrace = response._trace;
             if (respTrace && typeof respTrace === "object" && !Array.isArray(respTrace)) {
-              this._handleResponseTrace(method, "error", elapsed, respTrace);
+              this._handleResponseTrace(method, "error", elapsed, respTrace, responseLog);
             }
             reject(mapRemoteError(response.error));
           } else if (response.result !== void 0) {
-            this._log.debug(`RPC response ok: method=${method}, id=${rpcId}, elapsed=${elapsed}ms ${summarizeDict(response.result, DIAG_RESULT_FIELDS)}`);
+            responseLog.debug(`RPC response ok: method=${method}, id=${rpcId}, elapsed=${elapsed}ms ${summarizeDict(response.result, DIAG_RESULT_FIELDS)}`);
             if (traceId) {
-              this._log.info(`[trace=${traceId}] rpc_recv method=${method} rpc_id=${rpcId} duration_ms=${elapsed} status=ok`);
+              responseLog.info(`[trace=${traceId}] rpc_recv method=${method} rpc_id=${rpcId} duration_ms=${elapsed} status=ok`);
             }
             this._notifyMetaObserver(response);
             const respTrace = response._trace;
             if (respTrace && typeof respTrace === "object" && !Array.isArray(respTrace)) {
-              this._handleResponseTrace(method, "ok", elapsed, respTrace);
+              this._handleResponseTrace(method, "ok", elapsed, respTrace, responseLog);
             }
             resolve(response.result);
           } else {
-            this._log.warn(`RPC response missing result or error: method=${method}, id=${rpcId}, elapsed=${elapsed}ms`);
+            responseLog.warn(`RPC response missing result or error: method=${method}, id=${rpcId}, elapsed=${elapsed}ms`);
             reject(new SerializationError(`rpc response missing result and error: ${method}`));
           }
         },
@@ -2246,7 +2451,8 @@ var RPCTransport = class {
           pending,
           tStart,
           timeoutMs: effectiveTimeout,
-          background: true
+          background: true,
+          logger: requestLog
         });
       } else {
         this._rpcQueue.push({
@@ -2256,7 +2462,8 @@ var RPCTransport = class {
           pending,
           tStart,
           timeoutMs: effectiveTimeout,
-          background: false
+          background: false,
+          logger: requestLog
         });
       }
       this._drainRpcQueue();
@@ -2287,8 +2494,9 @@ var RPCTransport = class {
     if (payloadSize > MAX_WS_PAYLOAD_SIZE) {
       throw new ValidationError("payload is too large");
     }
+    const notifyLog = withLogContext(this._log, trafficLogContext("outbound", params2 ?? {}));
     await this._sendText(payload, `notification ${normalizedMethod}`);
-    this._log.debug(`notification sent: method=${normalizedMethod}, size=${payloadSize}`);
+    notifyLog.debug(`notification sent: method=${normalizedMethod}, size=${payloadSize}`);
   }
   _enqueueSend(task) {
     const run = this._sendChain.then(() => Promise.resolve(task()), () => Promise.resolve(task()));
@@ -2440,7 +2648,7 @@ var RPCTransport = class {
         const elapsed = Date.now() - entry.tStart;
         if (elapsed >= entry.timeoutMs) {
           clearTimeout(entry.pending.timer);
-          this._log.warn(`RPC queue timeout: method=${entry.method}, id=${entry.rpcId}, elapsed=${elapsed}ms, timeout=${entry.timeoutMs}ms`);
+          entry.logger.warn(`RPC queue timeout: method=${entry.method}, id=${entry.rpcId}, elapsed=${elapsed}ms, timeout=${entry.timeoutMs}ms`);
           entry.pending.reject(new TimeoutError(`rpc timeout before send: ${entry.method}`, { retryable: true }));
           continue;
         }
@@ -2453,11 +2661,11 @@ var RPCTransport = class {
           `rpc ${entry.method}`,
           () => this._pending.get(entry.rpcId) === entry.pending
         ).then(() => {
-          this._log.debug(`RPC request sent: method=${entry.method}, id=${entry.rpcId}, background=${entry.background}`);
+          entry.logger.debug(`RPC request sent: method=${entry.method}, id=${entry.rpcId}, background=${entry.background}`);
         }).catch((err) => {
           if (this._pending.get(entry.rpcId) !== entry.pending) return;
           this._removeRpc(entry.rpcId, entry.pending);
-          this._log.error(`RPC send failed: method=${entry.method}, id=${entry.rpcId}, error=${String(err)}`, err instanceof Error ? err : void 0);
+          entry.logger.error(`RPC send failed: method=${entry.method}, id=${entry.rpcId}, error=${String(err)}`, err instanceof Error ? err : void 0);
           entry.pending.reject(
             err instanceof ConnectionError ? err : new ConnectionError(`failed to send rpc ${entry.method}: ${err instanceof Error ? err.message : String(err)}`)
           );
@@ -2469,7 +2677,7 @@ var RPCTransport = class {
     }
   }
   /** 处理 RPC 响应中的 _trace 字段：追加 sdk.recv span，格式化输出，通知 observer */
-  _handleResponseTrace(method, status, elapsedMs, respTrace) {
+  _handleResponseTrace(method, status, elapsedMs, respTrace, logger = this._log) {
     try {
       const sdkRecvSpan = {
         node: "sdk",
@@ -2480,7 +2688,7 @@ var RPCTransport = class {
       const existingSpans = Array.isArray(respTrace.spans) ? respTrace.spans : [];
       const spans = [...existingSpans, sdkRecvSpan];
       const enriched = { ...respTrace, spans };
-      this._log.info(traceDisplay(method, status, elapsedMs, respTrace, spans));
+      logger.info(traceDisplay(method, status, elapsedMs, respTrace, spans));
       if (this._traceObserver !== null) {
         const observer = this._traceObserver;
         this._dispatcher.enqueueTask(async () => {
@@ -2492,7 +2700,7 @@ var RPCTransport = class {
         });
       }
     } catch (err) {
-      this._log.debug(`trace handling raised: ${err instanceof Error ? err.message : String(err)}`);
+      logger.debug(`trace handling raised: ${err instanceof Error ? err.message : String(err)}`);
     }
   }
   // ── 内部消息处理 ──────────────────────────────────
@@ -2532,15 +2740,17 @@ var RPCTransport = class {
       const error = new ConnectionError(`websocket closed: code=${event.code} reason=${event.reason}`);
       if (this._onDisconnect) {
         const onDisconnect = this._onDisconnect;
-        this._dispatcher.enqueueTask(async () => {
+        const task = async () => {
           try {
             await onDisconnect(error, event.code);
           } catch (exc) {
             this._log.warn("[aun_core.transport] disconnect callback exception:", exc);
           }
-        });
+        };
+        if (this._onDisconnectIsProtocol) this._dispatcher.enqueueProtocolTask(task);
+        else this._dispatcher.enqueueTask(task);
       }
-      this._dispatcher.enqueue("connection.error", { error });
+      this._dispatcher.enqueueProtocol("connection.error", { error });
     }
   }
   _notConnectedError() {
@@ -2560,21 +2770,22 @@ var RPCTransport = class {
         pending.resolve(message);
         this._drainRpcQueue();
       } else {
-        this._log.warn("[aun_core.transport] recv unknown rpc response (maybe arrived after timeout): id=" + rpcId);
+        withLogContext(this._log, { direction: "inbound", peerAid: "" }).warn("[aun_core.transport] recv unknown rpc response (maybe arrived after timeout): id=" + rpcId);
       }
       return;
     }
     const method = String(message.method ?? "");
     if (method === "challenge") {
       this._challenge = message;
-      this._log.debug("challenge received");
-      this._dispatcher.enqueue("connection.challenge", message.params ?? {});
+      withLogContext(this._log, trafficLogContext("inbound", message.params ?? message)).debug("challenge received");
+      this._dispatcher.enqueueProtocol("connection.challenge", message.params ?? {});
       return;
     }
     if (method.startsWith("event/")) {
       const protocolEvent = method.slice(6);
       const sdkEvent = EVENT_NAME_MAP[protocolEvent] ?? protocolEvent;
-      this._log.debug(`event recv: event=${sdkEvent} ${summarizeDict(message.params, DIAG_RESULT_FIELDS)}`);
+      const eventLog = withLogContext(this._log, trafficLogContext("inbound", message.params ?? message));
+      eventLog.debug(`event recv: event=${sdkEvent} ${summarizeDict(message.params, DIAG_RESULT_FIELDS)}`);
       this._notifyMetaObserver(message);
       const params2 = message.params ?? {};
       if ("_trace" in params2) {
@@ -2592,19 +2803,19 @@ var RPCTransport = class {
             });
           }
           const traceObj = eventTrace;
-          this._log.info(`[trace=${String(traceObj.trace_id ?? "")}] event_recv event=${sdkEvent}`);
+          eventLog.info(`[trace=${String(traceObj.trace_id ?? "")}] event_recv event=${sdkEvent}`);
         }
       }
       if (sdkEvent.startsWith("app.")) {
         this._dispatcher.enqueue(sdkEvent, params2);
         return;
       }
-      this._dispatcher.enqueue(`_raw.${sdkEvent}`, params2);
+      this._dispatcher.enqueueProtocol(`_raw.${sdkEvent}`, params2);
       return;
     }
     this._notifyMetaObserver(message);
-    this._log.debug(`notification recv: method=${method || "<no-method>"}`);
-    this._dispatcher.enqueue("notification", message);
+    withLogContext(this._log, trafficLogContext("inbound", message.params ?? {})).debug(`notification recv: method=${method || "<no-method>"}`);
+    this._dispatcher.enqueueProtocol("notification", message);
   }
   _decodeMessage(raw) {
     if (isJsonObject(raw)) {
@@ -7028,8 +7239,7 @@ var MessageDeliveryEngine = class {
       max_pages: 1
     };
     const invoke = async () => {
-      const after = this.syncState(ns).ack;
-      const messages = await client._pullV2(after, pageLimit, { gateLocked: true, maxPages: 1 });
+      const messages = await client._pullV2(Number(request.after_seq), pageLimit, { gateLocked: true, maxPages: 1 });
       return { messages, raw_count: messages.length };
     };
     const pipeline = client._rpcPipeline;
@@ -7048,8 +7258,7 @@ var MessageDeliveryEngine = class {
       max_pages: maxPages
     };
     const invoke = async () => {
-      const after = this.syncState(ns).ack;
-      const messages = await client._pullGroupV2(groupId, after, pageLimit, { gateLocked: true, maxPages });
+      const messages = await client._pullGroupV2(groupId, Number(request.after_seq), pageLimit, { gateLocked: true, maxPages });
       return { messages, raw_count: messages.length };
     };
     const pipeline = client._rpcPipeline;
@@ -8783,7 +8992,9 @@ var LifecycleController = class {
         client._resetSeqTrackingState();
         client._clientLog.debug(`close exit: elapsed=${Date.now() - tStart}ms`);
       } finally {
-        const closing = client._dispatcher.close();
+        const closeProtocol = client._dispatcher.closeProtocol;
+        const protocolClosing = typeof closeProtocol === "function" ? closeProtocol.call(client._dispatcher) : Promise.resolve();
+        const closing = protocolClosing.then(() => client._dispatcher.close());
         if (!calledFromHandler) await closing;
       }
     }, "close");
@@ -15384,8 +15595,8 @@ function validateAgentMdCertificate(certPem, expectedAid, timestamp2, now, requi
 function resultOk(data) {
   return { ok: true, data };
 }
-function resultErr(code, message, cause) {
-  return { ok: false, error: { code, message, ...cause !== void 0 ? { cause } : {} } };
+function resultErr(code, message, _cause) {
+  return { ok: false, error: { code, message } };
 }
 
 // src/aid.ts
@@ -15755,8 +15966,8 @@ async function signingCertFingerprint(certPem) {
   }
   return await cached;
 }
-var PULL_GATE_STALE_MS = 3e4;
-var PULL_GATE_OPERATION_TIMEOUT_MS = 3e3;
+var PULL_GATE_STALE_MS = 35e3;
+var PULL_GATE_OPERATION_TIMEOUT_MS = 35e3;
 function sameIdentityAdmissionRejection(error, original) {
   const errorCode2 = Number(error?.code);
   const originalCode = Number(original?.code);
@@ -16246,7 +16457,8 @@ var RpcPipeline = class {
       if (!client._aid) return "";
       const mode = method === "message.history" ? "history" : params2.window_mode === "tail" ? "tail" : "forward";
       const cursor = mode === "history" ? `before=${String(params2.before_seq)}` : `after=${String(params2.after_seq ?? 0)}`;
-      return `p2p:${client._aid}|mode=${mode}|cursor=${cursor}|force=${String(Boolean(params2.force))}|limit=${String(params2.limit)}`;
+      const limit = mode === "forward" ? Number(params2.limit ?? 50) || 50 : params2.limit;
+      return `p2p:${client._aid}|mode=${mode}|cursor=${cursor}|force=${String(Boolean(params2.force))}|limit=${String(limit)}`;
     }
     if (method === "group.pull" || method === "group.v2.pull" || method === "group.history") {
       const gid = String(params2.group_id ?? params2.group_aid ?? "").trim();
@@ -16255,7 +16467,8 @@ var RpcPipeline = class {
       const cursor = mode === "history" ? `before=${String(params2.before_seq)}` : `after=${String(params2.after_seq ?? params2.after_message_seq ?? 0)}`;
       const explicitCursor = this.explicitGroupCursorParams(params2);
       const cursorSuffix = Object.keys(explicitCursor).length > 0 ? `|cursor_params=${stableStringify(explicitCursor)}` : "";
-      return `group:${gid}|mode=${mode}|cursor=${cursor}${cursorSuffix}|force=${String(Boolean(params2.force))}|limit=${String(params2.limit)}`;
+      const limit = mode === "forward" ? Number(params2.limit ?? 50) || 50 : params2.limit;
+      return `group:${gid}|mode=${mode}|cursor=${cursor}${cursorSuffix}|force=${String(Boolean(params2.force))}|limit=${String(limit)}`;
     }
     if (method === "group.pull_events") {
       const gid = String(params2.group_id ?? params2.group_aid ?? "").trim();
@@ -16330,9 +16543,9 @@ var RpcPipeline = class {
     const index = key.indexOf("|");
     return index < 0 ? key : key.slice(0, index);
   }
-  bindActivePullCancellation(method, params2, request) {
+  bindActivePullCancellation(method, params2, request, gateKey = "") {
     const cancel = request.cancel;
-    const key = this.pullGateKeyForCall(method, params2);
+    const key = gateKey || this.pullGateKeyForCall(method, params2);
     if (typeof cancel !== "function" || !key) return request;
     const state = this.pullGateStates.get(this.pullGateName(key));
     const active = state?.active;
@@ -16714,10 +16927,10 @@ var RpcPipeline = class {
       else if (options?.trace !== void 0) request = client._transport.call(method, payload, timeout, options.trace);
       else if (timeout !== void 0) request = client._transport.call(method, payload, timeout);
       else request = client._transport.call(method, payload);
-      return this.bindActivePullCancellation(method, payload, request);
+      return this.bindActivePullCancellation(method, payload, request, options?.pullGateKey ?? "");
     };
     const result = await this.transportCallWithIdentityRecovery(invokeTransport, method, payload);
-    this.throwIfPullInvalidated(this.pullScopeKey(this.pullGateKeyForCall(method, payload)));
+    this.throwIfPullInvalidated(this.pullScopeKey(options?.pullGateKey || this.pullGateKeyForCall(method, payload)));
     return result;
   }
   async transportCallWithIdentityRecovery(operation, method, params2) {
@@ -18222,7 +18435,7 @@ async function verifyGroupIndex(body, signer) {
       return resultOk({ valid: false, reason: "etag mismatch" });
     }
     const verified = await signer.verify(groupIndexSigningPayload(parsed.meta, parsed.entries), signature);
-    if (!verified.ok) return resultErr(verified.error.code, verified.error.message || "group index verify failed", verified.error.cause);
+    if (!verified.ok) return resultErr(verified.error.code, verified.error.message || "group index verify failed");
     if (!verified.data.valid) return resultOk({ valid: false, reason: "signature verification failed" });
     return resultOk({ valid: true, meta: parsed.meta, entries: canonicalEntries(parsed.entries) });
   } catch (exc) {
@@ -24956,7 +25169,16 @@ var V2E2EECoordinator = class {
     const limit = strictWindowLimit(params2.limit ?? V2_PULL_DEFAULT_PAGE_LIMIT);
     const ns = client._aid ? `p2p:${client._aid}` : "";
     if (ns) client._delivery.onPullStarted?.(ns);
-    const result = await client._callRawV2Rpc("message.v2.pull", { window_mode: "tail", after_seq: afterSeq, limit, _rpc_foreground: true });
+    const pullGateKey = pullGateKeyForClient(client, "message.v2.pull", {
+      window_mode: "tail",
+      after_seq: afterSeq,
+      limit
+    }, `${ns}|tail|after=${afterSeq}|limit=${limit}`);
+    const result = await client._callRawV2Rpc(
+      "message.v2.pull",
+      { window_mode: "tail", after_seq: afterSeq, limit, _rpc_foreground: true },
+      pullGateKey
+    );
     const page = validateTailPage(result, afterSeq, limit);
     if (ns) {
       client._seqTracker.commitTailWindow(ns, {
@@ -25065,7 +25287,7 @@ var V2E2EECoordinator = class {
         limit,
         ...opts?.force ? { force: true } : {},
         ...ackUpToSeq > 0 ? { ack_up_to_seq: ackUpToSeq } : {}
-      });
+      }, pullGateKey);
       if (ackUpToSeq > 0) {
         const actualAckSeq = client._delivery?.resolveP2PPullAckSeq?.(result, ackUpToSeq) ?? 0;
         if (actualAckSeq >= ackUpToSeq) {
@@ -25423,18 +25645,27 @@ var V2E2EECoordinator = class {
     const afterSeq = strictWindowSeq(params2.after_seq ?? 0, "after_seq");
     const limit = strictWindowLimit(params2.limit ?? V2_PULL_DEFAULT_PAGE_LIMIT);
     const ns = `group:${groupId}`;
-    const cursorParams = isJsonObject(params2._group_cursor_params) ? params2._group_cursor_params : params2;
+    const explicitCursorParams = isJsonObject(params2._group_cursor_params) ? params2._group_cursor_params : {};
+    const cursorParams = Object.keys(explicitCursorParams).length > 0 ? explicitCursorParams : params2;
     const requestDeviceId = String(cursorParams.device_id ?? "").trim();
     const requestSlotId = String(cursorParams.slot_id ?? "").trim();
     const ownsCursor = (!requestDeviceId || requestDeviceId === String(client._deviceId ?? "")) && (!requestSlotId || requestSlotId === String(client._slotId ?? ""));
     if (ownsCursor) client._delivery.onPullStarted?.(ns);
+    const pullGateKey = pullGateKeyForClient(client, "group.v2.pull", {
+      group_id: groupId,
+      window_mode: "tail",
+      after_seq: afterSeq,
+      limit,
+      _group_cursor_params: explicitCursorParams
+    }, `${ns}|tail|after=${afterSeq}|limit=${limit}`);
     const result = await client._callRawV2Rpc("group.v2.pull", withExplicitGroupAid({
       group_id: groupId,
       window_mode: "tail",
       after_seq: afterSeq,
       limit,
+      _group_cursor_params: explicitCursorParams,
       _rpc_foreground: true
-    }, groupAid));
+    }, groupAid), pullGateKey);
     const resultAid = String(result.group_aid ?? result.groupAid ?? "").trim();
     if (resultAid) groupAid = resultAid;
     const page = validateTailPage(result, afterSeq, limit);
@@ -25525,6 +25756,7 @@ var V2E2EECoordinator = class {
       }
       const result = await this.pullGroupV2TailInternal({
         ...opts?.cursorParams ?? {},
+        _group_cursor_params: opts?.cursorParams,
         group_id: String(opts.wireGroupId ?? gid),
         group_aid: groupAid || void 0,
         window_mode: "tail",
@@ -25551,13 +25783,13 @@ var V2E2EECoordinator = class {
     const cursorParams = opts?.cursorParams ?? {};
     const ownsCursor = opts?.ownsCursor !== false;
     if (ownsCursor) client._delivery.onPullStarted?.(ns);
-    let pullGateKey = ownsCursor ? pullGateKeyForClient(client, "group.v2.pull", {
+    let pullGateKey = pullGateKeyForClient(client, "group.v2.pull", {
       group_id: gid,
       after_seq: afterSeq,
       force: opts?.force === true,
       limit,
       _group_cursor_params: cursorParams
-    }, `${ns}|forward|after=${afterSeq}|force=${String(Boolean(opts?.force))}|limit=${limit}`) : "";
+    }, `${ns}|forward|after=${afterSeq}|force=${String(Boolean(opts?.force))}|limit=${limit}`);
     let nextAfterSeq = opts?.explicitAfterSeq || opts?.force ? afterSeq : afterSeq || client._seqTracker.getContiguousSeq(ns);
     const deferredServerCursor = ownsCursor ? this.pendingForwardCursor(ns, client._seqTracker.getContiguousSeq(ns)) : 0;
     const deferredForwardAck = ownsCursor ? this.pendingForwardAck(ns, client._seqTracker.getContiguousSeq(ns)) : 0;
@@ -25576,7 +25808,7 @@ var V2E2EECoordinator = class {
         ...cursorParams,
         ...opts?.force ? { force: true } : {},
         ...ackUpToSeq > 0 ? { ack_up_to_seq: ackUpToSeq } : {}
-      }, groupAid));
+      }, groupAid), pullGateKey);
       if (ackUpToSeq > 0) {
         const actualAckSeq = client._delivery?.resolveGroupPullAckSeq?.(result, ackUpToSeq) ?? 0;
         if (actualAckSeq >= ackUpToSeq) {
@@ -28380,104 +28612,6 @@ __publicField(_IndexedDBTokenStore, "_TRUST_CERT_PREFIX", "__trust_roots:cert:")
 __publicField(_IndexedDBTokenStore, "_TRUST_ISSUER_PREFIX", "__trust_roots:issuer:");
 var IndexedDBTokenStore = _IndexedDBTokenStore;
 
-// src/logger.ts
-var LEVEL_ORDER = { DEBUG: 0, INFO: 1, WARN: 2, ERROR: 3 };
-function formatMessage(template, args) {
-  if (args.length === 0) return template;
-  let i = 0;
-  let result = "";
-  let consumed = 0;
-  for (let p = 0; p < template.length; p++) {
-    const ch = template[p];
-    if (ch === "%" && template[p + 1] === "s" && i < args.length) {
-      result += String(args[i++]);
-      consumed++;
-      p++;
-    } else {
-      result += ch;
-    }
-  }
-  if (i < args.length) {
-    const tail = args.slice(i).map((a) => a instanceof Error ? a.message : String(a)).join(" ");
-    if (tail) result += " " + tail;
-  }
-  return result;
-}
-var AUNLogger = class {
-  constructor(opts) {
-    __publicField(this, "_debug");
-    __publicField(this, "_aunPath");
-    __publicField(this, "_deviceId", "-");
-    __publicField(this, "_aid", null);
-    __publicField(this, "_minLevel");
-    this._debug = opts.debug;
-    this._aunPath = String(opts.aunPath || "-");
-    this._minLevel = this._debug ? LEVEL_ORDER.DEBUG : LEVEL_ORDER.INFO;
-  }
-  for(module) {
-    return {
-      error: (msg, ...args) => this._emit("ERROR", module, msg, args),
-      warn: (msg, ...args) => this._emit("WARN", module, msg, args),
-      info: (msg, ...args) => this._emit("INFO", module, msg, args),
-      debug: (msg, ...args) => this._emit("DEBUG", module, msg, args),
-      isDebugEnabled: () => this.isDebugEnabled()
-    };
-  }
-  isDebugEnabled() {
-    return this._debug && this._minLevel <= LEVEL_ORDER.DEBUG;
-  }
-  bindAid(aid) {
-    this._aid = aid || null;
-  }
-  bindDeviceId(deviceId) {
-    this._deviceId = String(deviceId || "").trim() || "-";
-  }
-  close() {
-  }
-  _emit(level, module, msg, args) {
-    if (LEVEL_ORDER[level] < this._minLevel) return;
-    if (level === "DEBUG" && !this._debug) return;
-    const { date, time, ms } = this._now();
-    const head = `[${date} ${time}.${ms}][${level}][${module}][aun_path=${this._aunPath || "-"}][device_id=${this._deviceId || "-"}]`;
-    const aidPart = this._aid ? ` [${this._aid}]` : "";
-    const formatted = formatMessage(msg, args);
-    const line = `${head}${aidPart} ${formatted}`;
-    let errArg;
-    for (let i = args.length - 1; i >= 0; i--) {
-      if (args[i] instanceof Error) {
-        errArg = args[i];
-        break;
-      }
-    }
-    switch (level) {
-      case "ERROR":
-        if (errArg) {
-          console.error(line, errArg);
-        } else {
-          console.error(line);
-        }
-        break;
-      case "WARN":
-        console.warn(line);
-        break;
-      case "INFO":
-        console.info(line);
-        break;
-      case "DEBUG":
-        console.debug(line);
-        break;
-    }
-  }
-  _now() {
-    const d = /* @__PURE__ */ new Date();
-    const pad = (n, w = 2) => String(n).padStart(w, "0");
-    const date = `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}`;
-    const time = `${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}`;
-    const ms = pad(d.getMilliseconds(), 3);
-    return { date, time, ms };
-  }
-};
-
 // src/agent-md.ts
 var DEFAULT_HTTP_TIMEOUT_MS = 3e4;
 function buildDefaultAgentMd(aid, options = {}) {
@@ -29582,6 +29716,13 @@ function _v2ConcatBytes(...parts) {
 function formatCaughtError2(error) {
   return error instanceof Error ? error : String(error);
 }
+function publicError(error) {
+  const record = error && typeof error === "object" ? error : null;
+  const rawCode = record?.localCode ?? record?.stringCode ?? record?.code;
+  const code = rawCode === void 0 || rawCode === null || rawCode === "" || rawCode === -1 ? "INTERNAL_ERROR" : typeof rawCode === "string" || typeof rawCode === "number" ? rawCode : "INTERNAL_ERROR";
+  const message = String(record?.message ?? error ?? "internal error").trim() || "internal error";
+  return { code, message };
+}
 var RELOGIN_REFRESH_ERRORS = /* @__PURE__ */ new Set([
   "missing refresh_token",
   "invalid_or_expired_refresh_token",
@@ -29844,6 +29985,7 @@ var _AUNClient = class _AUNClient {
     this._deviceId = inputAid?.deviceId || getDeviceId();
     this._logger = new AUNLogger({ debug: _debug, aunPath: this.configModel.aunPath });
     this._logger.bindDeviceId(this._deviceId);
+    this._logger.bindAid(initAid ?? "");
     this._clientLog = this._logger.for("aun_core.client");
     this._logAuth = this._logger.for("aun_core.auth");
     this._logTransport = this._logger.for("aun_core.transport");
@@ -29891,10 +30033,10 @@ var _AUNClient = class _AUNClient {
     });
     this._transport = new RPCTransport({
       eventDispatcher: this._dispatcher,
-      timeout: DEFAULT_SESSION_OPTIONS.timeouts.call,
-      onDisconnect: (error, closeCode) => this._handleTransportDisconnect(error, closeCode)
+      timeout: DEFAULT_SESSION_OPTIONS.timeouts.call
     });
-    this._transport.setMetaObserver(
+    this._transport.setProtocolDisconnectCallback((error, closeCode) => this._handleTransportDisconnect(error, closeCode));
+    this._transport.setProtocolMetaObserver(
       (meta) => this._observeRpcMeta(meta).catch((exc) => {
         this._clientLog.debug(`rpc meta observer skipped: ${String(exc)}`);
       })
@@ -29929,54 +30071,54 @@ var _AUNClient = class _AUNClient {
     if (typeof this._tokenStore.setLogger === "function") {
       this._tokenStore.setLogger(this._tokenStoreLog);
     }
-    this._dispatcher.subscribe("_raw.message.received", (data) => {
+    this._dispatcher.subscribeProtocol("_raw.message.received", (data) => {
       this._onRawMessageReceived(data);
     });
-    this._dispatcher.subscribe("_raw.message.recalled", (data) => {
+    this._dispatcher.subscribeProtocol("_raw.message.recalled", (data) => {
       this._safeAsync(this._onRawMessageRecalled(data));
     });
-    this._dispatcher.subscribe("_raw.group.message_created", (data) => {
+    this._dispatcher.subscribeProtocol("_raw.group.message_created", (data) => {
       this._onRawGroupMessageCreated(data);
     });
-    this._dispatcher.subscribe("_raw.group.message_recalled", (data) => {
+    this._dispatcher.subscribeProtocol("_raw.group.message_recalled", (data) => {
       this._safeAsync(this._onRawGroupMessageRecalled(data));
     });
-    this._dispatcher.subscribe("_raw.group.changed", (data) => {
+    this._dispatcher.subscribeProtocol("_raw.group.changed", (data) => {
       this._onRawGroupChanged(data);
     });
-    this._dispatcher.subscribe("_raw.group.invite_created", (data) => {
+    this._dispatcher.subscribeProtocol("_raw.group.invite_created", (data) => {
       this._safeAsync(this._onRawGroupInviteReceived(data, "push"));
     });
-    this._dispatcher.subscribe("_raw.group.invite_received", (data) => {
+    this._dispatcher.subscribeProtocol("_raw.group.invite_received", (data) => {
       this._safeAsync(this._onRawGroupInviteReceived(data, "push"));
     });
-    this._dispatcher.subscribe("_raw.group.invite_finalized", (data) => {
+    this._dispatcher.subscribeProtocol("_raw.group.invite_finalized", (data) => {
       this._safeAsync(this._onRawGroupInviteFinalized(data));
     });
-    this._dispatcher.subscribe("_raw.peer.v2.message_received", (data) => {
+    this._dispatcher.subscribeProtocol("_raw.peer.v2.message_received", (data) => {
       this._safeAsync(this._onV2PushNotification(data));
     });
-    this._dispatcher.subscribe("_raw.group.v2.message_created", (data) => {
+    this._dispatcher.subscribeProtocol("_raw.group.v2.message_created", (data) => {
       this._safeAsync(this._onRawGroupV2MessageCreated(data));
     });
-    this._dispatcher.subscribe("_raw.group.v2.state_proposed", (data) => {
+    this._dispatcher.subscribeProtocol("_raw.group.v2.state_proposed", (data) => {
       this._safeAsync(this._onV2StateProposed(data));
     });
-    this._dispatcher.subscribe("_raw.group.v2.state_retry_needed", (data) => {
+    this._dispatcher.subscribeProtocol("_raw.group.v2.state_retry_needed", (data) => {
       this._safeAsync(this._onV2StateRetryNeeded(data));
     });
-    this._dispatcher.subscribe("_raw.group.v2.state_confirmed", (data) => {
+    this._dispatcher.subscribeProtocol("_raw.group.v2.state_confirmed", (data) => {
       this._safeAsync(this._onV2StateConfirmed(data));
     });
-    this._dispatcher.subscribe("_raw.group.state_committed", (data) => {
+    this._dispatcher.subscribeProtocol("_raw.group.state_committed", (data) => {
       this._safeAsync(this._onGroupStateCommitted(data));
     });
     for (const evt of ["message.ack", "storage.object_changed", "stream/created", "stream/closed"]) {
-      this._dispatcher.subscribe(`_raw.${evt}`, (data) => {
+      this._dispatcher.subscribeProtocol(`_raw.${evt}`, (data) => {
         this._dispatcher.enqueue(evt, data);
       });
     }
-    this._dispatcher.subscribe("_raw.gateway.disconnect", async (data) => {
+    this._dispatcher.subscribeProtocol("_raw.gateway.disconnect", async (data) => {
       await this._onGatewayDisconnect(data);
     });
   }
@@ -30249,6 +30391,7 @@ var _AUNClient = class _AUNClient {
     this._slotId = aid.slotId || "default";
     this._logger = new AUNLogger({ debug: aid.debug, aunPath: nextConfig.aunPath });
     this._logger.bindDeviceId(this._deviceId);
+    this._logger.bindAid(aid.aid);
     this._clientLog = this._logger.for("aun_core.client");
     this._logAuth = this._logger.for("aun_core.auth");
     this._logTransport = this._logger.for("aun_core.transport");
@@ -30290,10 +30433,10 @@ var _AUNClient = class _AUNClient {
     });
     this._transport = new RPCTransport({
       eventDispatcher: this._dispatcher,
-      timeout: DEFAULT_SESSION_OPTIONS.timeouts.call,
-      onDisconnect: (error, closeCode) => this._handleTransportDisconnect(error, closeCode)
+      timeout: DEFAULT_SESSION_OPTIONS.timeouts.call
     });
-    this._transport.setMetaObserver(
+    this._transport.setProtocolDisconnectCallback((error, closeCode) => this._handleTransportDisconnect(error, closeCode));
+    this._transport.setProtocolMetaObserver(
       (meta) => this._observeRpcMeta(meta).catch((exc) => {
         this._clientLog.debug(`rpc meta observer skipped: ${String(exc)}`);
       })
@@ -31053,7 +31196,7 @@ var _AUNClient = class _AUNClient {
     }
     await this._transport.notify(directMethod, payload);
   }
-  async _callRawV2Rpc(method, params2) {
+  async _callRawV2Rpc(method, params2, pullGateKey = "") {
     const p = { ...params2 ?? {} };
     const forceForeground = Boolean(p._rpc_foreground);
     const rpcBackground = !forceForeground && (Boolean(p._rpc_background) || this._backgroundRpcDepth > 0);
@@ -31078,7 +31221,10 @@ var _AUNClient = class _AUNClient {
     if (method.startsWith("group.") && p.slot_id === void 0) {
       p.slot_id = this._slotId;
     }
-    return await this._rpcPipeline.rawCall(method, p, { background: rpcBackground });
+    return await this._rpcPipeline.rawCall(method, p, {
+      background: rpcBackground,
+      ...pullGateKey ? { pullGateKey } : {}
+    });
   }
   // ── 事件 ──────────────────────────────────────────
   /**
@@ -31672,6 +31818,7 @@ ${invitee}` : "";
             if (identity && isJsonObject(identity)) {
               this._identity = identity;
               this._aid = String(identity.aid ?? this._aid ?? "");
+              this._logger.bindAid(this._aid);
               if (this._sessionParams) {
                 this._sessionParams.access_token = String(auth.token ?? params2.access_token ?? "");
               }
@@ -31872,6 +32019,7 @@ ${invitee}` : "";
     identity.access_token = accessToken;
     this._identity = identity;
     this._aid = String(identity.aid ?? this._aid ?? "");
+    this._logger.bindAid(this._aid);
     if (identity.aid) {
       const persistIdentity = this._auth._persistIdentity;
       if (typeof persistIdentity === "function") {
@@ -32091,7 +32239,7 @@ ${invitee}` : "";
             }
             this._clientLog.warn(`token refresh failed (${this._tokenRefreshFailures}/3), next retry: ${String(exc)}`);
           } else {
-            this._dispatcher.enqueue("connection.error", { error: formatCaughtError2(exc) });
+            this._dispatcher.enqueue("connection.error", { error: publicError(exc) });
           }
         }
         scheduleRefresh();
@@ -32141,7 +32289,7 @@ ${invitee}` : "";
     }
     this._dispatcher.enqueue("state_change", {
       state: this._publicState(this._state),
-      error
+      error: error ? publicError(error) : null
     });
     if (reconnectAbort.signal.aborted || this._reconnectAbort !== reconnectAbort || this._closing) {
       if (this._reconnectAbort === reconnectAbort) {
@@ -32165,7 +32313,7 @@ ${invitee}` : "";
       const disconnectInfo = this._lastDisconnectInfo ?? {};
       const eventPayload = {
         state: this._publicState(this._state),
-        error,
+        error: error ? publicError(error) : null,
         reason
       };
       const detail = disconnectInfo.detail;
@@ -32368,7 +32516,7 @@ ${invitee}` : "";
         this._lastError = exc instanceof Error ? exc : new Error(String(exc));
         this._lastErrorCode = "reconnect_failed";
         if (!reconnectAbort || !await this._publishReconnectEvent(reconnectAbort, "connection.error", {
-          error: formatCaughtError2(exc),
+          error: publicError(exc),
           attempt
         })) return;
         if (!this._shouldRetryReconnect(exc)) {
@@ -32376,7 +32524,7 @@ ${invitee}` : "";
           this._nextRetryAt = null;
           if (reconnectAbort) await this._publishReconnectEvent(reconnectAbort, "state_change", {
             state: this._publicState(this._state),
-            error: formatCaughtError2(exc),
+            error: publicError(exc),
             attempt
           });
           return;