@moxt-ai/mobius-sdk 0.0.64 → 0.0.66

package/dist/service-client.js

@@ -1,16 +1,12 @@
-import { decodeAgentSettingsDiscoveredEvent, decodeMobiusSessionExportV2, decodeNativeSessionEventsV2, decodeNativeSessionResult, decodeSessionConfigUpdatedEvent, decodeSessionEventLogPageV2, decodeSessionEventV2, decodeSessionReadyEvent, decodeSessionsListedEvent, decodeSessionsQueriedEvent, decodeWorkspaceEntriesEvent, isIdentifier, MOBIUS_API_PREFIX, SessionPromptDisposition, } from "@moxt-ai/mobius-protocol";
+import { decodeAgentSettingsDiscoveredEvent, decodeMobiusSessionExportV2, decodeNativeSessionEventsV2, decodeNativeSessionResult, decodeSessionConfigUpdatedEvent, decodeSessionEventBatchV2, decodeSessionEventLogPageV2, decodeSessionReadyEvent, decodeSessionsListedEvent, decodeSessionsQueriedEvent, decodeWorkspaceEntriesEvent, isIdentifier, MOBIUS_API_PREFIX, SessionPromptDisposition, } from "@moxt-ai/mobius-protocol";
 import { MobiusApiError, MobiusCancellationError, MobiusConnectionError, MobiusError, MobiusProtocolError, MobiusTimeoutError, MobiusValidationError, } from "./errors.js";
 import { MobiusPublicRequestExecutor } from "./public-request.js";
-import { decodeMobiusAttempt, decodeMobiusBrowserCredential, decodeMobiusChannelAccessGrant, decodeMobiusChannelDescriptor, decodeMobiusEventPage, decodeMobiusInteraction, decodeMobiusInteractionList, decodeMobiusLinkedChannelDeviceList, decodeMobiusMessagePage, decodeMobiusRedeemedChannelCredential, decodeMobiusRuntimeList, decodeMobiusRuntimePairing, decodeMobiusRuntimePairingStatus, decodeMobiusServiceCapabilities, decodeMobiusSession, decodeMobiusSessionEvent, decodeMobiusSessionExport, decodeMobiusSessionPage, decodeMobiusSessionState, decodeMobiusToolCallDetail, decodeMobiusTurn, decodeRuntimeDescriptor, MobiusPairedRuntimePairingStatus, MobiusRuntimePairingLifecycle, MobiusSessionAccess, } from "./resources.js";
+import { decodeMobiusAttempt, decodeMobiusBrowserCredential, decodeMobiusChannelAccessGrant, decodeMobiusChannelDescriptor, decodeMobiusInteraction, decodeMobiusInteractionList, decodeMobiusLinkedChannelDeviceList, decodeMobiusMessagePage, decodeMobiusRedeemedChannelCredential, decodeMobiusRuntimeList, decodeMobiusRuntimePairing, decodeMobiusRuntimePairingStatus, decodeMobiusServiceCapabilities, decodeMobiusSession, decodeMobiusSessionExport, decodeMobiusSessionPage, decodeMobiusSessionState, decodeMobiusToolCallDetail, decodeMobiusTurn, decodeRuntimeDescriptor, MobiusPairedRuntimePairingStatus, MobiusRuntimePairingLifecycle, MobiusSessionAccess, } from "./resources.js";
 import { HttpTransport, isMobiusLiveEventTransport, } from "./transport/http-transport.js";
-const MOBIUS_EVENT_FORMAT_VERSION = "1";
-const MOBIUS_SESSION_EVENT_STREAM_EVENT = "mobius.session-event.v1";
-const MOBIUS_SESSION_EVENT_STREAM_MEDIA_TYPE = "text/event-stream";
 const DEFAULT_OPERATION_TIMEOUT_MILLISECONDS = 20_000;
 const DEFAULT_STREAM_CONNECTION_TIMEOUT_MILLISECONDS = 15_000;
 const DEFAULT_STREAM_LIVENESS_TIMEOUT_MILLISECONDS = 45_000;
 const DEFAULT_STREAM_RECONNECT_ATTEMPTS = 4;
