@agentunion/fastaun 0.5.9 → 0.5.10

package/dist/transport.js

@@ -9,7 +9,8 @@
  */
 import WebSocket from 'ws';
 import * as crypto from 'node:crypto';
-import { ConnectionError, SerializationError, TimeoutError, ValidationError, mapRemoteError } from './errors.js';
+import { Worker, isMainThread, parentPort, workerData } from 'node:worker_threads';
+import { AUNError, AuthError, CertificateRevokedError, ClientSignatureError, ConnectionError, E2EEDecryptFailedError, E2EEDegradedError, E2EEError, GroupError, GroupNotFoundError, GroupStateError, IdentityConflictError, NotFoundError, PermissionError, RateLimitError, SerializationError, SessionError, StateError, TimeoutError, ValidationError, VersionConflictError, mapRemoteError, } from './errors.js';
 import { isJsonObject } from './types.js';
 const MAX_WS_PAYLOAD_SIZE = 1_000_000;
 const MAX_RPC_INFLIGHT = 16;
@@ -236,6 +237,226 @@ const EVENT_NAME_MAP = {
     'group.message_recalled': 'group.message_recalled',
     'storage.object_changed': 'storage.object_changed',
 };
+function serializeWorkerError(error) {
+    if (error instanceof AUNError) {
+        const payload = {
+            name: error.name,
+            message: error.message,
+            code: error.code,
+            stringCode: error.stringCode,
+            data: error.data,
+            retryable: error.retryable,
+            traceId: error.traceId,
+        };
+        if (error instanceof E2EEError) {
+            payload.localCode = error.localCode;
+            payload.closeReason = error.closeReason;
+        }
+        return payload;
+    }
+    if (error instanceof Error) {
+        return { name: error.name, message: error.message };
+    }
+    return { name: 'Error', message: String(error) };
+}
+function deserializeWorkerError(payload) {
+    const message = String(payload?.message ?? 'transport worker error');
+    const options = {
+        code: payload?.code,
+        stringCode: payload?.stringCode,
+        data: payload?.data ?? null,
+        retryable: payload?.retryable,
+        traceId: payload?.traceId,
+    };
+    switch (payload?.name) {
+        case 'ConnectionError': return new ConnectionError(message, options);
+        case 'TimeoutError': return new TimeoutError(message, options);
+        case 'AuthError': return new AuthError(message, options);
+        case 'PermissionError': return new PermissionError(message, options);
+        case 'ValidationError': return new ValidationError(message, options);
+        case 'NotFoundError': return new NotFoundError(message, options);
+        case 'RateLimitError': return new RateLimitError(message, options);
+        case 'StateError': return new StateError(message, options);
+        case 'SerializationError': return new SerializationError(message, options);
+        case 'SessionError': return new SessionError(message, options);
+        case 'VersionConflictError': return new VersionConflictError(message, options);
+        case 'GroupError': return new GroupError(message, options);
+        case 'GroupNotFoundError': return new GroupNotFoundError(message, options);
+        case 'GroupStateError': return new GroupStateError(message, options);
+        case 'E2EEDecryptFailedError': return new E2EEDecryptFailedError(message, options);
+        case 'E2EEDegradedError': return new E2EEDegradedError(message, options);
+        case 'E2EEError': return new E2EEError(message, {
+            ...options,
+            localCode: payload?.localCode,
+            closeReason: payload?.closeReason,
+        });
+        case 'CertificateRevokedError': return new CertificateRevokedError(message, options);
+        case 'IdentityConflictError': return new IdentityConflictError(message, options);
+        case 'ClientSignatureError': return new ClientSignatureError(message, options);
+        case 'AUNError': return new AUNError(message, options);
+        case 'TypeError': return new TypeError(message);
+        case 'Error': return new Error(message);
+        default:
+            if (payload?.code !== undefined) {
+                return mapRemoteError({
+                    code: payload.code,
+                    message,
+                    data: payload.data ?? null,
+                });
+            }
+            return new Error(message);
+    }
+}
+function executeShortRpcEnvelope(url, method, params, signal) {
+    return new Promise((resolve, reject) => {
+        if (signal.aborted) {
+            reject(new AuthError('short RPC cancelled'));
+            return;
+        }
+        const requestId = `pre-${method}`;
+        const payload = JSON.stringify({ jsonrpc: '2.0', id: requestId, method, params });
+        const ws = new WebSocket(url, { handshakeTimeout: 5_000, rejectUnauthorized: false });
+        let opened = false;
+        let challengeReceived = false;
+        let settled = false;
+        let timer = null;
+        const cleanup = () => {
+            if (timer !== null)
+                clearTimeout(timer);
+            signal.removeEventListener('abort', onAbort);
+            ws.off('open', onOpen);
+            ws.off('message', onMessage);
+            ws.off('error', onError);
+            ws.off('close', onClose);
+        };
+        const finish = (callback) => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            try {
+                ws.close();
+            }
+            catch { /* ignore */ }
+            callback();
+        };
+        const fail = (error) => finish(() => reject(error));
+        const onOpen = () => {
+            opened = true;
+            timer = setTimeout(() => fail(new AuthError(`shortRpc timeout: ${method}`)), 15_000);
+        };
+        const onAbort = () => {
+            ws.once('error', () => { });
+            try {
+                ws.terminate();
+            }
+            catch { /* ignore */ }
+            fail(new AuthError('short RPC cancelled'));
+        };
+        const onError = (error) => fail(new AuthError(opened ? `websocket error: ${error.message}` : `websocket connect failed: ${error.message}`));
+        const onClose = () => fail(new AuthError(challengeReceived
+            ? `websocket closed before ${method} response`
+            : 'websocket closed before challenge'));
+        const onMessage = (data) => {
+            try {
+                const raw = Buffer.isBuffer(data)
+                    ? data.toString('utf-8')
+                    : data instanceof ArrayBuffer
+                        ? Buffer.from(data).toString('utf-8')
+                        : String(data);
+                const message = JSON.parse(raw);
+                if (!isJsonObject(message)) {
+                    fail(new ValidationError(`invalid WebSocket frame before ${method}`));
+                    return;
+                }
+                if (!challengeReceived) {
+                    if (message.method !== 'challenge')
+                        return;
+                    challengeReceived = true;
+                    ws.send(payload);
+                    return;
+                }
+                if (message.id !== requestId)
+                    return;
+                finish(() => resolve(message));
+            }
+            catch (error) {
+                fail(error instanceof Error ? error : new AuthError(String(error)));
+            }
+        };
+        ws.on('open', onOpen);
+        ws.on('message', onMessage);
+        ws.on('error', onError);
+        ws.on('close', onClose);
+        signal.addEventListener('abort', onAbort, { once: true });
+        if (signal.aborted)
+            onAbort();
+    });
+}
+export function shortRpcViaNetworkActor(url, method, params) {
+    if (!isMainThread || process.env.VITEST || process.env.AUN_TRANSPORT_LOCAL === '1') {
+        const controller = new AbortController();
+        return Object.assign(executeShortRpcEnvelope(url, method, params, controller.signal), {
+            cancel: () => controller.abort(),
+        });
+    }
+    const id = `short-rpc-${crypto.randomUUID()}`;
+    let worker = null;
+    let settled = false;
+    let resolveResult;
+    let rejectResult;
+    const promise = new Promise((resolve, reject) => {
+        resolveResult = resolve;
+        rejectResult = reject;
+    });
+    const cleanup = () => {
+        const current = worker;
+        worker = null;
+        if (!current)
+            return;
+        current.removeAllListeners();
+        void current.terminate().catch(() => { });
+    };
+    const resolveOnce = (value) => {
+        if (settled)
+            return;
+        settled = true;
+        cleanup();
+        resolveResult(value);
+    };
+    const rejectOnce = (error) => {
+        if (settled)
+            return;
+        settled = true;
+        cleanup();
+        rejectResult(error);
+    };
+    try {
+        worker = new Worker(new URL(import.meta.url), {
+            execArgv: process.execArgv.filter((arg) => !arg.startsWith('--input-type')),
+            workerData: { aunShortRpcWorker: true, id, url, method, params },
+        });
+        worker.on('message', (message) => {
+            if (message.type !== 'reply' || message.id !== id)
+                return;
+            if (message.ok && isJsonObject(message.result))
+                resolveOnce(message.result);
+            else
+                rejectOnce(deserializeWorkerError(message.error));
+        });
+        worker.on('error', (error) => rejectOnce(new AuthError(`short RPC worker error: ${error.message}`)));
+        worker.on('exit', (code) => {
+            if (!settled)
+                rejectOnce(new AuthError(`short RPC worker exited: ${code}`));
+        });
+    }
+    catch (error) {
+        rejectOnce(new AuthError(`short RPC worker unavailable: ${error instanceof Error ? error.message : String(error)}`));
+    }
+    return Object.assign(promise, {
+        cancel: () => rejectOnce(new AuthError('short RPC cancelled')),
+    });
+}
 /**
  * WebSocket JSON-RPC 2.0 传输层
  */
