@moxt-ai/mobius-sdk 0.0.23 → 0.0.26

package/dist/service-client.js

@@ -1,12 +1,8 @@
-import { decodeAgentSettingsDiscoveredEvent, decodeNativeMessagePage, decodeNativeSessionResult, decodeSessionConfigUpdatedEvent, decodeSessionReadyEvent, decodeWorkspaceEntriesEvent, MOBIUS_API_PREFIX, MOBIUS_EVENT_FORMAT_VERSION, MOBIUS_SESSION_EVENT_STREAM_EVENT, MOBIUS_SESSION_EVENT_STREAM_MEDIA_TYPE, SessionPromptDisposition, } from "@moxt-ai/mobius-protocol";
+import { decodeAgentSettingsDiscoveredEvent, decodeNativeSessionResult, decodeWorkspaceEntriesEvent, MOBIUS_API_PREFIX, } from "@moxt-ai/mobius-protocol";
 import { MobiusApiError, MobiusCancellationError, MobiusConnectionError, MobiusError, MobiusProtocolError, MobiusTimeoutError, MobiusValidationError, } from "./errors.js";
-import { decodeMobiusAttempt, decodeMobiusBrowserCredential, decodeMobiusEventPage, decodeMobiusInteraction, decodeMobiusInteractionList, decodeMobiusMessagePage, decodeMobiusRuntimeList, decodeMobiusRuntimePairing, decodeMobiusRuntimePairingStatus, decodeMobiusServiceCapabilities, decodeMobiusSession, decodeMobiusSessionEvent, decodeMobiusSessionExport, decodeMobiusSessionPage, decodeMobiusSessionState, decodeMobiusToolCallDetail, decodeMobiusTurn, MobiusPageRequest, MobiusPairedRuntimePairingStatus, MobiusRuntimePairingLifecycle, MobiusSessionAccess, } from "./resources.js";
-import { HttpTransport, isMobiusLiveEventTransport, } from "./transport/http-transport.js";
+import { decodeMobiusBrowserCredential, decodeMobiusRuntimeList, decodeMobiusRuntimePairing, decodeMobiusRuntimePairingStatus, MobiusPairedRuntimePairingStatus, MobiusRuntimePairingLifecycle, } from "./resources.js";
+import { HttpTransport } from "./transport/http-transport.js";
 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 class StaticMobiusCredentialProvider {
     #token;
     constructor(token) {
@@ -64,12 +60,6 @@ function projectPath(projectId, resourcePath) {
     }
     return `v1/projects/${encodeURIComponent(projectId)}/${resourcePath}`;
 }
-function sessionPath(projectId, sessionId, resourcePath) {
-    if (!/^[a-zA-Z0-9][a-zA-Z0-9._:-]{0,127}$/.test(sessionId)) {
-        throw new MobiusValidationError("The Mobius Session identifier is invalid");
-    }
-    return projectPath(projectId, `sessions/${encodeURIComponent(sessionId)}/${resourcePath}`);
-}
 function requestUrl(endpoint, path) {
     return new URL(path, endpoint);
 }
@@ -148,82 +138,12 @@ 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;
-    #release;
-    #closed = false;
-    constructor(events, controller, release) {
-        this.events = events;
-        this.#controller = controller;
-        this.#release = release;
-    }
-    close = () => {
-        if (this.#closed) {
-            return;
-        }
-        this.#closed = true;
-        this.#controller.abort(new Error("The live Session event connection closed"));
-        this.#release();
-    };
-}
 export class MobiusRequestExecutor {
     #authenticationProviderId;
     #credentialProvider;
     #endpoint;
     #operationTimeoutMilliseconds;
     #observeResponse;
-    #streamConnectionTimeoutMilliseconds;
-    #streamLivenessTimeoutMilliseconds;
     #transport;
     constructor(options) {
         const authenticationProviderId = options.authenticationProviderId ?? "";
@@ -237,61 +157,9 @@ export class MobiusRequestExecutor {
         this.#endpoint = normalizeEndpoint(options.endpoint);
         this.#operationTimeoutMilliseconds = validatePositiveInteger(options.operationTimeoutMilliseconds ?? DEFAULT_OPERATION_TIMEOUT_MILLISECONDS, "operation timeout");
         this.#observeResponse = options.observeResponse;
-        this.#streamConnectionTimeoutMilliseconds = validatePositiveInteger(options.streamConnectionTimeoutMilliseconds ?? DEFAULT_STREAM_CONNECTION_TIMEOUT_MILLISECONDS, "stream connection timeout");
-        this.#streamLivenessTimeoutMilliseconds = validatePositiveInteger(options.streamLivenessTimeoutMilliseconds ?? DEFAULT_STREAM_LIVENESS_TIMEOUT_MILLISECONDS, "stream liveness timeout");
         this.#transport = options.transport ?? new HttpTransport();
     }
     get = async (path, signal) => await this.request(path, "GET", "", false, signal);
-    getFile = async (path, maximumBytes, signal) => {
-        const deadline = new RequestDeadline(signal, this.#operationTimeoutMilliseconds);
-        try {
-            const credential = validateCredential(await this.#credentialProvider.credential(deadline.signal));
-            const response = await this.#transport.fetch(new Request(requestUrl(this.#endpoint, path), {
-                headers: this.authenticationHeaders(credential, "application/octet-stream"),
-                signal: deadline.signal,
-            }));
-            this.#observeResponse?.({
-                serverTiming: response.headers.get("server-timing"),
-                status: response.status,
-            });
-            if (!response.ok) {
-                await throwApiError(response);
-            }
-            const mediaType = response.headers.get("content-type") ?? "";
-            const modifiedAt = response.headers.get("last-modified") ?? "";
-            const encodedName = response.headers.get("x-mobius-file-name") ?? "";
-            const encodedLength = response.headers.get("x-mobius-byte-length") ?? "";
-            if (mediaType.length === 0 ||
-                mediaType.length > 255 ||
-                modifiedAt.length === 0 ||
-                !/^\d+$/.test(encodedLength)) {
-                throw new MobiusProtocolError("The service returned invalid file metadata");
-            }
-            const byteLength = Number(encodedLength);
-            if (!Number.isSafeInteger(byteLength) || byteLength < 1 || byteLength > maximumBytes) {
-                throw new MobiusProtocolError("The service returned an invalid file size");
-            }
-            let name;
-            try {
-                name = decodeURIComponent(encodedName);
-            }
-            catch (cause) {
-                throw new MobiusProtocolError("The service returned an invalid file name", { cause });
-            }
-            return {
-                bytes: await readExactResponseBytes(response, byteLength, deadline.signal, false),
-                mediaType,
-                modifiedAt,
-                name,
-            };
-        }
-        catch (cause) {
-            return deadline.translate(cause);
-        }
-        finally {
-            deadline.finish();
-        }
-    };
     post = async (path, body, signal) => {
         const encoded = JSON.stringify(body);
         if (typeof encoded !== "string") {
@@ -310,103 +178,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");
-        }
-        const controller = new AbortController();
-        const abort = () => controller.abort(signal.reason);
-        signal.addEventListener("abort", abort, { once: true });
-        const timeoutId = globalThis.setTimeout(() => controller.abort(new Error("The live Session event connection timed out")), this.#streamConnectionTimeoutMilliseconds);
-        const release = () => {
-            globalThis.clearTimeout(timeoutId);
-            signal.removeEventListener("abort", abort);
-        };
-        try {
-            const credential = validateCredential(await this.#credentialProvider.credential(controller.signal));
-            const events = await this.#transport.openLiveSessionEvents(new Request(requestUrl(this.#endpoint, path), {
-                headers: this.authenticationHeaders(credential, "application/json"),
-                signal: controller.signal,
-            }));
-            globalThis.clearTimeout(timeoutId);
-            return new LiveEventConnection(events, controller, release);
-        }
-        catch (cause) {
-            release();
-            if (signal.aborted) {
-                throw new MobiusCancellationError({ cause });
-            }
-            if (cause instanceof MobiusError) {
-                throw cause;
-            }
-            throw new MobiusConnectionError("The live Session event stream could not connect", { cause });
-        }
-    };
     request = async (path, method, body, hasBody, signal) => {
         const deadline = new RequestDeadline(signal, this.#operationTimeoutMilliseconds);
         try {
@@ -472,63 +243,6 @@ export class MobiusRequestExecutor {
         return headers;
     };
 }
-export async function readExactResponseBytes(response, expectedByteLength, signal, verifyDigest = true) {
-    const declaredLength = response.headers.get("content-length");
-    if (declaredLength !== null &&
-        (!/^(0|[1-9][0-9]*)$/.test(declaredLength) || Number(declaredLength) !== expectedByteLength)) {
-        throw new MobiusProtocolError("The service returned an invalid artifact length");
-    }
-    const reader = response.body?.getReader();
-    if (reader === undefined) {
-        throw new MobiusProtocolError("The service returned no artifact content");
-    }
-    const chunks = [];
-    let byteLength = 0;
-    try {
-        while (true) {
-            signal.throwIfAborted();
-            const chunk = await reader.read();
-            signal.throwIfAborted();
-            if (chunk.done) {
-                break;
-            }
-            byteLength += chunk.value.byteLength;
-            if (byteLength > expectedByteLength) {
-                await reader.cancel("Artifact response exceeded its metadata");
-                throw new MobiusProtocolError("The service returned an oversized artifact");
-            }
-            chunks.push(chunk.value);
-        }
-    }
-    finally {
-        reader.releaseLock();
-    }
-    if (byteLength !== expectedByteLength) {
-        throw new MobiusProtocolError("The service returned an incomplete artifact");
-    }
-    const bytes = new Uint8Array(byteLength);
-    let offset = 0;
-    for (const chunk of chunks) {
-        bytes.set(chunk, offset);
-        offset += chunk.byteLength;
-    }
-    if (verifyDigest) {
-        const digest = await crypto.subtle.digest("SHA-256", bytes);
-        signal.throwIfAborted();
-        const sha256 = Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("");
-        if (sha256 !== response.headers.get("x-mobius-sha256")) {
-            throw new MobiusProtocolError("The service returned artifact content with an invalid digest");
-        }
-    }
-    return bytes;
-}
-export class MobiusCapabilityResources {
-    #executor;
-    constructor(executor) {
-        this.#executor = executor;
-    }
-    read = async (signal) => decodeMobiusServiceCapabilities(await this.#executor.get("capabilities", signal));
-}
 export class MobiusCredentialResources {
     #executor;
     #projectId;
@@ -623,599 +337,15 @@ function waitForPairingPoll(milliseconds, signal) {
         signal.addEventListener("abort", cancel, { once: true });
     });
 }
-export class MobiusSessionResources {
-    #executor;
-    #projectId;
-    constructor(executor, projectId) {
-        this.#executor = executor;
-        this.#projectId = projectId;
-    }
-    create = async (request, signal) => decodeMobiusSession(await this.#executor.post(projectPath(this.#projectId, "sessions"), request, signal));
-    createAccess = async (sessionId, expiresInSeconds, signal) => new MobiusSessionAccess(await this.#executor.post(sessionPath(this.#projectId, sessionId, "access-credentials"), { expiresInSeconds }, signal));
-    prepare = async (sessionId, signal) => decodeSessionReadyEvent(JSON.stringify(await this.#executor.post(sessionPath(this.#projectId, sessionId, "prepare"), {}, signal)));
-    updateConfiguration = async (sessionId, request, signal) => decodeSessionConfigUpdatedEvent(JSON.stringify(await this.#executor.post(sessionPath(this.#projectId, sessionId, "configuration"), request, signal)));
-    configure = async (sessionId, request, signal) => decodeMobiusSession(await this.#executor.put(sessionPath(this.#projectId, sessionId, "binding"), request, signal));
-    delete = async (sessionId, signal) => decodeMobiusSessionState(await this.#executor.delete(sessionPath(this.#projectId, sessionId, "").slice(0, -1), signal));
-    export = async (sessionId, signal) => decodeMobiusSessionExport(await this.#executor.get(sessionPath(this.#projectId, sessionId, "export"), signal));
-    import = async (exported, targetBinding, signal) => decodeMobiusSession(await this.#executor.post(projectPath(this.#projectId, "session-imports"), {
-        formatVersion: exported.formatVersion,
-        session: exported.session,
-        targetBinding,
-    }, signal));
-    read = async (sessionId, signal) => decodeMobiusSession(await this.#executor.get(sessionPath(this.#projectId, sessionId, "").slice(0, -1), signal));
-    readFile = async (sessionId, path, signal, maximumBytes = 32 * 1024 * 1024) => {
-        if (path.length === 0 || path.length > 4_096) {
-            throw new MobiusValidationError("The file path is invalid");
-        }
-        if (!Number.isSafeInteger(maximumBytes) || maximumBytes < 1 || maximumBytes > 128 * 1024 * 1024) {
-            throw new MobiusValidationError("The file size limit is invalid");
-        }
-        const query = new URLSearchParams({ maxBytes: maximumBytes.toString(), path });
-        return await this.#executor.getFile(`${sessionPath(this.#projectId, sessionId, "files/content")}?${query.toString()}`, maximumBytes, signal);
-    };
-    list = async (page, signal) => {
-        const path = requestUrl(new URL("https://mobius.invalid/"), projectPath(this.#projectId, "sessions"));
-        path.searchParams.set("limit", page.limit.toString());
-        if (page.cursor.length > 0) {
-            path.searchParams.set("cursor", page.cursor);
-        }
-        return decodeMobiusSessionPage(await this.#executor.get(`${path.pathname.slice(1)}${path.search}`, signal));
-    };
-    readMessages = async (sessionId, page, signal) => {
-        const path = requestUrl(new URL("https://mobius.invalid/"), sessionPath(this.#projectId, sessionId, "messages"));
-        path.searchParams.set("limit", page.limit.toString());
-        if (page.cursor.length > 0) {
-            path.searchParams.set("cursor", page.cursor);
-        }
-        return decodeMobiusMessagePage(await this.#executor.get(`${path.pathname.slice(1)}${path.search}`, signal));
-    };
-    queryNativeMessages = async (...request) => {
-        const [sessionId, page, signal] = request.length === 2
-            ? [request[0], new MobiusPageRequest(50, ""), request[1]]
-            : [request[0], request[1], request[2]];
-        try {
-            const path = requestUrl(new URL("https://mobius.invalid/"), sessionPath(this.#projectId, sessionId, "native-messages"));
-            path.searchParams.set("limit", page.limit.toString());
-            if (page.cursor.length > 0) {
-                path.searchParams.set("cursor", page.cursor);
-            }
-            return decodeNativeMessagePage(await this.#executor.get(`${path.pathname.slice(1)}${path.search}`, signal));
-        }
-        catch (cause) {
-            if (cause instanceof MobiusError) {
-                throw cause;
-            }
-            throw new MobiusProtocolError("The service returned invalid native messages", { cause });
-        }
-    };
-}
-export class MobiusTurnResources {
-    #executor;
-    #projectId;
-    constructor(executor, projectId) {
-        this.#executor = executor;
-        this.#projectId = projectId;
-    }
-    submit = async (sessionId, request, signal) => decodeMobiusTurn(await this.#executor.post(sessionPath(this.#projectId, sessionId, "turns"), request, signal));
-    read = async (sessionId, turnId, signal) => decodeMobiusTurn(await this.#executor.get(sessionPath(this.#projectId, sessionId, `turns/${encodeURIComponent(turnId)}`), signal));
-    cancel = async (sessionId, turnId, request, signal) => decodeMobiusTurn(await this.#executor.post(sessionPath(this.#projectId, sessionId, `turns/${encodeURIComponent(turnId)}/cancel`), request, signal));
-    steer = async (sessionId, turnId, signal) => decodeMobiusTurn(await this.#executor.put(sessionPath(this.#projectId, sessionId, `turns/${encodeURIComponent(turnId)}/disposition`), { disposition: SessionPromptDisposition.Steer }, signal));
-}
-export class MobiusAttemptResources {
-    #executor;
-    #projectId;
-    constructor(executor, projectId) {
-        this.#executor = executor;
-        this.#projectId = projectId;
-    }
-    read = async (sessionId, attemptId, signal) => decodeMobiusAttempt(await this.#executor.get(sessionPath(this.#projectId, sessionId, `attempts/${encodeURIComponent(attemptId)}`), signal));
-}
-export class MobiusToolCallResources {
-    #executor;
-    #projectId;
-    constructor(executor, projectId) {
-        this.#executor = executor;
-        this.#projectId = projectId;
-    }
-    readDetail = async (sessionId, attemptId, toolCallId, signal) => decodeMobiusToolCallDetail(await this.#executor.get(sessionPath(this.#projectId, sessionId, `attempts/${encodeURIComponent(attemptId)}/tool-calls/${encodeURIComponent(toolCallId)}`), signal));
-}
-export class MobiusInteractionResources {
-    #executor;
-    #projectId;
-    constructor(executor, projectId) {
-        this.#executor = executor;
-        this.#projectId = projectId;
-    }
-    listPending = async (sessionId, signal) => decodeMobiusInteractionList(await this.#executor.get(sessionPath(this.#projectId, sessionId, "interactions"), signal));
-    read = async (sessionId, interactionId, signal) => decodeMobiusInteraction(await this.#executor.get(sessionPath(this.#projectId, sessionId, `interactions/${encodeURIComponent(interactionId)}`), signal));
-    respond = async (sessionId, interactionId, request, signal) => decodeMobiusInteraction(await this.#executor.post(sessionPath(this.#projectId, sessionId, `interactions/${encodeURIComponent(interactionId)}/responses`), request, signal));
-}
-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 MobiusEventResources {
-    #executor;
-    #maximumReconnectAttempts;
-    #projectId;
-    #subscriptions = new Set();
-    #liveSubscriptions = 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;
-    };
-    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();
-    };
-}
 export class MobiusClient {
-    attempts;
-    capabilities;
     credentials;
-    events;
-    interactions;
     runtimePairings;
     runtimes;
-    sessions;
-    turns;
-    toolCalls;
     constructor(options) {
         const executor = new MobiusRequestExecutor(options);
-        const reconnectAttempts = validatePositiveInteger(options.maxStreamReconnectAttempts ?? DEFAULT_STREAM_RECONNECT_ATTEMPTS, "stream reconnect attempt limit");
-        this.attempts = new MobiusAttemptResources(executor, options.projectId);
-        this.capabilities = new MobiusCapabilityResources(executor);
         this.credentials = new MobiusCredentialResources(executor, options.projectId);
-        this.events = new MobiusEventResources(executor, options.projectId, reconnectAttempts);
-        this.interactions = new MobiusInteractionResources(executor, options.projectId);
         this.runtimePairings = new MobiusRuntimePairingResources(executor, options.projectId);
         this.runtimes = new MobiusRuntimeResources(executor, options.projectId);
-        this.sessions = new MobiusSessionResources(executor, options.projectId);
-        this.turns = new MobiusTurnResources(executor, options.projectId);
-        this.toolCalls = new MobiusToolCallResources(executor, options.projectId);
     }
-    close = () => {
-        this.events.close();
-    };
 }
 //# sourceMappingURL=service-client.js.map