@moxt-ai/mobius-sdk 0.0.29 → 0.0.30

package/dist/service-client.js

@@ -1,8 +1,15 @@
-import { decodeAgentSettingsDiscoveredEvent, decodeNativeSessionResult, decodeWorkspaceEntriesEvent, MOBIUS_API_PREFIX, } from "@moxt-ai/mobius-protocol";
+import { decodeAgentSettingsDiscoveredEvent, decodeNativeMessagePage, decodeNativeSessionResult, decodeSessionConfigUpdatedEvent, decodeSessionReadyEvent, decodeSessionsQueriedEvent, decodeWorkspaceEntriesEvent, MOBIUS_API_PREFIX, SessionPromptDisposition, } from "@moxt-ai/mobius-protocol";
 import { MobiusApiError, MobiusCancellationError, MobiusConnectionError, MobiusError, MobiusProtocolError, MobiusTimeoutError, MobiusValidationError, } from "./errors.js";
-import { decodeMobiusBrowserCredential, decodeMobiusRuntimeList, decodeMobiusRuntimePairing, decodeMobiusRuntimePairingStatus, MobiusPairedRuntimePairingStatus, MobiusRuntimePairingLifecycle, } from "./resources.js";
-import { HttpTransport } from "./transport/http-transport.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";
+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 class StaticMobiusCredentialProvider {
     #token;
     constructor(token) {
@@ -60,6 +67,12 @@ 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);
 }
@@ -138,12 +151,82 @@ 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 ?? "";
@@ -157,9 +240,61 @@ 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") {
@@ -178,6 +313,103 @@ 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 {
@@ -243,6 +475,63 @@ 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;
@@ -269,6 +558,7 @@ export class MobiusRuntimeResources {
     listWorkspace = async (runtimeId, directoryId, signal) => decodeWorkspaceEntriesEvent(JSON.stringify(await this.#executor.post(projectPath(this.#projectId, `runtimes/${encodeURIComponent(runtimeId)}/workspace`), { directoryId }, signal)));
     discoverAgentSettings = async (runtimeId, agentId, request, signal) => decodeAgentSettingsDiscoveredEvent(JSON.stringify(await this.#executor.post(projectPath(this.#projectId, `runtimes/${encodeURIComponent(runtimeId)}/agents/${encodeURIComponent(agentId)}/settings`), request, signal)));
     nativeSessions = async (runtimeId, request, signal) => decodeNativeSessionResult(JSON.stringify(await this.#executor.post(projectPath(this.#projectId, `runtimes/${encodeURIComponent(runtimeId)}/native-sessions`), request, signal)));
+    querySessions = async (runtimeId, sessionIds, signal) => decodeSessionsQueriedEvent(JSON.stringify(await this.#executor.post(projectPath(this.#projectId, `runtimes/${encodeURIComponent(runtimeId)}/sessions/query`), { sessionIds }, signal))).entries;
     findNativeSessionByNativeSessionId = async (runtimeId, request, signal) => {
         const result = decodeNativeSessionResult(JSON.stringify(await this.#executor.post(projectPath(this.#projectId, `runtimes/${encodeURIComponent(runtimeId)}/native-sessions`), { ...request, action: "find" }, signal)));
         if (result.action !== "find") {
@@ -337,15 +627,630 @@ 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) => decodeSessionReadyEvent(JSON.stringify(await this.#executor.post(projectPath(this.#projectId, `runtimes/${encodeURIComponent(request.runtimeId)}/sessions`), request, signal)));
+    createAccess = async (sessionId, expiresInSeconds, signal) => new MobiusSessionAccess(await this.#executor.post(sessionPath(this.#projectId, sessionId, "access-credentials"), { expiresInSeconds }, signal));
+    load = async (runtimeId, sessionId, request, signal) => decodeSessionReadyEvent(JSON.stringify(await this.#executor.post(projectPath(this.#projectId, `runtimes/${encodeURIComponent(runtimeId)}/sessions/${encodeURIComponent(sessionId)}/load`), request, signal)));
+    updateConfiguration = async (...operation) => {
+        const result = operation.length === 3
+            ? await this.#executor.post(sessionPath(this.#projectId, operation[0], "configuration"), operation[1], operation[2])
+            : await this.#executor.post(projectPath(this.#projectId, `runtimes/${encodeURIComponent(operation[0])}/sessions/${encodeURIComponent(operation[1])}/configuration`), operation[2], operation[3]);
+        return decodeSessionConfigUpdatedEvent(JSON.stringify(result));
+    };
+    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) => {
+        if (request.length === 2 || request.length === 3) {
+            const sessionId = request[0];
+            const page = request.length === 2 ? new MobiusPageRequest(50, "") : request[1];
+            const signal = request.length === 2 ? request[1] : request[2];
+            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));
+        }
+        const [runtimeId, sessionId, identity, page, signal] = request.length === 4
+            ? [request[0], request[1], request[2], new MobiusPageRequest(50, ""), request[3]]
+            : request;
+        try {
+            const result = await this.#executor.post(projectPath(this.#projectId, `runtimes/${encodeURIComponent(runtimeId)}/sessions/${encodeURIComponent(sessionId)}/native-messages`), { ...identity, cursor: page.cursor.length === 0 ? null : page.cursor, limit: page.limit }, signal);
+            if (typeof result !== "object" || result === null || !("page" in result)) {
+                throw new MobiusProtocolError("The service returned invalid native messages");
+            }
+            return decodeNativeMessagePage(Reflect.get(result, "page"));
+        }
+        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));
+    submitToRuntime = async (runtimeId, sessionId, request, signal) => {
+        const result = await this.#executor.post(projectPath(this.#projectId, `runtimes/${encodeURIComponent(runtimeId)}/sessions/${encodeURIComponent(sessionId)}/turns`), {
+            ...request,
+            disposition: request.disposition ?? "reject",
+            sessionConfigurations: request.sessionConfigurations ?? [],
+            targetCommandId: request.targetCommandId ?? "",
+        }, signal);
+        if (typeof result !== "object" || result === null || !("turnId" in result)) {
+            throw new MobiusProtocolError("The service returned an invalid Turn");
+        }
+        const turnId = Reflect.get(result, "turnId");
+        if (typeof turnId !== "string") {
+            throw new MobiusProtocolError("The service returned an invalid Turn");
+        }
+        return { turnId };
+    };
+    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