@@ -273,6 +494,17 @@ export class RPCTransport {
     _traceMode = 'off';
     // Trace observer：observer(traceInfo) 在每次 RPC/事件携带 _trace 时调用
     _traceObserver = null;
+    // Network actor command bridge: transport state transitions are started in FIFO order.
+    _actorTail = Promise.resolve();
+    _actorBusy = false;
+    _worker = null;
+    _workerPending = new Map();
+    _workerSeq = 0;
+    _workerConnected = false;
+    _workerGeneration = null;
+    _workerConnecting = false;
+    _workerBufferedEvents = [];
+    _workerOptions;
     constructor(opts) {
         this._logger = opts.logger ?? _noopLogger;
         this._dispatcher = opts.eventDispatcher;
@@ -281,17 +513,262 @@ export class RPCTransport {
         this._onDisconnect = opts.onDisconnect ?? null;
         this._verifySsl = opts.verifySsl ?? true;
         this._dnsNet = opts.dnsNet ?? null;
+        this._workerOptions = { timeout: opts.timeout, verifySsl: opts.verifySsl };
+        this._dispatcher.subscribe('_transport.observer', (item) => this._dispatchObserver(item));
+        // 断线回调统一经过应用分发边界，避免 WebSocket close 处理器直接进入用户/客户端逻辑。
+        this._dispatcher.subscribe('_transport.disconnect', (item) => {
+            const event = item;
+            const callback = this._onDisconnect;
+            if (!callback || !event)
+                return;
+            try {
+                const result = callback(event.error ?? null, event.closeCode);
+                if (result && typeof result.then === 'function') {
+                    return Promise.resolve(result).catch(() => {
+                        this._logger.warn('disconnect callback error');
+                    });
+                }
+            }
+            catch {
+                this._logger.warn('disconnect callback error');
+            }
+        });
+        if (isMainThread && !process.env.VITEST && process.env.AUN_TRANSPORT_LOCAL !== '1') {
+            this._startNetworkWorker(opts);
+        }
+    }
+    _startNetworkWorker(opts) {
+        try {
+            const worker = new Worker(new URL(import.meta.url), {
+                execArgv: process.execArgv.filter((arg) => !arg.startsWith('--input-type')),
+                workerData: {
+                    aunTransportWorker: true,
+                    timeout: opts.timeout ?? 10_000,
+                    verifySsl: opts.verifySsl ?? true,
+                },
+            });
+            this._worker = worker;
+            worker.on('message', (message) => {
+                if (this._worker !== worker)
+                    return;
+                if (message.type === 'event') {
+                    this._handleWorkerEvent(message);
+                    return;
+                }
+                if (!message.id)
+                    return;
+                const pending = this._workerPending.get(message.id);
+                if (!pending)
+                    return;
+                if (typeof message.generation === 'number'
+                    && this._workerGeneration !== null
+                    && pending.commandType !== 'connect'
+                    && pending.commandType !== 'close'
+                    && message.generation !== this._workerGeneration) {
+                    this._workerPending.delete(message.id);
+                    if (pending.timer !== null)
+                        clearTimeout(pending.timer);
+                    pending.reject(new ConnectionError('stale transport worker response'));
+                    return;
+                }
+                this._workerPending.delete(message.id);
+                if (pending.timer !== null)
+                    clearTimeout(pending.timer);
+                if (pending.commandType === 'connect' && message.ok && typeof message.generation === 'number') {
+                    this._workerGeneration = message.generation;
+                }
+                if (message.ok)
+                    pending.resolve(message.result);
+                else {
+                    if (pending.commandType === 'connect') {
+                        this._workerGeneration = null;
+                        this._workerBufferedEvents = [];
+                    }
+                    pending.reject(deserializeWorkerError(message.error));
+                }
+            });
+            worker.on('error', (error) => {
+                if (this._worker !== worker)
+                    return;
+                this._worker = null;
+                this._workerConnected = false;
+                this._workerConnecting = false;
+                this._workerGeneration = null;
+                this._workerBufferedEvents = [];
+                for (const pending of this._workerPending.values()) {
+                    if (pending.timer !== null)
+                        clearTimeout(pending.timer);
+                    pending.reject(error);
+                }
+                this._workerPending.clear();
+                this._dispatcher.enqueue('connection.error', { error });
+            });
+            worker.on('exit', (code) => {
+                if (this._worker !== worker)
+                    return;
+                this._worker = null;
+                this._workerConnected = false;
+                this._workerConnecting = false;
+                this._workerGeneration = null;
+                this._workerBufferedEvents = [];
+                const error = new ConnectionError(`transport worker exited: ${code}`);
+                for (const pending of this._workerPending.values()) {
+                    if (pending.timer !== null)
+                        clearTimeout(pending.timer);
+                    pending.reject(error);
+                }
+                this._workerPending.clear();
+                if (code !== 0)
+                    this._dispatcher.enqueue('connection.error', { error: new Error(`transport worker exited: ${code}`) });
+            });
+        }
+        catch (error) {
+            this._worker = null;
+            this._logger.warn(`transport worker unavailable; using local transport: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    _ensureNetworkWorker() {
+        if (this._worker || !isMainThread || process.env.VITEST || process.env.AUN_TRANSPORT_LOCAL === '1')
+            return;
+        this._startNetworkWorker(this._workerOptions);
+        const worker = this._worker;
+        if (!worker)
+            return;
+        worker.postMessage({ type: 'set_timeout', value: this._timeout });
+        worker.postMessage({ type: 'set_connect_timeout', value: this._connectTimeout });
+        worker.postMessage({ type: 'set_trace_mode', value: this._traceMode });
+    }
+    _dnsFallbackSnapshot(url) {
+        if (!this._dnsNet)
+            return null;
+        try {
+            const hostname = new URL(url).hostname;
+            const cached = this._dnsNet.loadDnsCache(hostname);
+            return cached ? { hostname, ip: cached.ip, port: cached.port } : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    _handleWorkerEvent(message) {
+        if (typeof message.generation !== 'number')
+            return;
+        if (this._workerConnecting) {
+            this._workerBufferedEvents.push(message);
+            return;
+        }
+        if (this._workerGeneration === null || message.generation !== this._workerGeneration)
+            return;
+        if (message.event === '_transport.observer') {
+            const item = message.payload;
+            const observer = item?.kind?.includes('trace') ? this._traceObserver : this._metaObserver;
+            if (observer && item?.payload)
+                this._dispatcher.enqueue('_transport.observer', {
+                    kind: item.kind ?? 'observer', observer, payload: item.payload,
+                });
+            return;
+        }
+        if (message.event === '_transport.disconnect') {
+            this._workerConnected = false;
+            this._workerGeneration = null;
+            const payload = (message.payload && typeof message.payload === 'object')
+                ? { ...message.payload }
+                : {};
+            const workerError = payload.error;
+            if (workerError && typeof workerError === 'object') {
+                payload.error = new ConnectionError(String(workerError.message ?? 'transport disconnected'));
+            }
+            this._dispatcher.enqueue('_transport.disconnect', payload);
+        }
+        else if (message.event) {
+            this._dispatcher.enqueue(message.event, message.payload);
+        }
+    }
+    _flushWorkerEvents() {
+        const buffered = this._workerBufferedEvents;
+        this._workerBufferedEvents = [];
+        for (const message of buffered)
+            this._handleWorkerEvent(message);
+    }
+    _workerCommand(command) {
+        this._ensureNetworkWorker();
+        if (!this._worker)
+            return Promise.reject(new ConnectionError('transport worker unavailable'));
+        const worker = this._worker;
+        const id = `worker-${++this._workerSeq}`;
+        const timeoutMs = command.type === 'call'
+            ? null
+            : command.type === 'connect' ? this._connectTimeout + 1_000 : 30_000;
+        let posted = false;
+        const promise = new Promise((resolve, reject) => {
+            const timer = timeoutMs === null ? null : setTimeout(() => {
+                this._workerPending.delete(id);
+                if (posted) {
+                    try {
+                        worker.postMessage({ type: 'cancel', targetId: id });
+                    }
+                    catch { /* worker exit path */ }
+                }
+                reject(new TimeoutError(`rpc timeout: ${String(command.method ?? command.type)}`, { retryable: true }));
+            }, timeoutMs);
+            this._workerPending.set(id, { resolve: resolve, reject, timer, commandType: command.type });
+            const postCommand = () => {
+                if (!this._workerPending.has(id))
+                    return;
+                try {
+                    worker.postMessage({ ...command, id });
+                    posted = true;
+                }
+                catch (error) {
+                    this._workerPending.delete(id);
+                    if (timer !== null)
+                        clearTimeout(timer);
+                    reject(error);
+                }
+            };
+            if (command.type === 'call')
+                queueMicrotask(postCommand);
+            else
+                postCommand();
+        });
+        return Object.assign(promise, {
+            cancel: () => {
+                const pending = this._workerPending.get(id);
+                if (!pending)
+                    return;
+                this._workerPending.delete(id);
+                if (pending.timer !== null)
+                    clearTimeout(pending.timer);
+                if (posted) {
+                    try {
+                        worker.postMessage({ type: 'cancel', targetId: id });
+                    }
+                    catch { /* worker exit path */ }
+                }
+                pending.reject(new TimeoutError(`rpc cancelled: ${String(command.method ?? command.type)}`, { retryable: true }));
+            },
+        });
     }
     /** 设置默认 RPC 超时（毫秒） */
     setTimeout(timeout) {
         this._timeout = timeout;
+        if (this._worker) {
+            this._worker.postMessage({ type: 'set_timeout', value: timeout });
+            return;
+        }
     }
     /** 设置 WebSocket 建连及 challenge 超时（毫秒）。 */
     setConnectTimeout(timeout) {
         this._connectTimeout = timeout;
+        if (this._worker) {
+            this._worker.postMessage({ type: 'set_connect_timeout', value: timeout });
+            return;
+        }
     }
     /** 当前是否仍有可用的 WebSocket。 */
     isConnected() {
+        if (this._worker)
+            return this._workerConnected;
         return !this._closed && this._ws !== null && this._ws.readyState === WebSocket.OPEN;
     }
     /**
@@ -309,11 +786,33 @@ export class RPCTransport {
             throw new ValidationError(`invalid trace mode: ${mode}, must be off/log/diag`);
         }
         this._traceMode = mode;
+        if (this._worker) {
+            this._worker.postMessage({ type: 'set_trace_mode', value: mode });
+            return;
+        }
     }
     /** 注册 trace observer；observer(traceInfo) 在每次 RPC/事件携带 _trace 时调用。 */
     setTraceObserver(observer) {
         this._traceObserver = observer;
     }
+    _queueObserver(kind, observer, payload) {
+        this._dispatcher.enqueue('_transport.observer', {
+            kind,
+            observer,
+            payload,
+        });
+    }
+    async _dispatchObserver(item) {
+        const observerEvent = item;
+        if (!observerEvent || typeof observerEvent.observer !== 'function')
+            return;
+        try {
+            await observerEvent.observer(observerEvent.payload);
+        }
+        catch (err) {
+            this._logger.debug(`${observerEvent.kind || 'observer'} raised: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
     /** 获取上次连接的 challenge 消息 */
     get challenge() {
         return this._challenge;
@@ -334,11 +833,99 @@ export class RPCTransport {
             release();
         }
     }
+    _enqueueActor(operation) {
+        this._actorBusy = true;
+        const run = this._actorTail.then(async () => {
+            return await operation();
+        }, async () => {
+            return await operation();
+        });
+        const tail = run.then(() => undefined, () => undefined);
+        this._actorTail = tail;
+        void tail.then(() => {
+            if (this._actorTail === tail)
+                this._actorBusy = false;
+        });
+        return run;
+    }
+    /** 启动长生命周期 RPC，但不把 actor 队列占用到响应返回。 */
+    _enqueueActorStart(operation, cancellationError) {
+        let resolveResult;
+        let rejectResult;
+        const result = new Promise((resolve, reject) => {
+            resolveResult = resolve;
+            rejectResult = reject;
+        });
+        let cancel;
+        let cancelRequested = false;
+        const launch = () => {
+            if (cancelRequested)
+                return;
+            try {
+                const inner = operation();
+                cancel = inner.cancel;
+                inner.then(resolveResult, rejectResult);
+            }
+            catch (err) {
+                rejectResult(err);
+            }
+        };
+        // 调用命令本身在当前 turn 立即启动（若有 close 等独占命令则排队）。
+        // 网络响应仍异步完成，避免改变既有 call() 的入队/并发语义。
+        if (this._actorBusy) {
+            const gate = this._actorTail.then(launch, launch);
+            const tail = gate.then(() => undefined, () => undefined);
+            this._actorTail = tail;
+            void tail.then(() => {
+                if (this._actorTail === tail)
+                    this._actorBusy = false;
+            });
+        }
+        else {
+            launch();
+        }
+        return Object.assign(result, {
+            cancel: () => {
+                if (cancelRequested)
+                    return;
+                cancelRequested = true;
+                if (cancel) {
+                    cancel();
+                }
+                else {
+                    rejectResult(cancellationError?.() ?? new TimeoutError('rpc cancelled', { retryable: true }));
+                }
+            },
+        });
+    }
     /**
      * 连接到 Gateway WebSocket 端点。
      * 返回初始 challenge 消息（如果有）。
      */
     async connect(url) {
+        this._ensureNetworkWorker();
+        if (this._worker) {
+            this._workerConnecting = true;
+            try {
+                const result = await this._workerCommand({
+                    type: 'connect', url, dnsFallback: this._dnsFallbackSnapshot(url),
+                });
+                this._workerConnected = true;
+                this._workerConnecting = false;
+                this._flushWorkerEvents();
+                return result;
+            }
+            catch (error) {
+                this._workerConnecting = false;
+                this._workerConnected = false;
+                this._workerGeneration = null;
+                this._workerBufferedEvents = [];
+                throw error;
+            }
+        }
+        return this._enqueueActorStart(() => this._connectLocal(url));
+    }
+    async _connectLocal(url) {
         const tStart = Date.now();
         this._logger.debug(`connect enter: url=${url}`);
         // 只串行化清理和监听器安装；后续 connect 可立即取消本次握手。
@@ -568,6 +1155,31 @@ export class RPCTransport {
     }
     /** 关闭连接 */
     async close() {
+        if (this._worker) {
+            const worker = this._worker;
+            try {
+                await this._workerCommand({ type: 'close' });
+            }
+            finally {
+                if (this._worker === worker)
+                    this._worker = null;
+                this._workerConnected = false;
+                this._workerConnecting = false;
+                this._workerGeneration = null;
+                this._workerBufferedEvents = [];
+                for (const pending of this._workerPending.values()) {
+                    if (pending.timer !== null)
+                        clearTimeout(pending.timer);
+                    pending.reject(new ConnectionError('transport closed'));
+                }
+                this._workerPending.clear();
+                await worker.terminate();
+            }
+            return;
+        }
+        await this._enqueueActor(() => this._closeLocal());
+    }
+    async _closeLocal() {
         await this._withConnectionSetup(() => this._closeUnlocked());
     }
     /** 已持有连接建立串行权时关闭当前 WebSocket。 */
@@ -652,7 +1264,13 @@ export class RPCTransport {
     /**
      * 发送 JSON-RPC 2.0 请求并等待响应。
      */
-    async call(method, params, timeout, trace, background = false) {
+    call(method, params, timeout, trace, background = false) {
+        if (this._worker) {
+            return this._workerCommand({ type: 'call', method, params, timeout, trace, background });
+        }
+        return this._enqueueActorStart(() => this._callLocal(method, params, timeout, trace, background), () => new TimeoutError(`rpc cancelled: ${method}`, { retryable: true }));
+    }
+    _callLocal(method, params, timeout, trace, background = false) {
         if (this._closed || !this._ws) {
             const suffix = this._lastCloseCode !== null ? `: close code ${this._lastCloseCode}` : '';
             throw new ConnectionError(`transport not connected${suffix}`, {
@@ -721,12 +1339,7 @@ export class RPCTransport {
                         if (this._metaObserver !== null) {
                             const meta = response._meta;
                             if (meta !== null && typeof meta === 'object' && !Array.isArray(meta)) {
-                                try {
-                                    this._metaObserver(meta);
-                                }
-                                catch (err) {
-                                    this._logger.debug(`meta_observer raised: ${err instanceof Error ? err.message : String(err)}`);
-                                }
+                                this._queueObserver('meta_observer', this._metaObserver, meta);
                             }
                         }
                         // 处理 success 路径的 _trace
@@ -779,6 +1392,13 @@ export class RPCTransport {
     }
     /** 发送 JSON-RPC 2.0 Notification，不分配 id，也不等待响应。 */
     async notify(method, params) {
+        if (this._worker) {
+            await this._workerCommand({ type: 'notify', method, params });
+            return;
+        }
+        return this._enqueueActorStart(() => this._notifyLocal(method, params));
+    }
+    async _notifyLocal(method, params) {
         if (this._closed || !this._ws) {
             const suffix = this._lastCloseCode !== null ? `: close code ${this._lastCloseCode}` : '';
             throw new ConnectionError(`transport not connected${suffix}`, {
@@ -965,7 +1585,9 @@ export class RPCTransport {
             const enriched = { ...respTrace, spans };
             this._logger.info(traceDisplay(method, status, elapsedMs, respTrace, spans));
             if (this._traceObserver !== null) {
-                this._traceObserver({ type: 'rpc', method, trace: enriched, status, duration_ms: elapsedMs });
+                this._queueObserver('trace_observer', this._traceObserver, {
+                    type: 'rpc', method, trace: enriched, status, duration_ms: elapsedMs,
+                });
             }
         }
         catch (err) {
@@ -985,7 +1607,7 @@ export class RPCTransport {
             }
             catch (err) {
                 // 解析异常，发布错误事件
-                this._dispatcher.publish('connection.error', {
+                this._dispatcher.enqueue('connection.error', {
                     error: err instanceof Error ? err : String(err),
                 });
             }
@@ -1018,8 +1640,10 @@ export class RPCTransport {
             }
             this._backgroundRpcQueue = [];
             if (!wasClosed && this._onDisconnect) {
-                const cb = this._onDisconnect;
-                Promise.resolve(cb(null, code)).catch(() => this._logger.warn('disconnect callback error'));
+                this._dispatcher.enqueue('_transport.disconnect', {
+                    error: null,
+                    closeCode: code,
+                });
             }
         });
         ws.on('error', (err) => {
@@ -1027,7 +1651,7 @@ export class RPCTransport {
                 return;
             if (!this._closed) {
                 this._logger.error(`WebSocket error: ${err.message}`);
-                this._dispatcher.publish('connection.error', { error: err });
+                this._dispatcher.enqueue('connection.error', { error: err });
             }
         });
         this._startWebSocketHeartbeat(ws);
@@ -1136,7 +1760,7 @@ export class RPCTransport {
         if (method === 'challenge') {
             this._challenge = message;
             this._logger.debug('challenge received');
-            this._dispatcher.publish('connection.challenge', message.params ?? {});
+            this._dispatcher.enqueue('connection.challenge', message.params ?? {});
             return;
         }
         // 事件消息（event/ 前缀）
@@ -1146,12 +1770,7 @@ export class RPCTransport {
             this._logger.debug(`event recv: event=${sdkEvent} ${summarizeDict(message.params, DIAG_RESULT_FIELDS)}`);
             const meta = message._meta;
             if (this._metaObserver !== null && meta !== null && typeof meta === 'object' && !Array.isArray(meta)) {
-                try {
-                    this._metaObserver(meta);
-                }
-                catch (err) {
-                    this._logger.debug(`event meta_observer raised: ${err instanceof Error ? err.message : String(err)}`);
-                }
+                this._queueObserver('event meta_observer', this._metaObserver, meta);
             }
             // 提取事件中的 _trace 并回调 observer，然后从 params 中剥离
             const params = (message.params ?? {});
@@ -1160,10 +1779,9 @@ export class RPCTransport {
                 delete params._trace;
                 if (eventTrace && typeof eventTrace === 'object' && !Array.isArray(eventTrace)) {
                     if (this._traceObserver !== null) {
-                        try {
-                            this._traceObserver({ type: 'event', event: sdkEvent, trace: eventTrace });
-                        }
-                        catch { /* observer 抛错被吞 */ }
+                        this._queueObserver('trace_observer', this._traceObserver, {
+                            type: 'event', event: sdkEvent, trace: eventTrace,
+                        });
                     }
                     const traceObj = eventTrace;
                     this._logger.info(`[trace=${String(traceObj.trace_id ?? '')}] event_recv event=${sdkEvent}`);
@@ -1171,23 +1789,18 @@ export class RPCTransport {
             }
             // 发布为 _raw.{event}，由 AUNClient 处理后再发布用户可见的事件
             if (sdkEvent.startsWith('app.')) {
-                this._dispatcher.publish(sdkEvent, params);
+                this._dispatcher.enqueue(sdkEvent, params);
                 return;
             }
-            this._dispatcher.publish(`_raw.${sdkEvent}`, params);
+            this._dispatcher.enqueue(`_raw.${sdkEvent}`, params);
             return;
         }
         // 其他通知
         const meta = message._meta;
         if (this._metaObserver !== null && meta !== null && typeof meta === 'object' && !Array.isArray(meta)) {
-            try {
-                this._metaObserver(meta);
-            }
-            catch (err) {
-                this._logger.debug(`notification meta_observer raised: ${err instanceof Error ? err.message : String(err)}`);
-            }
+            this._queueObserver('notification meta_observer', this._metaObserver, meta);
         }
-        this._dispatcher.publish('notification', message);
+        this._dispatcher.enqueue('notification', message);
     }
     /** 解码 WebSocket 消息为 JSON 对象 */
     _decodeMessage(raw) {
@@ -1222,4 +1835,116 @@ export class RPCTransport {
         }
     }
 }
+if (!isMainThread && Boolean(workerData?.aunShortRpcWorker) && parentPort) {
+    const command = workerData;
+    const controller = new AbortController();
+    void executeShortRpcEnvelope(command.url, command.method, command.params, controller.signal)
+        .then((result) => parentPort.postMessage({
+        type: 'reply', id: command.id, ok: true, result,
+    }))
+        .catch((error) => parentPort.postMessage({
+        type: 'reply', id: command.id, ok: false, error: serializeWorkerError(error),
+    }))
+        .finally(() => parentPort.close());
+}
+if (!isMainThread && Boolean(workerData?.aunTransportWorker) && parentPort) {
+    let workerActor = null;
+    const bridgeGeneration = () => Number(workerActor?._connectionGeneration ?? 0);
+    const workerDispatcher = {
+        enqueue(event, payload) {
+            if (event === '_transport.observer') {
+                const item = payload;
+                parentPort.postMessage({ type: 'event', generation: bridgeGeneration(), event, payload: {
+                        kind: item.kind ?? 'observer', payload: item.payload ?? {},
+                    } });
+                return;
+            }
+            parentPort.postMessage({ type: 'event', generation: bridgeGeneration(), event, payload });
+        },
+        subscribe() { return { unsubscribe() { } }; },
+    };
+    const actor = new RPCTransport({
+        eventDispatcher: workerDispatcher,
+        timeout: Number(workerData.timeout ?? 10_000),
+        verifySsl: Boolean(workerData.verifySsl ?? true),
+        // Worker 内只让 close handler 经 workerDispatcher 转发一次，主线程负责执行真实回调。
+        onDisconnect: () => { },
+    });
+    workerActor = actor;
+    actor.setMetaObserver((meta) => workerDispatcher.enqueue('_transport.observer', {
+        kind: 'meta_observer', payload: meta,
+    }));
+    actor.setTraceObserver((trace) => workerDispatcher.enqueue('_transport.observer', {
+        kind: 'trace_observer', payload: trace,
+    }));
+    const active = new Map();
+    let dnsFallback = null;
+    actor._dnsNet = {
+        loadDnsCache(hostname) {
+            return dnsFallback?.hostname === hostname ? { ip: dnsFallback.ip, port: dnsFallback.port } : null;
+        },
+    };
+    parentPort.on('message', async (command) => {
+        const id = command.id;
+        try {
+            if (command.type === 'cancel') {
+                const pending = active.get(String(command.targetId ?? ''));
+                pending?.cancel?.();
+                return;
+            }
+            let result;
+            switch (command.type) {
+                case 'connect': {
+                    dnsFallback = command.dnsFallback ?? null;
+                    const request = actor.connect(String(command.url ?? ''));
+                    if (id)
+                        active.set(id, { cancel: request.cancel ?? (() => { void actor.close().catch(() => { }); }) });
+                    result = await request;
+                    if (id)
+                        active.delete(id);
+                    break;
+                }
+                case 'call': {
+                    const request = actor.call(String(command.method ?? ''), command.params ?? undefined, command.timeout, command.trace, Boolean(command.background));
+                    if (id)
+                        active.set(id, request);
+                    result = await request;
+                    if (id)
+                        active.delete(id);
+                    break;
+                }
+                case 'notify':
+                    result = await actor.notify(String(command.method ?? ''), command.params);
+                    break;
+                case 'close':
+                    result = await actor.close();
+                    break;
+                case 'set_timeout':
+                    actor.setTimeout(Number(command.value));
+                    return;
+                case 'set_connect_timeout':
+                    actor.setConnectTimeout(Number(command.value));
+                    return;
+                case 'set_trace_mode':
+                    actor.setTraceMode(String(command.value ?? 'off'));
+                    return;
+                default: return;
+            }
+            if (id)
+                parentPort.postMessage({ type: 'reply', id, generation: bridgeGeneration(), ok: true, result });
+        }
+        catch (error) {
+            if (id)
+                active.delete(id);
+            if (id)
+                parentPort.postMessage({
+                    type: 'reply',
+                    id,
+                    generation: bridgeGeneration(),
+                    ok: false,
+                    error: serializeWorkerError(error),
+                });
+        }
+    });
+}
 //# sourceMappingURL=transport.js.map