@verevoir/review 0.3.0 → 0.3.2

package/node_modules/@anthropic-ai/sdk/lib/MessageStream.js

@@ -0,0 +1,650 @@
+"use strict";
+var _MessageStream_instances, _MessageStream_currentMessageSnapshot, _MessageStream_params, _MessageStream_connectedPromise, _MessageStream_resolveConnectedPromise, _MessageStream_rejectConnectedPromise, _MessageStream_endPromise, _MessageStream_resolveEndPromise, _MessageStream_rejectEndPromise, _MessageStream_listeners, _MessageStream_ended, _MessageStream_errored, _MessageStream_aborted, _MessageStream_catchingPromiseCreated, _MessageStream_response, _MessageStream_request_id, _MessageStream_workspace_id, _MessageStream_logger, _MessageStream_client, _MessageStream_span, _MessageStream_getFinalMessage, _MessageStream_getFinalText, _MessageStream_handleError, _MessageStream_beginRequest, _MessageStream_addStreamEvent, _MessageStream_endRequest, _MessageStream_accumulateMessage;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageStream = void 0;
+const tslib_1 = require("../internal/tslib.js");
+const stainless_helper_header_1 = require("../internal/stainless-helper-header.js");
+const errors_1 = require("../internal/errors.js");
+const values_1 = require("../internal/utils/values.js");
+const error_1 = require("../error.js");
+const streaming_1 = require("../streaming.js");
+const parser_1 = require("./parser.js");
+const messages_request_1 = require("./internal/messages-request.js");
+const tracing_1 = require("./internal/tracing.js");
+const message_stream_utils_1 = require("../internal/message-stream-utils.js");
+function tracksToolInput(content) {
+    return content.type === 'tool_use' || content.type === 'server_tool_use';
+}
+var MessageStream = /* @__PURE__ */ (() => {
+    class MessageStream {
+        constructor(params, opts) {
+            _MessageStream_instances.add(this);
+            this.messages = [];
+            this.receivedMessages = [];
+            _MessageStream_currentMessageSnapshot.set(this, void 0);
+            _MessageStream_params.set(this, null);
+            this.controller = new AbortController();
+            _MessageStream_connectedPromise.set(this, void 0);
+            _MessageStream_resolveConnectedPromise.set(this, () => { });
+            _MessageStream_rejectConnectedPromise.set(this, () => { });
+            _MessageStream_endPromise.set(this, void 0);
+            _MessageStream_resolveEndPromise.set(this, () => { });
+            _MessageStream_rejectEndPromise.set(this, () => { });
+            _MessageStream_listeners.set(this, {});
+            _MessageStream_ended.set(this, false);
+            _MessageStream_errored.set(this, false);
+            _MessageStream_aborted.set(this, false);
+            _MessageStream_catchingPromiseCreated.set(this, false);
+            _MessageStream_response.set(this, void 0);
+            _MessageStream_request_id.set(this, void 0);
+            _MessageStream_workspace_id.set(this, void 0);
+            _MessageStream_logger.set(this, void 0);
+            // The client that makes the request, and the call span of the request, to record the message on.
+            // Both are set only for a stream that an SDK method created.
+            _MessageStream_client.set(this, void 0);
+            _MessageStream_span.set(this, void 0);
+            _MessageStream_handleError.set(this, (error) => {
+                tslib_1.__classPrivateFieldSet(this, _MessageStream_errored, true, "f");
+                // The stream ignores the events after an error, so its message stops being what the API sent.
+                if (tslib_1.__classPrivateFieldGet(this, _MessageStream_span, "f")) {
+                    tslib_1.__classPrivateFieldGet(this, _MessageStream_span, "f").streamed = undefined;
+                }
+                if ((0, errors_1.isAbortError)(error)) {
+                    error = new error_1.APIUserAbortError();
+                }
+                if (error instanceof error_1.APIUserAbortError) {
+                    tslib_1.__classPrivateFieldSet(this, _MessageStream_aborted, true, "f");
+                    return this._emit('abort', error);
+                }
+                if (error instanceof error_1.AnthropicError) {
+                    return this._emit('error', error);
+                }
+                if (error instanceof Error) {
+                    const anthropicError = new error_1.AnthropicError(error.message);
+                    // @ts-ignore
+                    anthropicError.cause = error;
+                    return this._emit('error', anthropicError);
+                }
+                return this._emit('error', new error_1.AnthropicError(String(error)));
+            });
+            tslib_1.__classPrivateFieldSet(this, _MessageStream_connectedPromise, new Promise((resolve, reject) => {
+                tslib_1.__classPrivateFieldSet(this, _MessageStream_resolveConnectedPromise, resolve, "f");
+                tslib_1.__classPrivateFieldSet(this, _MessageStream_rejectConnectedPromise, reject, "f");
+            }), "f");
+            tslib_1.__classPrivateFieldSet(this, _MessageStream_endPromise, new Promise((resolve, reject) => {
+                tslib_1.__classPrivateFieldSet(this, _MessageStream_resolveEndPromise, resolve, "f");
+                tslib_1.__classPrivateFieldSet(this, _MessageStream_rejectEndPromise, reject, "f");
+            }), "f");
+            // Don't let these promises cause unhandled rejection errors.
+            // we will manually cause an unhandled rejection error later
+            // if the user hasn't registered any error listener or called
+            // any promise-returning method.
+            tslib_1.__classPrivateFieldGet(this, _MessageStream_connectedPromise, "f").catch(() => { });
+            tslib_1.__classPrivateFieldGet(this, _MessageStream_endPromise, "f").catch(() => { });
+            tslib_1.__classPrivateFieldSet(this, _MessageStream_params, params, "f");
+            tslib_1.__classPrivateFieldSet(this, _MessageStream_logger, opts?.logger ?? console, "f");
+            tslib_1.__classPrivateFieldSet(this, _MessageStream_client, opts?.client, "f");
+        }
+        get response() {
+            return tslib_1.__classPrivateFieldGet(this, _MessageStream_response, "f");
+        }
+        get request_id() {
+            return tslib_1.__classPrivateFieldGet(this, _MessageStream_request_id, "f");
+        }
+        get workspace_id() {
+            return tslib_1.__classPrivateFieldGet(this, _MessageStream_workspace_id, "f");
+        }
+        /**
+         * Returns the `MessageStream` data, the raw `Response` instance and the ID of the request,
+         * returned vie the `request-id` header which is useful for debugging requests and resporting
+         * issues to Anthropic.
+         *
+         * This is the same as the `APIPromise.withResponse()` method.
+         *
+         * This method will raise an error if you created the stream using `MessageStream.fromReadableStream`
+         * as no `Response` is available.
+         */
+        async withResponse() {
+            tslib_1.__classPrivateFieldSet(this, _MessageStream_catchingPromiseCreated, true, "f");
+            const response = await tslib_1.__classPrivateFieldGet(this, _MessageStream_connectedPromise, "f");
+            if (!response) {
+                throw new Error('Could not resolve a `Response` object');
+            }
+            return {
+                data: this,
+                response,
+                request_id: response.headers.get('request-id'),
+                workspace_id: response.headers.get('anthropic-workspace-id'),
+            };
+        }
+        /**
+         * Intended for use on the frontend, consuming a stream produced with
+         * `.toReadableStream()` on the backend.
+         *
+         * Note that messages sent to the model do not appear in `.on('message')`
+         * in this context.
+         */
+        static fromReadableStream(stream) {
+            const runner = new MessageStream(null);
+            runner._run(() => runner._fromReadableStream(stream));
+            return runner;
+        }
+        static createMessage(messages, params, options, { logger, client, } = {}) {
+            const runner = new MessageStream(params, { logger, client });
+            for (const message of params.messages) {
+                runner._addMessageParam(message);
+            }
+            tslib_1.__classPrivateFieldSet(runner, _MessageStream_params, { ...params, stream: true }, "f");
+            runner._run(() => runner._createMessage(messages, { ...params, stream: true }, { ...options, headers: { ...options?.headers, [stainless_helper_header_1.STAINLESS_HELPER_METHOD_HEADER]: 'stream' } }));
+            return runner;
+        }
+        _run(executor) {
+            executor().then(() => {
+                this._emitFinal();
+                this._emit('end');
+            }, tslib_1.__classPrivateFieldGet(this, _MessageStream_handleError, "f"));
+        }
+        _addMessageParam(message) {
+            this.messages.push(message);
+        }
+        _addMessage(message, emit = true) {
+            this.receivedMessages.push(message);
+            if (emit) {
+                this._emit('message', message);
+            }
+        }
+        async _createMessage(messages, params, options) {
+            const signal = options?.signal;
+            let abortHandler;
+            if (signal) {
+                if (signal.aborted)
+                    this.controller.abort();
+                abortHandler = this.controller.abort.bind(this.controller);
+                signal.addEventListener('abort', abortHandler);
+            }
+            try {
+                tslib_1.__classPrivateFieldGet(this, _MessageStream_instances, "m", _MessageStream_beginRequest).call(this);
+                // Started here, where a throw fails the stream, and kept to record the final message on.
+                // `create()` below gets it in its options, so it uses this span instead of starting its own.
+                tslib_1.__classPrivateFieldSet(this, _MessageStream_span, options?.__span ?? (tslib_1.__classPrivateFieldGet(this, _MessageStream_client, "f") && (0, messages_request_1.startMessagesStreamSpan)(tslib_1.__classPrivateFieldGet(this, _MessageStream_client, "f"), params, options)), "f");
+                const { response, data: stream } = await messages
+                    .create({ ...params, stream: true }, { ...options, __span: tslib_1.__classPrivateFieldGet(this, _MessageStream_span, "f"), signal: this.controller.signal })
+                    .withResponse();
+                try {
+                    this._connected(response);
+                }
+                catch (error) {
+                    // Nothing reads the stream after a `connect` listener throws: closing it ends its span.
+                    if (tslib_1.__classPrivateFieldGet(this, _MessageStream_span, "f")) {
+                        tslib_1.__classPrivateFieldGet(this, _MessageStream_span, "f").failure = error;
+                    }
+                    stream.controller.abort();
+                    throw error;
+                }
+                for await (const event of stream) {
+                    try {
+                        tslib_1.__classPrivateFieldGet(this, _MessageStream_instances, "m", _MessageStream_addStreamEvent).call(this, event);
+                    }
+                    catch (error) {
+                        if (tslib_1.__classPrivateFieldGet(this, _MessageStream_span, "f")) {
+                            tslib_1.__classPrivateFieldGet(this, _MessageStream_span, "f").failure = error;
+                        }
+                        throw error;
+                    }
+                }
+                if (stream.controller.signal?.aborted) {
+                    throw new error_1.APIUserAbortError();
+                }
+                tslib_1.__classPrivateFieldGet(this, _MessageStream_instances, "m", _MessageStream_endRequest).call(this);
+            }
+            finally {
+                if (signal && abortHandler) {
+                    signal.removeEventListener('abort', abortHandler);
+                }
+            }
+        }
+        _connected(response) {
+            if (this.ended)
+                return;
+            tslib_1.__classPrivateFieldSet(this, _MessageStream_response, response, "f");
+            tslib_1.__classPrivateFieldSet(this, _MessageStream_request_id, response?.headers.get('request-id'), "f");
+            tslib_1.__classPrivateFieldSet(this, _MessageStream_workspace_id, response?.headers.get('anthropic-workspace-id'), "f");
+            tslib_1.__classPrivateFieldGet(this, _MessageStream_resolveConnectedPromise, "f").call(this, response);
+            this._emit('connect');
+        }
+        get ended() {
+            return tslib_1.__classPrivateFieldGet(this, _MessageStream_ended, "f");
+        }
+        get errored() {
+            return tslib_1.__classPrivateFieldGet(this, _MessageStream_errored, "f");
+        }
+        get aborted() {
+            return tslib_1.__classPrivateFieldGet(this, _MessageStream_aborted, "f");
+        }
+        abort() {
+            this.controller.abort();
+        }
+        /**
+         * Adds the listener function to the end of the listeners array for the event.
+         * No checks are made to see if the listener has already been added. Multiple calls passing
+         * the same combination of event and listener will result in the listener being added, and
+         * called, multiple times.
+         * @returns this MessageStream, so that calls can be chained
+         */
+        on(event, listener) {
+            const listeners = tslib_1.__classPrivateFieldGet(this, _MessageStream_listeners, "f")[event] || (tslib_1.__classPrivateFieldGet(this, _MessageStream_listeners, "f")[event] = []);
+            listeners.push({ listener });
+            return this;
+        }
+        /**
+         * Removes the specified listener from the listener array for the event.
+         * off() will remove, at most, one instance of a listener from the listener array. If any single
+         * listener has been added multiple times to the listener array for the specified event, then
+         * off() must be called multiple times to remove each instance.
+         * @returns this MessageStream, so that calls can be chained
+         */
+        off(event, listener) {
+            const listeners = tslib_1.__classPrivateFieldGet(this, _MessageStream_listeners, "f")[event];
+            if (!listeners)
+                return this;
+            const index = listeners.findIndex((l) => l.listener === listener);
+            if (index >= 0)
+                listeners.splice(index, 1);
+            return this;
+        }
+        /**
+         * Adds a one-time listener function for the event. The next time the event is triggered,
+         * this listener is removed and then invoked.
+         * @returns this MessageStream, so that calls can be chained
+         */
+        once(event, listener) {
+            const listeners = tslib_1.__classPrivateFieldGet(this, _MessageStream_listeners, "f")[event] || (tslib_1.__classPrivateFieldGet(this, _MessageStream_listeners, "f")[event] = []);
+            listeners.push({ listener, once: true });
+            return this;
+        }
+        /**
+         * This is similar to `.once()`, but returns a Promise that resolves the next time
+         * the event is triggered, instead of calling a listener callback.
+         * @returns a Promise that resolves the next time given event is triggered,
+         * or rejects if an error is emitted.  (If you request the 'error' event,
+         * returns a promise that resolves with the error).
+         *
+         * Example:
+         *
+         *   const message = await stream.emitted('message') // rejects if the stream errors
+         */
+        emitted(event) {
+            return new Promise((resolve, reject) => {
+                tslib_1.__classPrivateFieldSet(this, _MessageStream_catchingPromiseCreated, true, "f");
+                if (event !== 'error')
+                    this.once('error', reject);
+                this.once(event, resolve);
+            });
+        }
+        async done() {
+            tslib_1.__classPrivateFieldSet(this, _MessageStream_catchingPromiseCreated, true, "f");
+            await tslib_1.__classPrivateFieldGet(this, _MessageStream_endPromise, "f");
+        }
+        get currentMessage() {
+            return tslib_1.__classPrivateFieldGet(this, _MessageStream_currentMessageSnapshot, "f");
+        }
+        /**
+         * @returns a promise that resolves with the the final assistant Message response,
+         * or rejects if an error occurred or the stream ended prematurely without producing a Message.
+         * If structured outputs were used, this will be a ParsedMessage with a `parsed_output` field.
+         */
+        async finalMessage() {
+            await this.done();
+            return tslib_1.__classPrivateFieldGet(this, _MessageStream_instances, "m", _MessageStream_getFinalMessage).call(this);
+        }
+        /**
+         * @returns a promise that resolves with the the final assistant Message's text response, concatenated
+         * together if there are more than one text blocks.
+         * Rejects if an error occurred or the stream ended prematurely without producing a Message.
+         */
+        async finalText() {
+            await this.done();
+            return tslib_1.__classPrivateFieldGet(this, _MessageStream_instances, "m", _MessageStream_getFinalText).call(this);
+        }
+        _emit(event, ...args) {
+            // make sure we don't emit any MessageStreamEvents after end
+            if (tslib_1.__classPrivateFieldGet(this, _MessageStream_ended, "f"))
+                return;
+            if (event === 'end') {
+                tslib_1.__classPrivateFieldSet(this, _MessageStream_ended, true, "f");
+                tslib_1.__classPrivateFieldGet(this, _MessageStream_resolveEndPromise, "f").call(this);
+            }
+            const listeners = tslib_1.__classPrivateFieldGet(this, _MessageStream_listeners, "f")[event];
+            if (listeners) {
+                tslib_1.__classPrivateFieldGet(this, _MessageStream_listeners, "f")[event] = listeners.filter((l) => !l.once);
+                listeners.forEach(({ listener }) => listener(...args));
+            }
+            if (event === 'abort') {
+                const error = args[0];
+                if (!tslib_1.__classPrivateFieldGet(this, _MessageStream_catchingPromiseCreated, "f") && !listeners?.length) {
+                    Promise.reject(error);
+                }
+                tslib_1.__classPrivateFieldGet(this, _MessageStream_rejectConnectedPromise, "f").call(this, error);
+                tslib_1.__classPrivateFieldGet(this, _MessageStream_rejectEndPromise, "f").call(this, error);
+                this._emit('end');
+                return;
+            }
+            if (event === 'error') {
+                // NOTE: _emit('error', error) should only be called from #handleError().
+                const error = args[0];
+                if (!tslib_1.__classPrivateFieldGet(this, _MessageStream_catchingPromiseCreated, "f") && !listeners?.length) {
+                    // Trigger an unhandled rejection if the user hasn't registered any error handlers.
+                    // If you are seeing stack traces here, make sure to handle errors via either:
+                    // - runner.on('error', () => ...)
+                    // - await runner.done()
+                    // - await runner.final...()
+                    // - etc.
+                    Promise.reject(error);
+                }
+                tslib_1.__classPrivateFieldGet(this, _MessageStream_rejectConnectedPromise, "f").call(this, error);
+                tslib_1.__classPrivateFieldGet(this, _MessageStream_rejectEndPromise, "f").call(this, error);
+                this._emit('end');
+            }
+        }
+        _emitFinal() {
+            const finalMessage = this.receivedMessages.at(-1);
+            if (finalMessage) {
+                this._emit('finalMessage', tslib_1.__classPrivateFieldGet(this, _MessageStream_instances, "m", _MessageStream_getFinalMessage).call(this));
+            }
+        }
+        async _fromReadableStream(readableStream, options) {
+            const signal = options?.signal;
+            let abortHandler;
+            if (signal) {
+                if (signal.aborted)
+                    this.controller.abort();
+                abortHandler = this.controller.abort.bind(this.controller);
+                signal.addEventListener('abort', abortHandler);
+            }
+            try {
+                tslib_1.__classPrivateFieldGet(this, _MessageStream_instances, "m", _MessageStream_beginRequest).call(this);
+                this._connected(null);
+                const stream = streaming_1.Stream.fromReadableStream(readableStream, this.controller);
+                for await (const event of stream) {
+                    tslib_1.__classPrivateFieldGet(this, _MessageStream_instances, "m", _MessageStream_addStreamEvent).call(this, event);
+                }
+                if (stream.controller.signal?.aborted) {
+                    throw new error_1.APIUserAbortError();
+                }
+                tslib_1.__classPrivateFieldGet(this, _MessageStream_instances, "m", _MessageStream_endRequest).call(this);
+            }
+            finally {
+                if (signal && abortHandler) {
+                    signal.removeEventListener('abort', abortHandler);
+                }
+            }
+        }
+        [(_MessageStream_currentMessageSnapshot = new WeakMap(), _MessageStream_params = new WeakMap(), _MessageStream_connectedPromise = new WeakMap(), _MessageStream_resolveConnectedPromise = new WeakMap(), _MessageStream_rejectConnectedPromise = new WeakMap(), _MessageStream_endPromise = new WeakMap(), _MessageStream_resolveEndPromise = new WeakMap(), _MessageStream_rejectEndPromise = new WeakMap(), _MessageStream_listeners = new WeakMap(), _MessageStream_ended = new WeakMap(), _MessageStream_errored = new WeakMap(), _MessageStream_aborted = new WeakMap(), _MessageStream_catchingPromiseCreated = new WeakMap(), _MessageStream_response = new WeakMap(), _MessageStream_request_id = new WeakMap(), _MessageStream_workspace_id = new WeakMap(), _MessageStream_logger = new WeakMap(), _MessageStream_client = new WeakMap(), _MessageStream_span = new WeakMap(), _MessageStream_handleError = new WeakMap(), _MessageStream_instances = new WeakSet(), _MessageStream_getFinalMessage = function _MessageStream_getFinalMessage() {
+            if (this.receivedMessages.length === 0) {
+                throw new error_1.AnthropicError('stream ended without producing a Message with role=assistant');
+            }
+            return this.receivedMessages.at(-1);
+        }, _MessageStream_getFinalText = function _MessageStream_getFinalText() {
+            if (this.receivedMessages.length === 0) {
+                throw new error_1.AnthropicError('stream ended without producing a Message with role=assistant');
+            }
+            const textBlocks = this.receivedMessages
+                .at(-1)
+                .content.filter((block) => block.type === 'text')
+                .map((block) => block.text);
+            if (textBlocks.length === 0) {
+                throw new error_1.AnthropicError('stream ended without producing a content block with type=text');
+            }
+            return textBlocks.join(' ');
+        }, _MessageStream_beginRequest = function _MessageStream_beginRequest() {
+            if (this.ended)
+                return;
+            tslib_1.__classPrivateFieldSet(this, _MessageStream_currentMessageSnapshot, undefined, "f");
+        }, _MessageStream_addStreamEvent = function _MessageStream_addStreamEvent(event) {
+            if (this.ended)
+                return;
+            const messageSnapshot = tslib_1.__classPrivateFieldGet(this, _MessageStream_instances, "m", _MessageStream_accumulateMessage).call(this, event);
+            this._emit('_rawEvent', event);
+            if (!messageSnapshot)
+                return;
+            this._emit('streamEvent', event, messageSnapshot);
+            switch (event.type) {
+                case 'content_block_delta': {
+                    const content = messageSnapshot.content.at(-1);
+                    switch (event.delta.type) {
+                        case 'text_delta': {
+                            if (content.type === 'text') {
+                                this._emit('text', event.delta.text, content.text || '');
+                            }
+                            break;
+                        }
+                        case 'citations_delta': {
+                            if (content.type === 'text') {
+                                this._emit('citation', event.delta.citation, content.citations ?? []);
+                            }
+                            break;
+                        }
+                        case 'input_json_delta': {
+                            if (tracksToolInput(content) && tslib_1.__classPrivateFieldGet(this, _MessageStream_listeners, "f").inputJson?.length) {
+                                this._emit('inputJson', event.delta.partial_json, content.input);
+                            }
+                            break;
+                        }
+                        case 'thinking_delta': {
+                            if (content.type === 'thinking') {
+                                this._emit('thinking', event.delta.thinking, content.thinking);
+                            }
+                            break;
+                        }
+                        case 'signature_delta': {
+                            if (content.type === 'thinking') {
+                                this._emit('signature', content.signature);
+                            }
+                            break;
+                        }
+                        default:
+                            (0, values_1.checkNever)(event.delta);
+                    }
+                    break;
+                }
+                case 'message_stop': {
+                    if (tslib_1.__classPrivateFieldGet(this, _MessageStream_client, "f") && tslib_1.__classPrivateFieldGet(this, _MessageStream_span, "f") && tslib_1.__classPrivateFieldGet(this, _MessageStream_params, "f")) {
+                        (0, tracing_1.recordStreamedMessageContent)(tslib_1.__classPrivateFieldGet(this, _MessageStream_client, "f"), tslib_1.__classPrivateFieldGet(this, _MessageStream_span, "f"), tslib_1.__classPrivateFieldGet(this, _MessageStream_params, "f"), messageSnapshot);
+                    }
+                    this._addMessageParam(messageSnapshot);
+                    this._addMessage((0, parser_1.maybeParseMessage)(messageSnapshot, tslib_1.__classPrivateFieldGet(this, _MessageStream_params, "f"), { logger: tslib_1.__classPrivateFieldGet(this, _MessageStream_logger, "f") }), true);
+                    break;
+                }
+                case 'content_block_stop': {
+                    this._emit('contentBlock', messageSnapshot.content.at(-1));
+                    break;
+                }
+                case 'message_start': {
+                    tslib_1.__classPrivateFieldSet(this, _MessageStream_currentMessageSnapshot, messageSnapshot, "f");
+                    if (tslib_1.__classPrivateFieldGet(this, _MessageStream_span, "f") && tslib_1.__classPrivateFieldGet(this, _MessageStream_params, "f")) {
+                        tslib_1.__classPrivateFieldGet(this, _MessageStream_span, "f").streamed = { body: tslib_1.__classPrivateFieldGet(this, _MessageStream_params, "f"), message: messageSnapshot };
+                    }
+                    break;
+                }
+                case 'content_block_start':
+                case 'message_delta':
+                    break;
+            }
+        }, _MessageStream_endRequest = function _MessageStream_endRequest() {
+            if (this.ended) {
+                throw new error_1.AnthropicError(`stream has ended, this shouldn't happen`);
+            }
+            const snapshot = tslib_1.__classPrivateFieldGet(this, _MessageStream_currentMessageSnapshot, "f");
+            if (!snapshot) {
+                throw new error_1.AnthropicError(`request ended without sending any chunks`);
+            }
+            tslib_1.__classPrivateFieldSet(this, _MessageStream_currentMessageSnapshot, undefined, "f");
+            return (0, parser_1.maybeParseMessage)(snapshot, tslib_1.__classPrivateFieldGet(this, _MessageStream_params, "f"), { logger: tslib_1.__classPrivateFieldGet(this, _MessageStream_logger, "f") });
+        }, _MessageStream_accumulateMessage = function _MessageStream_accumulateMessage(event) {
+            let snapshot = tslib_1.__classPrivateFieldGet(this, _MessageStream_currentMessageSnapshot, "f");
+            if (event.type === 'message_start') {
+                if (snapshot) {
+                    throw new error_1.AnthropicError(`Unexpected event order, got ${event.type} before receiving "message_stop"`);
+                }
+                return event.message;
+            }
+            if (!snapshot)
+                return;
+            switch (event.type) {
+                case 'message_stop':
+                    return snapshot;
+                case 'message_delta':
+                    snapshot.stop_reason = event.delta.stop_reason;
+                    snapshot.stop_sequence = event.delta.stop_sequence;
+                    snapshot.stop_details = event.delta.stop_details;
+                    snapshot.usage.output_tokens = event.usage.output_tokens;
+                    if (event.delta.container != null) {
+                        snapshot.container = event.delta.container;
+                    }
+                    // The remaining usage counters are cumulative whole-message totals that are
+                    // omitted when they don't apply, so overwrite when present and never add.
+                    if (event.usage.input_tokens != null) {
+                        snapshot.usage.input_tokens = event.usage.input_tokens;
+                    }
+                    if (event.usage.cache_creation_input_tokens != null) {
+                        snapshot.usage.cache_creation_input_tokens = event.usage.cache_creation_input_tokens;
+                    }
+                    if (event.usage.cache_read_input_tokens != null) {
+                        snapshot.usage.cache_read_input_tokens = event.usage.cache_read_input_tokens;
+                    }
+                    if (event.usage.server_tool_use != null) {
+                        snapshot.usage.server_tool_use = event.usage.server_tool_use;
+                    }
+                    if (event.usage.output_tokens_details != null) {
+                        snapshot.usage.output_tokens_details = event.usage.output_tokens_details;
+                    }
+                    return snapshot;
+                case 'content_block_start':
+                    snapshot.content.push({ ...event.content_block });
+                    return snapshot;
+                case 'content_block_delta': {
+                    const snapshotContent = snapshot.content.at(event.index);
+                    switch (event.delta.type) {
+                        case 'text_delta': {
+                            if (snapshotContent?.type === 'text') {
+                                snapshot.content[event.index] = {
+                                    ...snapshotContent,
+                                    text: (snapshotContent.text || '') + event.delta.text,
+                                };
+                            }
+                            break;
+                        }
+                        case 'citations_delta': {
+                            if (snapshotContent?.type === 'text') {
+                                snapshot.content[event.index] = {
+                                    ...snapshotContent,
+                                    citations: [...(snapshotContent.citations ?? []), event.delta.citation],
+                                };
+                            }
+                            break;
+                        }
+                        case 'input_json_delta': {
+                            if (snapshotContent && tracksToolInput(snapshotContent)) {
+                                const jsonBuf = (snapshotContent[message_stream_utils_1.JSON_BUF_PROPERTY] || '') + event.delta.partial_json;
+                                snapshot.content[event.index] = (0, message_stream_utils_1.withLazyInput)(snapshotContent, jsonBuf);
+                            }
+                            break;
+                        }
+                        case 'thinking_delta': {
+                            if (snapshotContent?.type === 'thinking') {
+                                snapshot.content[event.index] = {
+                                    ...snapshotContent,
+                                    thinking: snapshotContent.thinking + event.delta.thinking,
+                                };
+                            }
+                            break;
+                        }
+                        case 'signature_delta': {
+                            if (snapshotContent?.type === 'thinking') {
+                                snapshot.content[event.index] = {
+                                    ...snapshotContent,
+                                    signature: event.delta.signature,
+                                };
+                            }
+                            break;
+                        }
+                        default:
+                            (0, values_1.checkNever)(event.delta);
+                    }
+                    return snapshot;
+                }
+                case 'content_block_stop': {
+                    const snapshotContent = snapshot.content.at(event.index);
+                    if (snapshotContent && tracksToolInput(snapshotContent) && message_stream_utils_1.JSON_BUF_PROPERTY in snapshotContent) {
+                        Object.defineProperty(snapshotContent, 'input', {
+                            value: snapshotContent.input,
+                            enumerable: true,
+                            configurable: true,
+                            writable: true,
+                        });
+                    }
+                    return snapshot;
+                }
+                default:
+                    return snapshot;
+            }
+        }, Symbol.asyncIterator)]() {
+            const pushQueue = [];
+            const readQueue = [];
+            let done = false;
+            this.on('_rawEvent', (event) => {
+                const reader = readQueue.shift();
+                if (reader) {
+                    reader.resolve(event);
+                }
+                else {
+                    pushQueue.push(event);
+                }
+            });
+            this.on('end', () => {
+                done = true;
+                for (const reader of readQueue) {
+                    reader.resolve(undefined);
+                }
+                readQueue.length = 0;
+            });
+            this.on('abort', (err) => {
+                done = true;
+                for (const reader of readQueue) {
+                    reader.reject(err);
+                }
+                readQueue.length = 0;
+            });
+            this.on('error', (err) => {
+                done = true;
+                for (const reader of readQueue) {
+                    reader.reject(err);
+                }
+                readQueue.length = 0;
+            });
+            return {
+                next: async () => {
+                    if (!pushQueue.length) {
+                        if (done) {
+                            return { value: undefined, done: true };
+                        }
+                        return new Promise((resolve, reject) => readQueue.push({ resolve, reject })).then((chunk) => (chunk ? { value: chunk, done: false } : { value: undefined, done: true }));
+                    }
+                    const chunk = pushQueue.shift();
+                    return { value: chunk, done: false };
+                },
+                return: async () => {
+                    this.abort();
+                    return { value: undefined, done: true };
+                },
+            };
+        }
+        toReadableStream() {
+            const stream = new streaming_1.Stream(this[Symbol.asyncIterator].bind(this), this.controller);
+            return stream.toReadableStream();
+        }
+    }
+    return MessageStream;
+})();
+exports.MessageStream = MessageStream;
+//# sourceMappingURL=MessageStream.js.map