@moxt-ai/mobius-sdk 0.0.3

package/dist/service-client.js

@@ -0,0 +1,1061 @@
+import { decodeNativeSessionHistory, 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 { MobiusApiError, MobiusCancellationError, MobiusConnectionError, MobiusError, MobiusProtocolError, MobiusTimeoutError, MobiusValidationError, } from "./errors.js";
+import { decodeMobiusArtifact, decodeMobiusArtifactUpload, decodeMobiusAttempt, decodeMobiusAvailableArtifact, decodeMobiusBrowserCredential, decodeMobiusEventPage, decodeMobiusInteraction, decodeMobiusInteractionList, decodeMobiusMessagePage, decodeMobiusRuntimeList, decodeMobiusRuntimePairing, decodeMobiusRuntimePairingStatus, decodeMobiusServiceCapabilities, decodeMobiusSession, decodeMobiusSessionEvent, decodeMobiusSessionExport, decodeMobiusSessionPage, decodeMobiusSessionState, decodeMobiusToolCallDetail, decodeMobiusTurn, MobiusArtifactDownload, MobiusAvailableArtifact, MobiusPairedRuntimePairingStatus, MobiusRuntimePairingLifecycle, MobiusSessionAccess, } from "./resources.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) {
+        this.#token = validateCredential(token);
+    }
+    credential = async (signal) => {
+        signal.throwIfAborted();
+        return this.#token;
+    };
+}
+function validateCredential(value) {
+    if (typeof value !== "string" ||
+        value.length < 1 ||
+        value.length > 4_096 ||
+        value.includes("\r") ||
+        value.includes("\n")) {
+        throw new MobiusValidationError("The Mobius credential is invalid");
+    }
+    return value;
+}
+class PlatformMobiusHttpTransport {
+    fetch = async (request) => await globalThis.fetch(request);
+}
+function validatePositiveInteger(value, name) {
+    if (!Number.isSafeInteger(value) || value < 1) {
+        throw new MobiusValidationError(`The ${name} is invalid`);
+    }
+    return value;
+}
+function normalizeEndpoint(value) {
+    let endpoint;
+    try {
+        endpoint = new URL(value);
+    }
+    catch (cause) {
+        throw new MobiusValidationError("The Mobius endpoint is invalid", {
+            cause,
+        });
+    }
+    if ((endpoint.protocol !== "http:" && endpoint.protocol !== "https:") ||
+        endpoint.username.length > 0 ||
+        endpoint.password.length > 0 ||
+        endpoint.search.length > 0 ||
+        endpoint.hash.length > 0) {
+        throw new MobiusValidationError("The Mobius endpoint is invalid");
+    }
+    if (endpoint.pathname === "/") {
+        endpoint.pathname = `${MOBIUS_API_PREFIX}/`;
+    }
+    else if (!endpoint.pathname.endsWith("/")) {
+        endpoint.pathname = `${endpoint.pathname}/`;
+    }
+    return endpoint;
+}
+function projectPath(projectId, resourcePath) {
+    if (!/^[a-zA-Z0-9][a-zA-Z0-9._:-]{0,127}$/.test(projectId)) {
+        throw new MobiusValidationError("The Mobius project identifier is invalid");
+    }
+    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);
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function record(value) {
+    if (!isRecord(value)) {
+        throw new MobiusProtocolError("The service returned an invalid error response");
+    }
+    return value;
+}
+async function responseValue(response) {
+    try {
+        return await response.json();
+    }
+    catch (cause) {
+        throw new MobiusProtocolError("The service returned invalid JSON", {
+            cause,
+        });
+    }
+}
+async function throwApiError(response) {
+    const value = record(await responseValue(response));
+    const error = record(value["error"]);
+    const code = error["code"];
+    const message = error["message"];
+    if (typeof code !== "string" || typeof message !== "string") {
+        throw new MobiusProtocolError("The service returned an invalid error response");
+    }
+    throw new MobiusApiError(code, message, response.status);
+}
+class RequestDeadline {
+    #controller = new AbortController();
+    #requestSignal;
+    #timeoutId;
+    #timedOut = false;
+    constructor(requestSignal, timeoutMilliseconds) {
+        this.#requestSignal = requestSignal;
+        if (requestSignal.aborted) {
+            this.#controller.abort(requestSignal.reason);
+        }
+        else {
+            requestSignal.addEventListener("abort", this.abortFromRequest, {
+                once: true,
+            });
+        }
+        this.#timeoutId = globalThis.setTimeout(this.abortFromTimeout, timeoutMilliseconds);
+    }
+    get signal() {
+        return this.#controller.signal;
+    }
+    finish = () => {
+        globalThis.clearTimeout(this.#timeoutId);
+        this.#requestSignal.removeEventListener("abort", this.abortFromRequest);
+    };
+    translate = (cause) => {
+        if (this.#requestSignal.aborted) {
+            throw new MobiusCancellationError({ cause });
+        }
+        if (this.#timedOut) {
+            throw new MobiusTimeoutError({ cause });
+        }
+        if (cause instanceof MobiusError) {
+            throw cause;
+        }
+        throw new MobiusConnectionError("The Mobius service could not be reached", {
+            cause,
+        });
+    };
+    abortFromRequest = () => {
+        this.#controller.abort(this.#requestSignal.reason);
+    };
+    abortFromTimeout = () => {
+        this.#timedOut = true;
+        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"));
+    };
+}
+export class MobiusRequestExecutor {
+    #authenticationProviderId;
+    #credentialProvider;
+    #endpoint;
+    #operationTimeoutMilliseconds;
+    #streamConnectionTimeoutMilliseconds;
+    #streamLivenessTimeoutMilliseconds;
+    #transport;
+    constructor(options) {
+        const authenticationProviderId = options.authenticationProviderId ?? "";
+        if (authenticationProviderId.length > 128 ||
+            authenticationProviderId.includes("\r") ||
+            authenticationProviderId.includes("\n")) {
+            throw new MobiusValidationError("The Mobius authentication provider identifier is invalid");
+        }
+        this.#authenticationProviderId = authenticationProviderId;
+        this.#credentialProvider = options.credentialProvider;
+        this.#endpoint = normalizeEndpoint(options.endpoint);
+        this.#operationTimeoutMilliseconds = validatePositiveInteger(options.operationTimeoutMilliseconds ?? DEFAULT_OPERATION_TIMEOUT_MILLISECONDS, "operation timeout");
+        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 PlatformMobiusHttpTransport();
+    }
+    get = async (path, signal) => await this.request(path, "GET", "", false, signal);
+    post = async (path, body, signal) => {
+        const encoded = JSON.stringify(body);
+        if (typeof encoded !== "string") {
+            throw new MobiusValidationError("The Mobius request body is invalid");
+        }
+        return await this.request(path, "POST", encoded, true, signal);
+    };
+    put = async (path, body, signal) => {
+        const encoded = JSON.stringify(body);
+        if (typeof encoded !== "string") {
+            throw new MobiusValidationError("The Mobius request body is invalid");
+        }
+        return await this.request(path, "PUT", encoded, true, signal);
+    };
+    putBytes = async (path, bytes, mediaType, uploadToken, signal) => {
+        const deadline = new RequestDeadline(signal, this.#operationTimeoutMilliseconds);
+        try {
+            const credential = validateCredential(await this.#credentialProvider.credential(deadline.signal));
+            const headers = this.authenticationHeaders(credential, "application/json");
+            headers.set("content-type", mediaType);
+            headers.set("x-mobius-upload-token", validateCredential(uploadToken));
+            const response = await this.#transport.fetch(new Request(requestUrl(this.#endpoint, path), {
+                body: Uint8Array.from(bytes),
+                headers,
+                method: "PUT",
+                signal: deadline.signal,
+            }));
+            if (!response.ok) {
+                await throwApiError(response);
+            }
+            return await responseValue(response);
+        }
+        catch (cause) {
+            return deadline.translate(cause);
+        }
+        finally {
+            deadline.finish();
+        }
+    };
+    getBytes = async (path, artifact, 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, artifact.mediaType),
+                signal: deadline.signal,
+            }));
+            if (!response.ok) {
+                await throwApiError(response);
+            }
+            if (response.headers.get("content-type") !== artifact.mediaType ||
+                response.headers.get("x-mobius-artifact-id") !== artifact.artifactId ||
+                response.headers.get("x-mobius-sha256") !== artifact.sha256) {
+                throw new MobiusProtocolError("The service returned invalid artifact metadata");
+            }
+            return await readExactResponseBytes(response, artifact.byteLength, deadline.signal);
+        }
+        catch (cause) {
+            return deadline.translate(cause);
+        }
+        finally {
+            deadline.finish();
+        }
+    };
+    delete = async (path, signal) => await this.request(path, "DELETE", "", false, signal);
+    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);
+    };
+    request = async (path, method, body, hasBody, signal) => {
+        const deadline = new RequestDeadline(signal, this.#operationTimeoutMilliseconds);
+        try {
+            const credential = validateCredential(await this.#credentialProvider.credential(deadline.signal));
+            const headers = this.authenticationHeaders(credential, "application/json");
+            if (hasBody) {
+                headers.set("content-type", "application/json");
+            }
+            const response = await this.#transport.fetch(new Request(requestUrl(this.#endpoint, path), {
+                body: hasBody ? body : null,
+                headers,
+                method,
+                signal: deadline.signal,
+            }));
+            if (!response.ok) {
+                await throwApiError(response);
+            }
+            return await responseValue(response);
+        }
+        catch (cause) {
+            return deadline.translate(cause);
+        }
+        finally {
+            deadline.finish();
+        }
+    };
+    requestEmpty = async (path, method, 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/json"),
+                method,
+                signal: deadline.signal,
+            }));
+            if (!response.ok) {
+                await throwApiError(response);
+            }
+            if (response.status !== 204) {
+                throw new MobiusProtocolError("The service returned an invalid empty response");
+            }
+        }
+        catch (cause) {
+            return deadline.translate(cause);
+        }
+        finally {
+            deadline.finish();
+        }
+    };
+    authenticationHeaders = (credential, accept) => {
+        const headers = new Headers({ accept, authorization: `Bearer ${credential}` });
+        if (this.#authenticationProviderId.length > 0) {
+            headers.set("x-mobius-oidc-provider", this.#authenticationProviderId);
+        }
+        return headers;
+    };
+}
+export async function readExactResponseBytes(response, expectedByteLength, signal) {
+    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;
+    }
+    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 MobiusArtifactResources {
+    #executor;
+    #projectId;
+    constructor(executor, projectId) {
+        this.#executor = executor;
+        this.#projectId = projectId;
+    }
+    createUpload = async (sessionId, request, signal) => decodeMobiusArtifactUpload(await this.#executor.post(sessionPath(this.#projectId, sessionId, "artifacts/uploads"), request, signal));
+    uploadContent = async (sessionId, upload, bytes, signal) => {
+        if (upload.sessionId !== sessionId || bytes.byteLength !== upload.byteLength) {
+            throw new MobiusValidationError("The artifact content does not match its upload authorization");
+        }
+        return decodeMobiusAvailableArtifact(await this.#executor.putBytes(sessionPath(this.#projectId, sessionId, `artifacts/${encodeURIComponent(upload.artifactId)}/content`), bytes, upload.mediaType, upload.uploadToken, signal));
+    };
+    read = async (sessionId, artifactId, signal) => decodeMobiusArtifact(await this.#executor.get(sessionPath(this.#projectId, sessionId, `artifacts/${encodeURIComponent(artifactId)}`), signal));
+    download = async (sessionId, artifactId, signal) => {
+        const artifact = await this.read(sessionId, artifactId, signal);
+        if (!(artifact instanceof MobiusAvailableArtifact)) {
+            throw new MobiusApiError("artifact_not_ready", "The artifact content is not available", 409);
+        }
+        const bytes = await this.#executor.getBytes(sessionPath(this.#projectId, sessionId, `artifacts/${encodeURIComponent(artifactId)}/content`), artifact, signal);
+        return new MobiusArtifactDownload(artifact, bytes);
+    };
+}
+export class MobiusCredentialResources {
+    #executor;
+    #projectId;
+    constructor(executor, projectId) {
+        this.#executor = executor;
+        this.#projectId = projectId;
+    }
+    issue = async (request, signal) => decodeMobiusBrowserCredential(await this.#executor.post(projectPath(this.#projectId, "browser-credentials"), request, signal));
+    revoke = async (credentialId, signal) => {
+        if (!/^[a-zA-Z0-9][a-zA-Z0-9._:-]{0,127}$/.test(credentialId)) {
+            throw new MobiusValidationError("The browser credential identifier is invalid");
+        }
+        await this.#executor.deleteEmpty(projectPath(this.#projectId, `browser-credentials/${encodeURIComponent(credentialId)}`), signal);
+    };
+}
+export class MobiusRuntimeResources {
+    #executor;
+    #projectId;
+    constructor(executor, projectId) {
+        this.#executor = executor;
+        this.#projectId = projectId;
+    }
+    list = async (signal) => decodeMobiusRuntimeList(await this.#executor.get(projectPath(this.#projectId, "runtimes"), signal));
+    listWorkspace = async (runtimeId, directoryId, signal) => decodeWorkspaceEntriesEvent(JSON.stringify(await this.#executor.post(projectPath(this.#projectId, `runtimes/${encodeURIComponent(runtimeId)}/workspace`), { directoryId }, signal)));
+    nativeSessions = async (runtimeId, request, signal) => decodeNativeSessionResult(JSON.stringify(await this.#executor.post(projectPath(this.#projectId, `runtimes/${encodeURIComponent(runtimeId)}/native-sessions`), request, signal)));
+    revoke = async (runtimeId, signal) => {
+        if (!/^[a-zA-Z0-9][a-zA-Z0-9._:-]{0,127}$/.test(runtimeId)) {
+            throw new MobiusValidationError("The Runtime identifier is invalid");
+        }
+        await this.#executor.deleteEmpty(projectPath(this.#projectId, `runtimes/${encodeURIComponent(runtimeId)}`), signal);
+    };
+}
+export class MobiusRuntimePairingResources {
+    #executor;
+    #projectId;
+    constructor(executor, projectId) {
+        this.#executor = executor;
+        this.#projectId = projectId;
+    }
+    create = async (request, signal) => decodeMobiusRuntimePairing(await this.#executor.post(projectPath(this.#projectId, "runtime-pairings"), request, signal));
+    read = async (pairingId, signal) => {
+        if (!/^[a-zA-Z0-9][a-zA-Z0-9._:-]{0,127}$/.test(pairingId)) {
+            throw new MobiusValidationError("The Runtime pairing identifier is invalid");
+        }
+        return decodeMobiusRuntimePairingStatus(await this.#executor.get(projectPath(this.#projectId, `runtime-pairings/${encodeURIComponent(pairingId)}`), signal));
+    };
+    waitUntilPaired = async (pairingId, options, signal) => {
+        const deadline = Date.now() + options.timeoutMilliseconds;
+        while (true) {
+            if (signal.aborted) {
+                throw new MobiusCancellationError({ cause: signal.reason });
+            }
+            const status = await this.read(pairingId, signal);
+            if (status instanceof MobiusPairedRuntimePairingStatus) {
+                return status;
+            }
+            if (status.status === MobiusRuntimePairingLifecycle.Expired) {
+                throw new MobiusApiError("runtime_pairing_expired", "The Runtime pairing expired", 410);
+            }
+            if (status.status === MobiusRuntimePairingLifecycle.Revoked) {
+                throw new MobiusApiError("runtime_pairing_revoked", "The Runtime pairing was revoked", 410);
+            }
+            const remaining = deadline - Date.now();
+            if (remaining <= 0) {
+                throw new MobiusTimeoutError();
+            }
+            await waitForPairingPoll(Math.min(options.pollIntervalMilliseconds, remaining), signal);
+        }
+    };
+}
+function waitForPairingPoll(milliseconds, signal) {
+    if (signal.aborted) {
+        return Promise.reject(new MobiusCancellationError({ cause: signal.reason }));
+    }
+    return new Promise((resolve, reject) => {
+        const timeout = globalThis.setTimeout(() => {
+            signal.removeEventListener("abort", cancel);
+            resolve();
+        }, milliseconds);
+        const cancel = () => {
+            globalThis.clearTimeout(timeout);
+            reject(new MobiusCancellationError({ cause: signal.reason }));
+        };
+        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));
+    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));
+    };
+    readNativeHistory = async (sessionId, signal) => {
+        try {
+            return decodeNativeSessionHistory(await this.#executor.get(sessionPath(this.#projectId, sessionId, "native-history"), signal));
+        }
+        catch (cause) {
+            if (cause instanceof MobiusError) {
+                throw cause;
+            }
+            throw new MobiusProtocolError("The service returned invalid native Session history", { 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;
+    #cursorParameter;
+    #closed = false;
+    #cursor;
+    #hasSequence = false;
+    #lastSequence = 0n;
+    completed;
+    constructor(executor, path, cursor, observer, signal, controller, firstConnection, maximumReconnectAttempts, cursorParameter = "cursor") {
+        this.#cursor = cursor;
+        this.#controller = controller;
+        this.#executor = executor;
+        this.#externalSignal = signal;
+        this.#maximumReconnectAttempts = maximumReconnectAttempts;
+        this.#observer = observer;
+        this.#path = path;
+        this.#cursorParameter = cursorParameter;
+        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.#cursorParameter}=${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 MobiusEventResources {
+    #executor;
+    #maximumReconnectAttempts;
+    #projectId;
+    #subscriptions = 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;
+    };
+    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));
+    };
+    close = () => {
+        for (const subscription of this.#subscriptions) {
+            subscription.close();
+        }
+        this.#subscriptions.clear();
+    };
+}
+export class MobiusFixedSessionEventResources {
+    #executor;
+    #maximumReconnectAttempts;
+    #subscriptions = new Set();
+    constructor(executor, maximumReconnectAttempts = DEFAULT_STREAM_RECONNECT_ATTEMPTS) {
+        this.#executor = executor;
+        this.#maximumReconnectAttempts = validatePositiveInteger(maximumReconnectAttempts, "stream reconnect attempt limit");
+    }
+    subscribe = async (cursor, observer, signal) => {
+        if (cursor.length > 512) {
+            throw new MobiusValidationError("The Session event cursor is invalid");
+        }
+        const path = "v1/client/session/events";
+        const streamPath = cursor.length === 0 ? path : `${path}?after=${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, "after");
+        this.#subscriptions.add(subscription);
+        const remove = subscription.completed.finally(() => {
+            this.#subscriptions.delete(subscription);
+        });
+        void remove.catch(() => { });
+        return subscription;
+    };
+    list = async (page, signal) => {
+        const query = new URLSearchParams({ limit: page.limit.toString() });
+        if (page.cursor.length > 0) {
+            query.set("after", page.cursor);
+        }
+        return decodeMobiusEventPage(await this.#executor.get(`v1/client/session/events?${query.toString()}`, signal));
+    };
+    close = () => {
+        for (const subscription of this.#subscriptions) {
+            subscription.close();
+        }
+        this.#subscriptions.clear();
+    };
+}
+export class MobiusClient {
+    artifacts;
+    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.artifacts = new MobiusArtifactResources(executor, options.projectId);
+        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