@hile/message-modem 4.0.2 → 4.0.4

package/dist/index.js

@@ -1,4 +1,4 @@
-import { AbortException, Exception, TimeoutException } from "./exception.js";
+import { AbortException, Exception, MessageInputError, TimeoutException } from "./exception.js";
 import { Readable } from 'node:stream';
 import { DeadlineScheduler } from './deadline-scheduler.js';
 export * from './exception.js';
@@ -8,9 +8,44 @@ export var MESSAGE_MODEM_TYPE;
     MESSAGE_MODEM_TYPE[MESSAGE_MODEM_TYPE["RESPONSE"] = 1] = "RESPONSE";
     MESSAGE_MODEM_TYPE[MESSAGE_MODEM_TYPE["ABORT"] = 2] = "ABORT";
     MESSAGE_MODEM_TYPE[MESSAGE_MODEM_TYPE["STREAM_CREDIT"] = 3] = "STREAM_CREDIT";
+    MESSAGE_MODEM_TYPE[MESSAGE_MODEM_TYPE["STREAM_DATA"] = 4] = "STREAM_DATA";
+    MESSAGE_MODEM_TYPE[MESSAGE_MODEM_TYPE["STREAM_CANCEL"] = 5] = "STREAM_CANCEL";
 })(MESSAGE_MODEM_TYPE || (MESSAGE_MODEM_TYPE = {}));
 const MAX_STREAM_WINDOW = 64;
+const DEFAULT_INPUT_STREAM_WINDOW = 1;
+const MAX_CONCURRENT_STREAMS = 128;
 const MAX_TIMER_DELAY = 2_147_483_647;
+export function isBinaryInput(value) {
+    return value instanceof Uint8Array || value instanceof ArrayBuffer;
+}
+export function isMessageInput(value) {
+    return isBinaryInput(value) || isAsyncIterable(value);
+}
+async function* toInputIterable(input) {
+    if (input instanceof ArrayBuffer) {
+        yield new Uint8Array(input);
+        return;
+    }
+    if (input instanceof Uint8Array) {
+        yield input;
+        return;
+    }
+    yield* input;
+}
+function normalizeMessageInput(data, explicitInput) {
+    if (explicitInput !== undefined) {
+        if (isMessageInput(data)) {
+            throw new TypeError('A message accepts only one request input stream');
+        }
+        if (!isMessageInput(explicitInput)) {
+            throw new TypeError('Message input must be an AsyncIterable, Uint8Array, or ArrayBuffer');
+        }
+        return { data, input: toInputIterable(explicitInput) };
+    }
+    if (!isMessageInput(data))
+        return { data };
+    return { data: undefined, input: toInputIterable(data) };
+}
 function streamLimit(value, name) {
     if (value === undefined)
         return undefined;
@@ -33,6 +68,17 @@ function streamTimeout(value, name) {
     }
     return normalized;
 }