-const MAX_EVENT_BLOCK_LENGTH = 9 * 1024 * 1024;
 export function externalContentPath(content) {
     let kind;
     let key;
@@ -176,55 +172,6 @@ class RequestDeadline {
         this.#controller.abort(new Error("The Mobius operation timed out"));
     };
 }
-class StreamConnection {
-    #closed = false;
-    #controller;
-    #hasActivity = false;
-    #livenessTimedOut = false;
-    #livenessTimeoutId;
-    #livenessTimeoutMilliseconds;
-    #release;
-    response;
-    constructor(response, controller, release, livenessTimeoutMilliseconds) {
-        this.#controller = controller;
-        this.#livenessTimeoutMilliseconds = livenessTimeoutMilliseconds;
-        this.#release = release;
-        this.response = response;
-        this.#livenessTimeoutId = globalThis.setTimeout(this.abortFromLivenessTimeout, this.#livenessTimeoutMilliseconds);
-    }
-    get hasActivity() {
-        return this.#hasActivity;
-    }
-    close = () => {
-        if (this.#closed) {
-            return;
-        }
-        this.#closed = true;
-        globalThis.clearTimeout(this.#livenessTimeoutId);
-        this.#controller.abort(new Error("The Mobius event connection closed"));
-        this.#release();
-    };
-    touch = () => {
-        if (this.#closed) {
-            return;
-        }
-        this.#hasActivity = true;
-        globalThis.clearTimeout(this.#livenessTimeoutId);
-        this.#livenessTimeoutId = globalThis.setTimeout(this.abortFromLivenessTimeout, this.#livenessTimeoutMilliseconds);
-    };
-    translateFailure = (cause) => {
-        if (this.#livenessTimedOut) {
-            throw new MobiusTimeoutError({ cause });
-        }
-        throw new MobiusConnectionError("The Mobius event stream was interrupted", {
-            cause,
-        });
-    };
-    abortFromLivenessTimeout = () => {
-        this.#livenessTimedOut = true;
-        this.#controller.abort(new Error("The Mobius event stream became inactive"));
-    };
-}
 class LiveEventConnection {
     events;
     #controller;
@@ -338,71 +285,6 @@ export class MobiusRequestExecutor {
     deleteEmpty = async (path, signal) => {
         await this.requestEmpty(path, "DELETE", signal);
     };
-    openEventStream = async (path, signal) => {
-        const controller = new AbortController();
-        let timedOut = false;
-        const abortFromRequest = () => controller.abort(signal.reason);
-        if (signal.aborted) {
-            abortFromRequest();
-        }
-        else {
-            signal.addEventListener("abort", abortFromRequest, { once: true });
-        }
-        const timeoutId = globalThis.setTimeout(() => {
-            timedOut = true;
-            controller.abort(new Error("The Mobius event stream timed out"));
-        }, this.#streamConnectionTimeoutMilliseconds);
-        const release = () => {
-            globalThis.clearTimeout(timeoutId);
-            signal.removeEventListener("abort", abortFromRequest);
-        };
-        let response;
-        try {
-            const credential = validateCredential(await this.#credentialProvider.credential(controller.signal));
-            response = await this.#transport.fetch(new Request(requestUrl(this.#endpoint, path), {
-                headers: this.authenticationHeaders(credential, MOBIUS_SESSION_EVENT_STREAM_MEDIA_TYPE),
-                signal: controller.signal,
-            }));
-        }
-        catch (cause) {
-            release();
-            if (signal.aborted) {
-                throw new MobiusCancellationError({ cause });
-            }
-            if (timedOut) {
-                throw new MobiusTimeoutError({ cause });
-            }
-            if (cause instanceof MobiusError) {
-                throw cause;
-            }
-            throw new MobiusConnectionError("The Mobius event stream could not connect", { cause });
-        }
-        if (!response.ok) {
-            try {
-                await throwApiError(response);
-            }
-            catch (cause) {
-                release();
-                if (signal.aborted) {
-                    throw new MobiusCancellationError({ cause });
-                }
-                if (timedOut) {
-                    throw new MobiusTimeoutError({ cause });
-                }
-                throw cause;
-            }
-        }
-        globalThis.clearTimeout(timeoutId);
-        const contentType = response.headers.get("content-type") ?? "";
-        if (!contentType.startsWith(MOBIUS_SESSION_EVENT_STREAM_MEDIA_TYPE) ||
-            response.headers.get("x-mobius-event-format") !== MOBIUS_EVENT_FORMAT_VERSION ||
-            response.body === null) {
-            controller.abort(new Error("The Mobius event stream is invalid"));
-            release();
-            throw new MobiusProtocolError("The service returned an invalid Session event stream");
-        }
-        return new StreamConnection(response, controller, release, this.#streamLivenessTimeoutMilliseconds);
-    };
     openLiveEventStream = async (path, signal) => {
         if (!isMobiusLiveEventTransport(this.#transport)) {
             throw new MobiusValidationError("The configured transport does not support live Session events");
@@ -874,387 +756,6 @@ export class MobiusInteractionResources {
         }
     };
 }
-export class MobiusEventSubscription {
-    #controller;
-    #executor;
-    #externalSignal;
-    #maximumReconnectAttempts;
-    #observer;
-    #path;
-    #closed = false;
-    #cursor;
-    #hasSequence = false;
-    #lastSequence = 0n;
-    completed;
-    constructor(executor, path, cursor, observer, signal, controller, firstConnection, maximumReconnectAttempts) {
-        this.#cursor = cursor;
-        this.#controller = controller;
-        this.#executor = executor;
-        this.#externalSignal = signal;
-        this.#maximumReconnectAttempts = maximumReconnectAttempts;
-        this.#observer = observer;
-        this.#path = path;
-        if (this.#externalSignal.aborted) {
-            this.abortFromExternal();
-        }
-        else {
-            this.#externalSignal.addEventListener("abort", this.abortFromExternal, {
-                once: true,
-            });
-        }
-        this.completed = this.run(firstConnection).finally(() => {
-            this.#externalSignal.removeEventListener("abort", this.abortFromExternal);
-        });
-    }
-    get cursor() {
-        return this.#cursor;
-    }
-    close = () => {
-        if (this.#closed) {
-            return;
-        }
-        this.#closed = true;
-        this.#controller.abort(new Error("The Mobius event subscription closed"));
-    };
-    abortFromExternal = () => {
-        this.#controller.abort(this.#externalSignal.reason);
-    };
-    run = async (firstConnection) => {
-        let connection = firstConnection;
-        let reconnectAttempts = 0;
-        while (!this.#closed) {
-            try {
-                const stopped = await this.consume(connection);
-                connection.close();
-                if (stopped || this.#closed) {
-                    this.#closed = true;
-                    return;
-                }
-                throw new MobiusConnectionError("The Mobius event stream closed before the observer stopped it");
-            }
-            catch (cause) {
-                connection.close();
-                if (this.#closed) {
-                    return;
-                }
-                if (connection.hasActivity) {
-                    reconnectAttempts = 0;
-                }
-                try {
-                    const recovery = await this.recover(cause, reconnectAttempts);
-                    reconnectAttempts = recovery.attempts;
-                    connection = recovery.connection;
-                }
-                catch (recoveryCause) {
-                    if (this.#closed) {
-                        return;
-                    }
-                    throw recoveryCause;
-                }
-            }
-        }
-    };
-    consume = async (connection) => {
-        const body = connection.response.body;
-        if (body === null) {
-            throw new MobiusProtocolError("The Mobius event stream has no body");
-        }
-        const reader = body.getReader();
-        const decoder = new TextDecoder();
-        let buffered = "";
-        try {
-            while (!this.#closed) {
-                const result = await reader.read();
-                if (result.done) {
-                    buffered += decoder.decode();
-                    if (buffered.trim().length > 0) {
-                        throw new MobiusProtocolError("The Mobius event stream ended with an incomplete event");
-                    }
-                    return false;
-                }
-                connection.touch();
-                buffered += decoder.decode(result.value, { stream: true });
-                if (buffered.length > MAX_EVENT_BLOCK_LENGTH) {
-                    throw new MobiusProtocolError("The Mobius event stream exceeded its event limit");
-                }
-                let boundary = buffered.indexOf("\n\n");
-                let boundaryLength = 2;
-                const carriageReturnBoundary = buffered.indexOf("\r\n\r\n");
-                if (carriageReturnBoundary >= 0 && (boundary < 0 || carriageReturnBoundary < boundary)) {
-                    boundary = carriageReturnBoundary;
-                    boundaryLength = 4;
-                }
-                while (boundary >= 0) {
-                    const block = buffered.slice(0, boundary);
-                    buffered = buffered.slice(boundary + boundaryLength);
-                    if (await this.consumeBlock(block.replaceAll("\r\n", "\n"))) {
-                        return true;
-                    }
-                    boundary = buffered.indexOf("\n\n");
-                    boundaryLength = 2;
-                    const nextCarriageReturnBoundary = buffered.indexOf("\r\n\r\n");
-                    if (nextCarriageReturnBoundary >= 0 && (boundary < 0 || nextCarriageReturnBoundary < boundary)) {
-                        boundary = nextCarriageReturnBoundary;
-                        boundaryLength = 4;
-                    }
-                }
-            }
-            return true;
-        }
-        catch (cause) {
-            if (this.#closed || this.#controller.signal.aborted) {
-                throw cause;
-            }
-            if (cause instanceof MobiusError) {
-                throw cause;
-            }
-            return connection.translateFailure(cause);
-        }
-        finally {
-            reader.releaseLock();
-        }
-    };
-    consumeBlock = async (block) => {
-        if (block.length === 0 || block.startsWith(":")) {
-            return false;
-        }
-        let eventName = "";
-        let eventId = "";
-        let data = "";
-        for (const line of block.split("\n")) {
-            if (line.startsWith("event:")) {
-                eventName = line.slice("event:".length).trimStart();
-            }
-            else if (line.startsWith("id:")) {
-                eventId = line.slice("id:".length).trimStart();
-            }
-            else if (line.startsWith("data:")) {
-                data += `${line.slice("data:".length).trimStart()}\n`;
-            }
-            else if (!line.startsWith(":")) {
-                throw new MobiusProtocolError("The Mobius event stream contains an invalid field");
-            }
-        }
-        if (eventName !== MOBIUS_SESSION_EVENT_STREAM_EVENT || data.length === 0) {
-            throw new MobiusProtocolError("The Mobius event stream contains an unsupported event");
-        }
-        let value;
-        try {
-            value = JSON.parse(data.slice(0, -1));
-        }
-        catch (cause) {
-            throw new MobiusProtocolError("The Mobius event stream contains invalid JSON", { cause });
-        }
-        const event = decodeMobiusSessionEvent(value);
-        if (event.cursor !== eventId) {
-            throw new MobiusProtocolError("The Mobius event identifier does not match its cursor");
-        }
-        const sequence = BigInt(event.sequence);
-        if (this.#hasSequence && sequence <= this.#lastSequence) {
-            return false;
-        }
-        if (this.#hasSequence && sequence !== this.#lastSequence + 1n) {
-            throw new MobiusProtocolError("The Mobius event stream contains a gap");
-        }
-        let shouldContinue;
-        try {
-            shouldContinue = await this.#observer.receive(event);
-        }
-        catch (cause) {
-            throw new MobiusError("event_observer_failed", "The Mobius event observer failed", { cause });
-        }
-        this.#cursor = event.cursor;
-        this.#hasSequence = true;
-        this.#lastSequence = sequence;
-        return !shouldContinue;
-    };
-    pathWithCursor = () => {
-        if (this.#cursor.length === 0) {
-            return this.#path;
-        }
-        return `${this.#path}${this.#path.includes("?") ? "&" : "?"}cursor=${encodeURIComponent(this.#cursor)}`;
-    };
-    recover = async (initialCause, completedAttempts) => {
-        this.throwIfTerminal(initialCause);
-        let attempts = completedAttempts;
-        let latestCause = initialCause;
-        while (attempts < this.#maximumReconnectAttempts) {
-            attempts += 1;
-            await this.reconnectDelay(attempts);
-            try {
-                return new MobiusEventStreamRecovery(await this.#executor.openEventStream(this.pathWithCursor(), this.#controller.signal), attempts);
-            }
-            catch (cause) {
-                latestCause = cause;
-                this.throwIfTerminal(cause);
-            }
-        }
-        throw new MobiusConnectionError("The Mobius event stream could not recover", { cause: latestCause });
-    };
-    throwIfTerminal = (cause) => {
-        if (this.#externalSignal.aborted) {
-            throw new MobiusCancellationError({ cause });
-        }
-        if (cause instanceof MobiusProtocolError ||
-            (cause instanceof MobiusApiError && cause.status < 500) ||
-            (cause instanceof MobiusError &&
-                !(cause instanceof MobiusConnectionError) &&
-                !(cause instanceof MobiusTimeoutError) &&
-                !(cause instanceof MobiusApiError))) {
-            throw cause;
-        }
-    };
-    reconnectDelay = async (attempt) => {
-        const delayMilliseconds = Math.min(250 * 2 ** (attempt - 1), 2_000);
-        await new Promise((resolve, reject) => {
-            const timeoutId = globalThis.setTimeout(() => {
-                this.#controller.signal.removeEventListener("abort", abort);
-                resolve();
-            }, delayMilliseconds);
-            const abort = () => {
-                globalThis.clearTimeout(timeoutId);
-                reject(new MobiusCancellationError());
-            };
-            this.#controller.signal.addEventListener("abort", abort, { once: true });
-        });
-    };
-}
-class MobiusEventStreamRecovery {
-    attempts;
-    connection;
-    constructor(connection, attempts) {
-        this.attempts = attempts;
-        this.connection = connection;
-    }
-}
-export class MobiusLiveEventSubscription {
-    #controller = new AbortController();
-    #executor;
-    #maximumReconnectAttempts;
-    #observer;
-    #path;
-    #closed = false;
-    connected;
-    completed;
-    constructor(executor, path, observer, signal, maximumReconnectAttempts) {
-        this.#executor = executor;
-        this.#maximumReconnectAttempts = maximumReconnectAttempts;
-        this.#observer = observer;
-        this.#path = path;
-        const abort = () => this.#controller.abort(signal.reason);
-        if (signal.aborted) {
-            abort();
-        }
-        else {
-            signal.addEventListener("abort", abort, { once: true });
-        }
-        let resolveConnected = () => undefined;
-        let rejectConnected = (_cause) => undefined;
-        this.connected = new Promise((resolve, reject) => {
-            resolveConnected = resolve;
-            rejectConnected = reject;
-        });
-        this.completed = this.run(resolveConnected, rejectConnected).finally(() => signal.removeEventListener("abort", abort));
-    }
-    close = () => {
-        if (this.#closed) {
-            return;
-        }
-        this.#closed = true;
-        this.#controller.abort(new Error("The live Session event subscription closed"));
-    };
-    run = async (resolveConnected, rejectConnected) => {
-        let attempts = 0;
-        let connectionState = { kind: "initial" };
-        while (!this.#closed) {
-            let connection = null;
-            try {
-                connection = await this.#executor.openLiveEventStream(this.#path, this.#controller.signal);
-                await this.#observer.reconcile(connectionState);
-                if (connectionState.kind === "initial") {
-                    resolveConnected();
-                    connectionState = { kind: "reconnected" };
-                }
-                attempts = 0;
-                const reader = connection.events.getReader();
-                try {
-                    while (!this.#closed) {
-                        const result = await reader.read();
-                        if (result.done) {
-                            throw new MobiusConnectionError("The live Session event stream disconnected");
-                        }
-                        let value;
-                        try {
-                            value = JSON.parse(result.value.data);
-                        }
-                        catch (cause) {
-                            throw new MobiusProtocolError("The live Session event stream contains invalid JSON", {
-                                cause,
-                            });
-                        }
-                        const event = decodeMobiusSessionEvent(value);
-                        if (event.cursor !== result.value.eventId) {
-                            throw new MobiusProtocolError("The live Session event identifier is invalid");
-                        }
-                        if (!(await this.#observer.receive(event))) {
-                            this.close();
-                        }
-                    }
-                }
-                finally {
-                    reader.releaseLock();
-                }
-            }
-            catch (cause) {
-                if (this.#closed || this.#controller.signal.aborted) {
-                    if (connectionState.kind === "initial") {
-                        rejectConnected(new MobiusCancellationError({ cause }));
-                    }
-                    return;
-                }
-                if (cause instanceof MobiusProtocolError ||
-                    (cause instanceof MobiusApiError && cause.status < 500) ||
-                    (cause instanceof MobiusError &&
-                        !(cause instanceof MobiusConnectionError) &&
-                        !(cause instanceof MobiusTimeoutError) &&
-                        !(cause instanceof MobiusApiError))) {
-                    if (connectionState.kind === "initial") {
-                        rejectConnected(cause);
-                    }
-                    throw cause;
-                }
-                attempts += 1;
-                if (attempts > this.#maximumReconnectAttempts) {
-                    const failure = new MobiusConnectionError("The live Session event stream could not recover", {
-                        cause,
-                    });
-                    if (connectionState.kind === "initial") {
-                        rejectConnected(failure);
-                    }
-                    throw failure;
-                }
-                await this.reconnectDelay(attempts);
-            }
-            finally {
-                connection?.close();
-            }
-        }
-    };
-    reconnectDelay = async (attempt) => {
-        const delayMilliseconds = Math.min(250 * 2 ** (attempt - 1), 2_000);
-        await new Promise((resolve, reject) => {
-            const timeoutId = globalThis.setTimeout(() => {
-                this.#controller.signal.removeEventListener("abort", abort);
-                resolve();
-            }, delayMilliseconds);
-            const abort = () => {
-                globalThis.clearTimeout(timeoutId);
-                reject(new MobiusCancellationError());
-            };
-            this.#controller.signal.addEventListener("abort", abort, { once: true });
-        });
-    };
-}
 export class MobiusLiveEventSubscriptionV2 {
     #controller = new AbortController();
     #executor;
@@ -1320,8 +821,8 @@ export class MobiusLiveEventSubscriptionV2 {
                                 cause,
                             });
                         }
-                        const event = decodeSessionEventV2(value);
-                        if (!(await this.#observer.receive(event))) {
+                        const events = decodeSessionEventBatchV2(value);
+                        if (!(await this.#observer.receive(events))) {
                             this.close();
                         }
                     }
@@ -1384,50 +885,12 @@ export class MobiusEventResources {
     #executor;
     #maximumReconnectAttempts;
     #projectId;
-    #subscriptions = new Set();
-    #liveSubscriptions = new Set();
     #liveSubscriptionsV2 = new Set();
     constructor(executor, projectId, maximumReconnectAttempts) {
         this.#executor = executor;
         this.#maximumReconnectAttempts = maximumReconnectAttempts;
         this.#projectId = projectId;
     }
-    subscribe = async (sessionId, cursor, observer, signal) => {
-        if (cursor.length > 512) {
-            throw new MobiusValidationError("The Session event cursor is invalid");
-        }
-        const path = sessionPath(this.#projectId, sessionId, "events");
-        const streamPath = cursor.length === 0 ? path : `${path}?cursor=${encodeURIComponent(cursor)}`;
-        const controller = new AbortController();
-        const abortFromExternal = () => controller.abort(signal.reason);
-        if (signal.aborted) {
-            abortFromExternal();
-        }
-        else {
-            signal.addEventListener("abort", abortFromExternal, { once: true });
-        }
-        let firstConnection;
-        try {
-            firstConnection = await this.#executor.openEventStream(streamPath, controller.signal);
-        }
-        finally {
-            signal.removeEventListener("abort", abortFromExternal);
-        }
-        const subscription = new MobiusEventSubscription(this.#executor, path, cursor, observer, signal, controller, firstConnection, this.#maximumReconnectAttempts);
-        this.#subscriptions.add(subscription);
-        const remove = subscription.completed.finally(() => {
-            this.#subscriptions.delete(subscription);
-        });
-        void remove.catch(() => { });
-        return subscription;
-    };
-    subscribeLive = async (sessionId, observer, signal) => {
-        const subscription = new MobiusLiveEventSubscription(this.#executor, sessionPath(this.#projectId, sessionId, "events"), observer, signal, this.#maximumReconnectAttempts);
-        this.#liveSubscriptions.add(subscription);
-        void subscription.completed.finally(() => this.#liveSubscriptions.delete(subscription)).catch(() => undefined);
-        await subscription.connected;
-        return subscription;
-    };
     subscribeLiveV2 = async (sessionId, observer, signal) => {
         const subscription = new MobiusLiveEventSubscriptionV2(this.#executor, sessionPath(this.#projectId, sessionId, "events-v2"), observer, signal, this.#maximumReconnectAttempts);
         this.#liveSubscriptionsV2.add(subscription);
@@ -1445,35 +908,7 @@ export class MobiusEventResources {
         }
         return decodeSessionEventLogPageV2(await this.#executor.get(`${path.pathname.slice(1)}${path.search}`, signal));
     };
-    list = async (sessionId, page, signal) => {
-        const path = requestUrl(new URL("https://mobius.invalid/"), sessionPath(this.#projectId, sessionId, "events"));
-        path.searchParams.set("limit", page.limit.toString());
-        if (page.cursor.length > 0) {
-            path.searchParams.set("cursor", page.cursor);
-        }
-        return decodeMobiusEventPage(await this.#executor.get(`${path.pathname.slice(1)}${path.search}`, signal));
-    };
-    wait = async (sessionId, page, waitMilliseconds, signal) => {
-        if (!Number.isSafeInteger(waitMilliseconds) || waitMilliseconds < 1 || waitMilliseconds > 10_000) {
-            throw new MobiusValidationError("The Session event wait is invalid");
-        }
-        const path = requestUrl(new URL("https://mobius.invalid/"), sessionPath(this.#projectId, sessionId, "events"));
-        path.searchParams.set("limit", page.limit.toString());
-        path.searchParams.set("wait", waitMilliseconds.toString());
-        if (page.cursor.length > 0) {
-            path.searchParams.set("cursor", page.cursor);
-        }
-        return decodeMobiusEventPage(await this.#executor.get(`${path.pathname.slice(1)}${path.search}`, signal));
-    };
     close = () => {
-        for (const subscription of this.#subscriptions) {
-            subscription.close();
-        }
-        this.#subscriptions.clear();
-        for (const subscription of this.#liveSubscriptions) {
-            subscription.close();
-        }
-        this.#liveSubscriptions.clear();
         for (const subscription of this.#liveSubscriptionsV2) {
             subscription.close();
         }