+function returnProducerIterator(producer) {
+    if (producer.iteratorReturned || !producer.iterator?.return)
+        return;
+    producer.iteratorReturned = true;
+    try {
+        void Promise.resolve(producer.iterator.return()).catch(() => { });
+    }
+    catch {
+        // Iterator cleanup must not mask the request's original outcome.
+    }
+}
 class CreditReadable extends Readable {
     onConsumed;
     constructor(onConsumed) {
@@ -56,6 +102,8 @@ export class MessageModem {
     stacks = new Map();
     streams = new Map();
     streamProducers = new Map();
+    inputStreams = new Map();
+    inputStreamProducers = new Map();
     _dispose() {
         for (const { reject } of this.stacks.values()) {
             reject(new AbortException());
@@ -66,13 +114,25 @@ export class MessageModem {
         for (const { stream } of this.streams.values()) {
             stream.destroy(new AbortException());
         }
+        for (const { stream } of this.inputStreams.values()) {
+            stream.destroy(new AbortException());
+        }
         for (const producer of this.streamProducers.values()) {
+            producer.cancelled = true;
             producer.wake?.();
+            returnProducerIterator(producer);
+        }
+        for (const producer of this.inputStreamProducers.values()) {
+            producer.cancelled = true;
+            producer.wake?.();
+            returnProducerIterator(producer);
         }
         this.aborts.clear();
         this.stacks.clear();
         this.streams.clear();
         this.streamProducers.clear();
+        this.inputStreams.clear();
+        this.inputStreamProducers.clear();
         this.deadlines.clear();
     }
     /**
@@ -93,14 +153,13 @@ export class MessageModem {
      * @param data - 消息数据
      * @returns 消息数据
      */
-    createPostData(mode, data, twoway = true, stream = false) {
+    createPostData(mode, data, twoway = true) {
         const id = this.createIncrementId();
         const state = {
-            id, twoway, data, mode, stream,
+            id, twoway, data, mode,
         };
         if (mode === MESSAGE_MODEM_TYPE.ABORT) {
             state.twoway = false;
-            state.stream = false;
         }
         return state;
     }
@@ -112,10 +171,12 @@ export class MessageModem {
      * @returns 消息响应
      */
     _send(data, options) {
-        return this._write(data, {
+        const normalized = normalizeMessageInput(data, options?.input);
+        return this._write(normalized.data, {
             timeout: options?.timeout ?? 30000,
             twoway: true,
             signal: options?.signal,
+            input: normalized.input,
         });
     }
     /**
@@ -132,21 +193,119 @@ export class MessageModem {
             signal: options?.signal,
         });
     }
+    startInputProducer(id, input, onError, onActivity = () => { }) {
+        const producer = {
+            credits: 0,
+            nextCreditSeq: 0,
+            nextSeq: 0,
+            cancelled: false,
+            iteratorReturned: false,
+            fail: onError,
+            iterator: input[Symbol.asyncIterator](),
+        };
+        this.inputStreamProducers.set(id, producer);
+        void (async () => {
+            let readingInput = false;
+            try {
+                while (!producer.cancelled) {
+                    while (producer.credits === 0 && !producer.cancelled) {
+                        await new Promise((resolve) => {
+                            producer.wake = resolve;
+                        });
+                        producer.wake = undefined;
+                    }
+                    if (producer.cancelled)
+                        return;
+                    producer.credits--;
+                    readingInput = true;
+                    const next = await producer.iterator.next();
+                    if (!next.done && next.value == null) {
+                        throw new TypeError('Stream chunk must not be null or undefined');
+                    }
+                    readingInput = false;
+                    if (producer.cancelled)
+                        return;
+                    onActivity();
+                    this.post({
+                        id,
+                        mode: MESSAGE_MODEM_TYPE.STREAM_DATA,
+                        twoway: false,
+                        data: {
+                            direction: 'input',
+                            seq: producer.nextSeq++,
+                            payload: next.done ? undefined : next.value,
+                            final: next.done === true,
+                        },
+                    });
+                    if (next.done) {
+                        this.inputStreamProducers.delete(id);
+                        return;
+                    }
+                }
+            }
+            catch (error) {
+                if (producer.cancelled)
+                    return;
+                this.failInputProducer(id, readingInput
+                    ? new MessageInputError(error)
+                    : error instanceof Error
+                        ? error
+                        : new Error('Request input stream failed'));
+            }
+        })();
+    }
+    failInputProducer(id, error) {
+        const producer = this.inputStreamProducers.get(id);
+        if (!producer)
+            return;
+        this.cancelInputProducer(id);
+        try {
+            this.post({
+                id,
+                mode: MESSAGE_MODEM_TYPE.ABORT,
+                twoway: false,
+            });
+        }
+        catch {
+            // The transport may already be closed.
+        }
+        producer.fail?.(error);
+    }
+    cancelInputProducer(id) {
+        const producer = this.inputStreamProducers.get(id);
+        if (!producer)
+            return;
+        this.inputStreamProducers.delete(id);
+        producer.cancelled = true;
+        producer.wake?.();
+        returnProducerIterator(producer);
+    }
     _stream(data, options = {}) {
+        const normalized = normalizeMessageInput(data, options.input);
         const window = streamWindow(options.window);
         const timeout = streamTimeout(options.timeout, 'Stream timeout');
         const idleTimeout = streamTimeout(options.idleTimeout, 'Stream idle timeout');
-        const state = this.createPostData(MESSAGE_MODEM_TYPE.REQUEST, data, true, true);
-        state.streamVersion = 1;
-        if (window > 1)
-            state.streamWindow = window;
+        const state = this.createPostData(MESSAGE_MODEM_TYPE.REQUEST, normalized.data, true);
+        state.streams = {
+            ...(normalized.input ? { input: true } : {}),
+            output: window > 1 ? { window } : {},
+        };
         let consumer;
         const stream = new CreditReadable(() => {
             if (consumer.creditsOwed === 0 || consumer.completed || consumer.cancelled)
                 return;
             consumer.creditsOwed--;
             try {
-                this.post(this.createPostData(MESSAGE_MODEM_TYPE.STREAM_CREDIT, { id: state.id, seq: consumer.nextCreditSeq++ }, false));
+                this.post({
+                    id: state.id,
+                    mode: MESSAGE_MODEM_TYPE.STREAM_CREDIT,
+                    twoway: false,
+                    data: {
+                        direction: 'output',
+                        seq: consumer.nextCreditSeq++,
+                        window: consumer.maxCredits,
+                    },
+                });
             }
             catch (error) {
                 consumer.cancelled = true;
@@ -185,13 +344,18 @@ export class MessageModem {
             nextCreditSeq: 0,
             touch,
             clearTimers,
+            cleanup: () => { },
         };
         const sendAbort = () => {
             if (consumer.completed || consumer.cancelled)
                 return;
             consumer.cancelled = true;
             try {
-                this.post(this.createPostData(MESSAGE_MODEM_TYPE.ABORT, state.id));
+                this.post({
+                    id: state.id,
+                    mode: MESSAGE_MODEM_TYPE.ABORT,
+                    twoway: false,
+                });
             }
             catch {
                 // The transport may already be closed.
@@ -201,12 +365,24 @@ export class MessageModem {
             sendAbort();
             stream.destroy(new AbortException());
         };
+        const cleanup = () => {
+            clearTimers();
+            this.streams.delete(state.id);
+            options?.signal?.removeEventListener('abort', onAbort);
+        };
+        consumer.cleanup = cleanup;
         if (options?.signal?.aborted) {
             consumer.cancelled = true;
             queueMicrotask(() => stream.destroy(new AbortException()));
             return stream;
         }
         this.streams.set(state.id, consumer);
+        if (normalized.input) {
+            this.startInputProducer(state.id, normalized.input, (error) => {
+                consumer.cancelled = true;
+                stream.destroy(error);
+            }, consumer.touch);
+        }
         options?.signal?.addEventListener('abort', onAbort, { once: true });
         if (timeout) {
             totalTimer = this.deadlines.schedule(timeout, () => expire('Stream timeout'));
@@ -214,16 +390,16 @@ export class MessageModem {
         touch();
         stream.on('close', () => {
             sendAbort();
-            clearTimers();
-            this.streams.delete(state.id);
-            options?.signal?.removeEventListener('abort', onAbort);
+            this.cancelInputProducer(state.id);
+            cleanup();
         });
         try {
             this.post(state);
         }
         catch (error) {
             consumer.cancelled = true;
-            this.streams.delete(state.id);
+            this.cancelInputProducer(state.id);
+            cleanup();
             queueMicrotask(() => stream.destroy(error));
         }
         return stream;
@@ -240,6 +416,8 @@ export class MessageModem {
         const signal = options?.signal;
         // 创建请求消息数据
         const state = this.createPostData(MESSAGE_MODEM_TYPE.REQUEST, data, twoway);
+        if (options?.input)
+            state.streams = { input: true };
         // 如果消息是单向的，则直接返回
         if (!twoway) {
             if (!signal?.aborted)
@@ -257,13 +435,19 @@ export class MessageModem {
                 timer = undefined;
                 signal?.removeEventListener('abort', onAbort);
                 clear();
+                this.cancelInputProducer(state.id);
             };
             const onAbort = () => {
                 this.deadlines.cancel(timer);
                 timer = undefined;
                 try {
-                    if (posted)
-                        this.post(this.createPostData(MESSAGE_MODEM_TYPE.ABORT, state.id));
+                    if (posted) {
+                        this.post({
+                            id: state.id,
+                            mode: MESSAGE_MODEM_TYPE.ABORT,
+                            twoway: false,
+                        });
+                    }
                 }
                 catch {
                     /* 例如 WebSocket 已关闭时 send 可能抛错 */
@@ -271,6 +455,7 @@ export class MessageModem {
                 finally {
                     signal?.removeEventListener('abort', onAbort);
                     clear();
+                    this.cancelInputProducer(state.id);
                     reject(new AbortException());
                 }
             };
@@ -288,12 +473,29 @@ export class MessageModem {
                 resolve: _resolve,
                 reject: _reject,
             });
-            timer = this.deadlines.schedule(timeout, () => _reject(new TimeoutException()));
+            timer = this.deadlines.schedule(timeout, () => {
+                try {
+                    if (posted) {
+                        this.post({
+                            id: state.id,
+                            mode: MESSAGE_MODEM_TYPE.ABORT,
+                            twoway: false,
+                        });
+                    }
+                }
+                catch {
+                    // The transport may already be closed.
+                }
+                _reject(new TimeoutException());
+            });
             signal?.addEventListener('abort', onAbort, { once: true });
             if (signal?.aborted) {
                 onAbort();
                 return;
             }
+            if (options?.input) {
+                this.startInputProducer(state.id, options.input, _reject);
+            }
             try {
                 posted = true;
                 this.post(state);
@@ -303,14 +505,127 @@ export class MessageModem {
             }
         });
     }
+    createInputConsumer(id) {
+        const window = DEFAULT_INPUT_STREAM_WINDOW;
+        let consumer;
+        const stream = new CreditReadable(() => {
+            if (consumer.creditsOwed === 0 || consumer.completed || consumer.cancelled)
+                return;
+            consumer.creditsOwed--;
+            this.post({
+                id,
+                mode: MESSAGE_MODEM_TYPE.STREAM_CREDIT,
+                twoway: false,
+                data: {
+                    direction: 'input',
+                    seq: consumer.nextCreditSeq++,
+                    window,
+                },
+            });
+        });
+        consumer = {
+            stream,
+            completed: false,
+            cancelled: false,
+            creditsOwed: 0,
+            maxCredits: window,
+            nextSeq: 0,
+            nextCreditSeq: 0,
+            touch: () => { },
+            clearTimers: () => { },
+            cleanup: () => { },
+        };
+        this.inputStreams.set(id, consumer);
+        // A handler may intentionally ignore its body. Keep protocol failures from
+        // becoming process-level unhandled EventEmitter errors in that case.
+        stream.on('error', () => { });
+        stream.once('close', () => {
+            if (consumer.completed || consumer.cancelled)
+                return;
+            this.cancelInputConsumer(id, 'Request input consumer closed');
+        });
+        this.post({
+            id,
+            mode: MESSAGE_MODEM_TYPE.STREAM_CREDIT,
+            twoway: false,
+            data: {
+                direction: 'input',
+                seq: consumer.nextCreditSeq++,
+                window,
+            },
+        });
+        return stream;
+    }
+    canAcceptInputStream(id) {
+        return !this.inputStreams.has(id) && this.inputStreams.size < MAX_CONCURRENT_STREAMS;
+    }
+    cancelInputConsumer(id, message = 'Request handler completed') {
+        const consumer = this.inputStreams.get(id);
+        if (!consumer)
+            return;
+        this.inputStreams.delete(id);
+        consumer.cancelled = true;
+        try {
+            this.post({
+                id,
+                mode: MESSAGE_MODEM_TYPE.STREAM_CANCEL,
+                twoway: false,
+                data: { direction: 'input', message },
+            });
+        }
+        catch {
+            // The transport may already be closed.
+        }
+        consumer.stream.destroy();
+    }
+    failInputConsumer(id, error) {
+        const consumer = this.inputStreams.get(id);
+        if (!consumer)
+            return;
+        this.inputStreams.delete(id);
+        consumer.cancelled = true;
+        try {
+            this.post({
+                id,
+                mode: MESSAGE_MODEM_TYPE.STREAM_CANCEL,
+                twoway: false,
+                data: { direction: 'input', status: error.status, message: error.message },
+            });
+        }
+        catch {
+            // The transport may already be closed.
+        }
+        consumer.stream.destroy(error);
+        this.cancelOutputProducer(id);
+        const controller = this.aborts.get(id);
+        this.aborts.delete(id);
+        if (controller && !controller.signal.aborted)
+            controller.abort();
+    }
     /**
      * 处理请求消息
      * @param msg - 消息数据
      */
     onRequest(msg) {
+        if (msg.streams?.input && !this.canAcceptInputStream(msg.id)) {
+            if (msg.twoway) {
+                this.post({
+                    id: msg.id,
+                    mode: MESSAGE_MODEM_TYPE.RESPONSE,
+                    twoway: false,
+                    data: {
+                        status: 429,
+                        data: null,
+                        message: 'Request input stream capacity exceeded',
+                    },
+                });
+            }
+            return;
+        }
         const controller = new AbortController();
         this.aborts.set(msg.id, controller);
-        this.exec(msg.data, controller.signal)
+        const input = msg.streams?.input ? this.createInputConsumer(msg.id) : undefined;
+        Promise.resolve(this.exec(msg.data, controller.signal, input))
             .then(value => {
             if (controller.signal.aborted)
                 return;
@@ -346,6 +661,7 @@ export class MessageModem {
             }
         })
             .finally(() => {
+            this.cancelInputConsumer(msg.id);
             this.aborts.delete(msg.id);
         });
     }
@@ -360,38 +676,30 @@ export class MessageModem {
         // 如果栈中存在该消息，则处理响应消息
         if (stack) {
             const { resolve, reject } = stack;
+            if (!res || (typeof res.status !== 'string' && typeof res.status !== 'number')) {
+                reject(new Exception(502, 'Invalid response frame'));
+                return;
+            }
             // 如果响应状态码不是 200，则拒绝响应
-            if (res?.status !== 200) {
-                reject(new Exception(res?.status, res?.message));
+            if (res.status !== 200) {
+                reject(new Exception(res.status, res.message ?? 'Request failed'));
             }
             else {
-                resolve(res?.data);
+                resolve(res.data);
             }
         }
     }
     onStreamRequest(msg) {
-        if (msg.streamVersion !== 1) {
-            this.post({
-                id: msg.id,
-                mode: MESSAGE_MODEM_TYPE.RESPONSE,
-                stream: true,
-                streamVersion: 1,
-                data: { status: 400, seq: 0, payload: 'Unsupported stream protocol', final: true },
-                twoway: false,
-            });
-            return;
-        }
         let window;
         try {
-            window = streamWindow(msg.streamWindow);
+            window = streamWindow(msg.streams?.output?.window);
         }
         catch (error) {
             this.post({
                 id: msg.id,
-                mode: MESSAGE_MODEM_TYPE.RESPONSE,
-                stream: true,
-                streamVersion: 1,
+                mode: MESSAGE_MODEM_TYPE.STREAM_DATA,
                 data: {
+                    direction: 'output',
                     status: 400,
                     seq: 0,
                     payload: error instanceof Error ? error.message : 'Invalid stream window',
@@ -401,13 +709,19 @@ export class MessageModem {
             });
             return;
         }
-        if (this.streamProducers.has(msg.id) || this.streamProducers.size >= 128) {
+        if (this.streamProducers.has(msg.id)
+            || this.streamProducers.size >= MAX_CONCURRENT_STREAMS
+            || (msg.streams?.input && !this.canAcceptInputStream(msg.id))) {
             this.post({
                 id: msg.id,
-                mode: MESSAGE_MODEM_TYPE.RESPONSE,
-                stream: true,
-                streamVersion: 1,
-                data: { status: 429, seq: 0, payload: 'Stream capacity exceeded', final: true },
+                mode: MESSAGE_MODEM_TYPE.STREAM_DATA,
+                data: {
+                    direction: 'output',
+                    status: 429,
+                    seq: 0,
+                    payload: 'Stream capacity exceeded',
+                    final: true,
+                },
                 twoway: false,
             });
             return;
@@ -417,59 +731,63 @@ export class MessageModem {
             credits: window,
             maxCredits: window,
             nextCreditSeq: 0,
+            nextSeq: 0,
+            cancelled: false,
+            iteratorReturned: false,
         };
-        let sequence = 0;
         this.aborts.set(msg.id, controller);
         this.streamProducers.set(msg.id, producer);
+        const input = msg.streams?.input ? this.createInputConsumer(msg.id) : undefined;
         const takeCredit = async () => {
-            while (producer.credits === 0 && !controller.signal.aborted) {
+            while (producer.credits === 0 && !controller.signal.aborted && !producer.cancelled) {
                 await new Promise((resolve) => {
                     producer.wake = resolve;
                 });
                 producer.wake = undefined;
             }
-            if (controller.signal.aborted)
+            if (controller.signal.aborted || producer.cancelled)
                 throw new AbortException();
             producer.credits--;
         };
-        this.exec(msg.data, controller.signal)
+        Promise.resolve(this.exec(msg.data, controller.signal, input))
             .then(async (value) => {
             if (!isAsyncIterable(value)) {
                 throw new Exception(500, 'Invalid async iterable');
             }
             const iterator = value[Symbol.asyncIterator]();
             producer.iterator = iterator;
-            while (!controller.signal.aborted) {
+            while (!controller.signal.aborted && !producer.cancelled) {
                 await takeCredit();
                 const next = await iterator.next();
-                if (controller.signal.aborted)
+                if (controller.signal.aborted || producer.cancelled)
                     return;
                 if (next.done)
                     break;
+                if (next.value == null) {
+                    throw new Exception(500, 'Stream chunk must not be null or undefined');
+                }
                 this.post({
                     id: msg.id,
-                    mode: MESSAGE_MODEM_TYPE.RESPONSE,
-                    stream: true,
-                    streamVersion: msg.streamVersion,
+                    mode: MESSAGE_MODEM_TYPE.STREAM_DATA,
                     data: {
+                        direction: 'output',
                         status: 200,
-                        seq: sequence++,
+                        seq: producer.nextSeq++,
                         payload: next.value,
                         final: false,
                     },
                     twoway: false,
                 });
             }
-            if (controller.signal.aborted)
+            if (controller.signal.aborted || producer.cancelled)
                 return;
             this.post({
                 id: msg.id,
-                mode: MESSAGE_MODEM_TYPE.RESPONSE,
-                stream: true,
-                streamVersion: msg.streamVersion,
+                mode: MESSAGE_MODEM_TYPE.STREAM_DATA,
                 data: {
+                    direction: 'output',
                     status: 200,
-                    seq: sequence++,
+                    seq: producer.nextSeq++,
                     payload: undefined,
                     final: true,
                 },
@@ -477,16 +795,15 @@ export class MessageModem {
             });
         })
             .catch(e => {
-            if (controller.signal.aborted)
+            if (controller.signal.aborted || producer.cancelled)
                 return;
             this.post({
                 id: msg.id,
-                mode: MESSAGE_MODEM_TYPE.RESPONSE,
-                stream: true,
-                streamVersion: msg.streamVersion,
+                mode: MESSAGE_MODEM_TYPE.STREAM_DATA,
                 data: {
+                    direction: 'output',
                     status: e instanceof Exception ? e.status : 500,
-                    seq: sequence,
+                    seq: producer.nextSeq,
                     payload: e instanceof Error ? e.message : 'Unknown error',
                     final: true,
                 },
@@ -494,10 +811,11 @@ export class MessageModem {
             });
         })
             .finally(() => {
-            if (controller.signal.aborted && producer.iterator?.return) {
-                void Promise.resolve(producer.iterator.return()).catch(() => { });
+            if ((controller.signal.aborted || producer.cancelled) && producer.iterator?.return) {
+                returnProducerIterator(producer);
             }
             producer.wake?.();
+            this.cancelInputConsumer(msg.id);
             this.streamProducers.delete(msg.id);
             this.aborts.delete(msg.id);
         });
@@ -506,25 +824,29 @@ export class MessageModem {
         const id = msg.id;
         const res = msg.data;
         const consumer = this.streams.get(id);
-        // 如果栈中存在该消息，则处理响应消息
-        if (consumer) {
+        if (consumer && !consumer.completed && !consumer.cancelled) {
             const stream = consumer.stream;
-            if (res) {
-                consumer.touch();
-                if (!Number.isSafeInteger(res.seq) || res.seq !== consumer.nextSeq) {
-                    stream.destroy(new Exception(409, `Invalid stream sequence: expected ${consumer.nextSeq}, received ${String(res.seq)}`));
+            if (res?.direction === 'output') {
+                if (!Number.isSafeInteger(res.seq)
+                    || res.seq !== consumer.nextSeq
+                    || typeof res.final !== 'boolean'
+                    || (typeof res.status !== 'string' && typeof res.status !== 'number')
+                    || (!res.final && res.payload == null)) {
+                    this.failOutputConsumer(id, new Exception(409, `Invalid response stream frame: expected sequence ${consumer.nextSeq}, received ${String(res.seq)}`));
                     return;
                 }
+                consumer.touch();
                 consumer.nextSeq++;
                 if (res.status === 200) {
                     if (res.final) {
                         consumer.completed = true;
-                        consumer.clearTimers();
+                        this.cancelInputProducer(id);
+                        consumer.cleanup();
                         stream.push(null);
                     }
                     else {
                         if (consumer.creditsOwed >= consumer.maxCredits) {
-                            stream.destroy(new Exception(429, 'Stream window exceeded'));
+                            this.failOutputConsumer(id, new Exception(429, 'Response stream window exceeded'));
                             return;
                         }
                         consumer.creditsOwed++;
@@ -533,18 +855,165 @@ export class MessageModem {
                 }
                 else {
                     consumer.completed = true;
-                    consumer.clearTimers();
-                    const err = new Exception(res.status, res.payload);
+                    this.cancelInputProducer(id);
+                    consumer.cleanup();
+                    const err = new Exception(res.status ?? 500, res.message ?? String(res.payload ?? 'Stream failed'));
                     setImmediate(() => stream.destroy(err));
                 }
             }
             else {
-                consumer.completed = true;
-                consumer.clearTimers();
-                const err = new Exception(404, 'Empty chunk data');
-                setImmediate(() => stream.destroy(err));
+                this.failOutputConsumer(id, res
+                    ? new Exception(400, 'Invalid response stream direction')
+                    : new Exception(404, 'Empty chunk data'));
+            }
+        }
+    }
+    failOutputConsumer(id, error) {
+        const consumer = this.streams.get(id);
+        if (!consumer || consumer.completed || consumer.cancelled)
+            return;
+        try {
+            this.post({
+                id,
+                mode: MESSAGE_MODEM_TYPE.ABORT,
+                twoway: false,
+            });
+        }
+        catch {
+            // The transport may already be closed.
+        }
+        consumer.cancelled = true;
+        this.cancelInputProducer(id);
+        consumer.cleanup();
+        consumer.stream.destroy(error);
+    }
+    onInputStreamData(msg) {
+        const consumer = this.inputStreams.get(msg.id);
+        if (!consumer)
+            return;
+        const chunk = msg.data;
+        if (!chunk
+            || chunk.direction !== 'input'
+            || !Number.isSafeInteger(chunk.seq)
+            || chunk.seq !== consumer.nextSeq
+            || typeof chunk.final !== 'boolean'
+            || (!chunk.final && chunk.payload == null)) {
+            const received = chunk?.seq;
+            this.failInputConsumer(msg.id, new Exception(409, `Invalid request input sequence: expected ${consumer.nextSeq}, received ${String(received)}`));
+            return;
+        }
+        consumer.nextSeq++;
+        if (chunk.final) {
+            consumer.completed = true;
+            this.inputStreams.delete(msg.id);
+            consumer.stream.push(null);
+            return;
+        }
+        if (consumer.creditsOwed >= consumer.maxCredits) {
+            this.failInputConsumer(msg.id, new Exception(429, 'Request input stream window exceeded'));
+            return;
+        }
+        consumer.creditsOwed++;
+        consumer.stream.push(chunk.payload);
+    }
+    onStreamCredit(msg) {
+        const credit = msg.data;
+        if (!credit
+            || (credit.direction !== 'input' && credit.direction !== 'output'))
+            return;
+        const producer = credit.direction === 'input'
+            ? this.inputStreamProducers.get(msg.id)
+            : this.streamProducers.get(msg.id);
+        if (!producer || producer.cancelled)
+            return;
+        if (!Number.isSafeInteger(credit.seq) || credit.seq < 0) {
+            if (credit.direction === 'input') {
+                this.failInputProducer(msg.id, new Exception(400, 'Invalid request input credit sequence'));
+            }
+            else {
+                this.failOutputProducer(msg.id, new Exception(400, 'Invalid response stream credit sequence'));
+            }
+            return;
+        }
+        if (credit.seq < producer.nextCreditSeq)
+            return;
+        if (credit.seq > producer.nextCreditSeq) {
+            if (credit.direction === 'input') {
+                this.failInputProducer(msg.id, new Exception(409, 'Request input credit sequence skipped'));
+            }
+            else {
+                this.failOutputProducer(msg.id, new Exception(409, 'Response stream credit sequence skipped'));
+            }
+            return;
+        }
+        if (producer.maxCredits === undefined) {
+            if (credit.direction !== 'input')
+                return;
+            try {
+                producer.maxCredits = streamWindow(credit.window);
+            }
+            catch {
+                this.failInputProducer(msg.id, new Exception(400, 'Invalid request input stream window'));
+                return;
+            }
+        }
+        else if (credit.window !== undefined && credit.window !== producer.maxCredits) {
+            if (credit.direction === 'input') {
+                this.failInputProducer(msg.id, new Exception(409, 'Request input stream window changed'));
+            }
+            else {
+                this.failOutputProducer(msg.id, new Exception(409, 'Response stream window changed'));
             }
+            return;
         }
+        if (producer.credits >= producer.maxCredits) {
+            if (credit.direction === 'input') {
+                this.failInputProducer(msg.id, new Exception(429, 'Request input credit window exceeded'));
+            }
+            else {
+                this.failOutputProducer(msg.id, new Exception(429, 'Response stream credit window exceeded'));
+            }
+            return;
+        }
+        producer.credits++;
+        producer.nextCreditSeq++;
+        producer.wake?.();
+    }
+    failOutputProducer(id, error) {
+        const producer = this.streamProducers.get(id);
+        if (!producer)
+            return;
+        try {
+            this.post({
+                id,
+                mode: MESSAGE_MODEM_TYPE.STREAM_DATA,
+                twoway: false,
+                data: {
+                    direction: 'output',
+                    status: error.status,
+                    seq: producer.nextSeq,
+                    final: true,
+                    message: error.message,
+                },
+            });
+        }
+        catch {
+            // The transport may already be closed.
+        }
+        this.cancelOutputProducer(id);
+        const controller = this.aborts.get(id);
+        this.aborts.delete(id);
+        if (controller && !controller.signal.aborted)
+            controller.abort();
+    }
+    cancelOutputProducer(id) {
+        const producer = this.streamProducers.get(id);
+        if (!producer)
+            return;
+        this.streamProducers.delete(id);
+        producer.cancelled = true;
+        producer.wake?.();
+        returnProducerIterator(producer);
     }
     /**
      * 接收消息
@@ -555,7 +1024,7 @@ export class MessageModem {
         switch (msg.mode) {
             // 处理请求消息
             case MESSAGE_MODEM_TYPE.REQUEST:
-                if (msg.stream) {
+                if (msg.streams?.output) {
                     this.onStreamRequest(msg);
                 }
                 else {
@@ -564,41 +1033,56 @@ export class MessageModem {
                 break;
             // 处理响应消息
             case MESSAGE_MODEM_TYPE.RESPONSE:
-                if (msg.stream) {
+                this.onResponse(msg);
+                break;
+            case MESSAGE_MODEM_TYPE.STREAM_DATA: {
+                const chunk = msg.data;
+                if (chunk?.direction === 'input')
+                    this.onInputStreamData(msg);
+                else if (chunk?.direction === 'output')
                     this.onStreamResponse(msg);
-                }
-                else {
-                    this.onResponse(msg);
-                }
+                else if (this.streams.has(msg.id))
+                    this.onStreamResponse(msg);
+                else if (this.inputStreams.has(msg.id))
+                    this.onInputStreamData(msg);
                 break;
+            }
             // 处理终止消息
             case MESSAGE_MODEM_TYPE.ABORT: {
-                const id = msg.data;
+                const id = msg.id;
                 const controller = this.aborts.get(id);
                 if (controller) {
                     this.aborts.delete(id);
-                    this.streamProducers.get(id)?.wake?.();
                     if (!controller.signal.aborted) {
                         controller.abort();
                     }
                 }
+                this.cancelOutputProducer(id);
+                this.cancelInputConsumer(id, 'Request aborted');
                 break;
             }
-            case MESSAGE_MODEM_TYPE.STREAM_CREDIT: {
-                const credit = msg.data;
-                if (!credit
-                    || !Number.isSafeInteger(credit.id)
-                    || credit.id < 0
-                    || !Number.isSafeInteger(credit.seq)
-                    || credit.seq < 0)
-                    break;
-                const producer = this.streamProducers.get(credit.id);
-                if (producer
-                    && producer.credits < producer.maxCredits
-                    && credit.seq === producer.nextCreditSeq) {
-                    producer.credits++;
-                    producer.nextCreditSeq++;
-                    producer.wake?.();
+            case MESSAGE_MODEM_TYPE.STREAM_CREDIT:
+                this.onStreamCredit(msg);
+                break;
+            case MESSAGE_MODEM_TYPE.STREAM_CANCEL: {
+                const cancel = msg.data;
+                if (cancel?.direction === 'input') {
+                    this.cancelInputProducer(msg.id);
+                    if (cancel.status !== undefined) {
+                        const error = new Exception(cancel.status, cancel.message ?? 'Request input stream rejected');
+                        const stack = this.stacks.get(msg.id);
+                        if (stack)
+                            stack.reject(error);
+                        else
+                            this.failOutputConsumer(msg.id, error);
+                    }
+                }
+                else if (cancel?.direction === 'output') {
+                    this.cancelOutputProducer(msg.id);
+                    const controller = this.aborts.get(msg.id);
+                    this.aborts.delete(msg.id);
+                    if (controller && !controller.signal.aborted)
+                        controller.abort();
                 }
                 break;
             }