@moxt-ai/mobius-sdk 0.0.3

package/dist/resources.js

@@ -0,0 +1,1411 @@
+import { AGENT_ACTIVITY_KIND, AGENT_MESSAGE_DELTA_KIND, decodeAttempt, decodeCommittedSessionEvent, decodeInteraction, decodePromptImagesValue, decodePromptResourcesValue, decodeRecordedSessionEvent, decodeTurn, MOBIUS_API_VERSION, MOBIUS_EVENT_FORMAT_VERSION, MOBIUS_SESSION_EVENT_STREAM_EVENT, MOBIUS_SESSION_EVENT_STREAM_MEDIA_TYPE, MOBIUS_SESSION_EVENT_STREAM_TRANSPORT, MOBIUS_SESSION_EXPORT_FORMAT_VERSION, SESSION_COMPLETED_KIND, SESSION_FAILED_KIND, SESSION_STARTED_KIND, sessionCapabilitiesSchema, } from "@moxt-ai/mobius-protocol";
+import { MobiusProtocolError, MobiusValidationError } from "./errors.js";
+const IDENTIFIER_PATTERN = /^[a-zA-Z0-9][a-zA-Z0-9._:-]{0,127}$/;
+const SESSION_CAPABILITY_FIELDS = [
+    "additionalDirectories",
+    "audioPrompt",
+    "closeSession",
+    "deleteSession",
+    "embeddedContextPrompt",
+    "imagePrompt",
+    "listSessions",
+    "loadSession",
+    "promptQueueing",
+    "resumeSession",
+    "steering",
+    "unstableForkSession",
+];
+function invalidResponse(message) {
+    return new MobiusProtocolError(message);
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function record(value, name) {
+    if (!isRecord(value)) {
+        throw invalidResponse(`The service returned an invalid ${name}`);
+    }
+    return value;
+}
+function stringField(value, field, maximumLength = 8_500_000) {
+    const candidate = value[field];
+    if (typeof candidate !== "string" || candidate.length > maximumLength) {
+        throw invalidResponse(`The service returned an invalid ${field}`);
+    }
+    return candidate;
+}
+function identifierField(value, field) {
+    const candidate = stringField(value, field, 128);
+    if (!IDENTIFIER_PATTERN.test(candidate)) {
+        throw invalidResponse(`The service returned an invalid ${field}`);
+    }
+    return candidate;
+}
+function integerField(value, field) {
+    const candidate = value[field];
+    if (typeof candidate !== "number" || !Number.isSafeInteger(candidate) || candidate < 0) {
+        throw invalidResponse(`The service returned an invalid ${field}`);
+    }
+    return candidate;
+}
+function booleanField(value, field) {
+    const candidate = value[field];
+    if (typeof candidate !== "boolean") {
+        throw invalidResponse(`The service returned an invalid ${field}`);
+    }
+    return candidate;
+}
+function arrayField(value, field, maximumLength = 10_000) {
+    const candidate = value[field];
+    if (!Array.isArray(candidate) || candidate.length > maximumLength) {
+        throw invalidResponse(`The service returned an invalid ${field}`);
+    }
+    return candidate;
+}
+function nullableCursor(value, field) {
+    const candidate = value[field];
+    if (candidate === null) {
+        return "";
+    }
+    if (typeof candidate !== "string" || candidate.length > 512) {
+        throw invalidResponse(`The service returned an invalid ${field}`);
+    }
+    return candidate;
+}
+function validateTimestamp(value, field) {
+    if (Number.isNaN(Date.parse(value))) {
+        throw invalidResponse(`The service returned an invalid ${field}`);
+    }
+    return value;
+}
+export class MobiusSessionEventCapabilities {
+    eventName;
+    formatVersion;
+    mediaType;
+    transport;
+    constructor(eventName, formatVersion, mediaType, transport) {
+        this.eventName = eventName;
+        this.formatVersion = formatVersion;
+        this.mediaType = mediaType;
+        this.transport = transport;
+    }
+}
+export class MobiusArtifactCapabilities {
+    downloadTransport;
+    uploadProtocol;
+    constructor(downloadTransport, uploadProtocol) {
+        this.downloadTransport = downloadTransport;
+        this.uploadProtocol = uploadProtocol;
+    }
+}
+export class MobiusAuthenticationCapabilities {
+    browserCredentials;
+    maximumBrowserCredentialLifetimeSeconds;
+    minimumBrowserCredentialLifetimeSeconds;
+    constructor(browserCredentials, maximumBrowserCredentialLifetimeSeconds, minimumBrowserCredentialLifetimeSeconds) {
+        this.browserCredentials = browserCredentials;
+        this.maximumBrowserCredentialLifetimeSeconds = maximumBrowserCredentialLifetimeSeconds;
+        this.minimumBrowserCredentialLifetimeSeconds = minimumBrowserCredentialLifetimeSeconds;
+    }
+}
+export class MobiusPortabilityCapabilities {
+    exportFormatVersion;
+    nativeContextImport;
+    targetBindingRequired;
+    constructor(exportFormatVersion, nativeContextImport, targetBindingRequired) {
+        this.exportFormatVersion = exportFormatVersion;
+        this.nativeContextImport = nativeContextImport;
+        this.targetBindingRequired = targetBindingRequired;
+    }
+}
+export class MobiusResourceCapabilities {
+    artifacts;
+    attempts;
+    browserCredentials;
+    events;
+    interactions;
+    messages;
+    portability;
+    runtimePairings;
+    runtimes;
+    sessions;
+    toolCalls;
+    turns;
+    constructor(resources) {
+        this.artifacts = booleanField(resources, "artifacts");
+        this.attempts = booleanField(resources, "attempts");
+        this.browserCredentials = booleanField(resources, "browserCredentials");
+        this.events = booleanField(resources, "events");
+        this.interactions = booleanField(resources, "interactions");
+        this.messages = booleanField(resources, "messages");
+        this.portability = booleanField(resources, "portability");
+        this.runtimePairings = booleanField(resources, "runtimePairings");
+        this.runtimes = booleanField(resources, "runtimes");
+        this.sessions = booleanField(resources, "sessions");
+        this.toolCalls = booleanField(resources, "toolCalls");
+        this.turns = booleanField(resources, "turns");
+    }
+}
+export class MobiusServiceCapabilities {
+    apiVersion;
+    artifacts;
+    authentication;
+    portability;
+    resources;
+    sessionEvents;
+    constructor(apiVersion, artifacts, authentication, portability, resources, sessionEvents) {
+        this.apiVersion = apiVersion;
+        this.artifacts = artifacts;
+        this.authentication = authentication;
+        this.portability = portability;
+        this.resources = resources;
+        this.sessionEvents = sessionEvents;
+    }
+}
+export function decodeMobiusServiceCapabilities(value) {
+    const capabilities = record(value, "service capabilities");
+    const resources = record(capabilities["resources"], "resource capabilities");
+    const artifacts = record(capabilities["artifacts"], "artifact capabilities");
+    const authentication = record(capabilities["authentication"], "authentication capabilities");
+    const portability = record(capabilities["portability"], "portability capabilities");
+    const sessionEvents = record(capabilities["sessionEvents"], "Session event capabilities");
+    const apiVersion = stringField(capabilities, "apiVersion", 32);
+    const eventName = stringField(sessionEvents, "eventName", 128);
+    const formatVersion = stringField(sessionEvents, "formatVersion", 32);
+    const mediaType = stringField(sessionEvents, "mediaType", 128);
+    const transport = stringField(sessionEvents, "transport", 32);
+    const downloadTransport = stringField(artifacts, "downloadTransport", 32);
+    const uploadProtocol = stringField(artifacts, "uploadProtocol", 32);
+    const exportFormatVersion = stringField(portability, "exportFormatVersion", 32);
+    if (apiVersion !== MOBIUS_API_VERSION ||
+        eventName !== MOBIUS_SESSION_EVENT_STREAM_EVENT ||
+        formatVersion !== MOBIUS_EVENT_FORMAT_VERSION ||
+        mediaType !== MOBIUS_SESSION_EVENT_STREAM_MEDIA_TYPE ||
+        transport !== MOBIUS_SESSION_EVENT_STREAM_TRANSPORT ||
+        downloadTransport !== "authorized-stream" ||
+        uploadProtocol !== "two-stage" ||
+        exportFormatVersion !== MOBIUS_SESSION_EXPORT_FORMAT_VERSION) {
+        throw invalidResponse("The service returned unsupported Mobius API capabilities");
+    }
+    return new MobiusServiceCapabilities(apiVersion, new MobiusArtifactCapabilities(downloadTransport, uploadProtocol), new MobiusAuthenticationCapabilities(booleanField(authentication, "browserCredentials"), integerField(authentication, "maximumBrowserCredentialLifetimeSeconds"), integerField(authentication, "minimumBrowserCredentialLifetimeSeconds")), new MobiusPortabilityCapabilities(exportFormatVersion, booleanField(portability, "nativeContextImport"), booleanField(portability, "targetBindingRequired")), new MobiusResourceCapabilities(resources), new MobiusSessionEventCapabilities(eventName, formatVersion, mediaType, transport));
+}
+export class MobiusRecordingPolicy {
+    contentLimitBytes;
+    hotEventLimit;
+    idempotencyRetentionMilliseconds;
+    level;
+    retentionMilliseconds;
+    constructor(level, retentionMilliseconds, hotEventLimit, contentLimitBytes, idempotencyRetentionMilliseconds = retentionMilliseconds) {
+        if ((level !== "full" && level !== "summary") ||
+            !Number.isSafeInteger(retentionMilliseconds) ||
+            retentionMilliseconds < 60_000 ||
+            !Number.isSafeInteger(hotEventLimit) ||
+            hotEventLimit < 10 ||
+            !Number.isSafeInteger(contentLimitBytes) ||
+            contentLimitBytes < 1_024 ||
+            !Number.isSafeInteger(idempotencyRetentionMilliseconds) ||
+            idempotencyRetentionMilliseconds < 60_000 ||
+            idempotencyRetentionMilliseconds > retentionMilliseconds) {
+            throw new MobiusValidationError("The Session recording policy is invalid");
+        }
+        this.contentLimitBytes = contentLimitBytes;
+        this.hotEventLimit = hotEventLimit;
+        this.idempotencyRetentionMilliseconds = idempotencyRetentionMilliseconds;
+        this.level = level;
+        this.retentionMilliseconds = retentionMilliseconds;
+    }
+    toJSON = () => new MobiusRecordingPolicyRequestPayload(this.level, this.retentionMilliseconds, this.hotEventLimit, this.contentLimitBytes, this.idempotencyRetentionMilliseconds);
+}
+class MobiusRecordingPolicyRequestPayload {
+    contentLimitBytes;
+    hotEventLimit;
+    idempotencyRetentionMilliseconds;
+    level;
+    retentionMilliseconds;
+    constructor(level, retentionMilliseconds, hotEventLimit, contentLimitBytes, idempotencyRetentionMilliseconds) {
+        this.contentLimitBytes = contentLimitBytes;
+        this.hotEventLimit = hotEventLimit;
+        this.idempotencyRetentionMilliseconds = idempotencyRetentionMilliseconds;
+        this.level = level;
+        this.retentionMilliseconds = retentionMilliseconds;
+    }
+}
+export class MobiusSessionAccess {
+    credential;
+    credentialId;
+    projectId;
+    sessionId;
+    expiresAt;
+    constructor(value) {
+        const resource = record(value, "Session access");
+        this.credential = stringField(resource, "credential", 256);
+        if (!/^msession_[A-Za-z0-9_-]{22}_[A-Za-z0-9_-]{43}$/u.test(this.credential)) {
+            throw invalidResponse("The Session credential is invalid");
+        }
+        this.credentialId = identifierField(resource, "credentialId");
+        this.projectId = identifierField(resource, "projectId");
+        this.sessionId = identifierField(resource, "sessionId");
+        this.expiresAt = validateTimestamp(stringField(resource, "expiresAt", 128), "expiresAt");
+    }
+}
+export class MobiusSessionImportBinding {
+    agentRef;
+    bindingId;
+    configRevision;
+    runtimeId;
+    workspaceRef;
+    constructor(bindingId, runtimeId, agentRef, workspaceRef, configRevision = 1) {
+        this.agentRef = agentRef;
+        this.bindingId = bindingId;
+        this.configRevision = configRevision;
+        this.runtimeId = runtimeId;
+        this.workspaceRef = workspaceRef;
+    }
+}
+export class MobiusBrowserCredentialRequest {
+    expiresInSeconds;
+    constructor(expiresInSeconds) {
+        if (!Number.isSafeInteger(expiresInSeconds) || expiresInSeconds < 60 || expiresInSeconds > 3_600) {
+            throw new MobiusValidationError("The browser credential lifetime is invalid");
+        }
+        this.expiresInSeconds = expiresInSeconds;
+    }
+}
+export class MobiusRuntimePairingRequest {
+    idempotencyKey;
+    constructor(idempotencyKey) {
+        if (!IDENTIFIER_PATTERN.test(idempotencyKey)) {
+            throw new MobiusValidationError("The Runtime pairing idempotency key is invalid");
+        }
+        this.idempotencyKey = idempotencyKey;
+    }
+}
+export class MobiusArtifactUploadRequest {
+    byteLength;
+    mediaType;
+    name;
+    sha256;
+    constructor(name, mediaType, byteLength, sha256) {
+        if (name.length < 1 ||
+            name.length > 500 ||
+            name.includes("\0") ||
+            mediaType.length < 1 ||
+            mediaType.length > 255 ||
+            mediaType.includes("\r") ||
+            mediaType.includes("\n") ||
+            !Number.isSafeInteger(byteLength) ||
+            byteLength < 1 ||
+            !/^[a-f0-9]{64}$/.test(sha256)) {
+            throw new MobiusValidationError("The artifact upload request is invalid");
+        }
+        this.byteLength = byteLength;
+        this.mediaType = mediaType;
+        this.name = name;
+        this.sha256 = sha256;
+    }
+}
+export class MobiusArtifact {
+    artifactId;
+    byteLength;
+    createdAt;
+    mediaType;
+    name;
+    sessionId;
+    sha256;
+    constructor(sessionId, artifactId, name, mediaType, byteLength, sha256, createdAt) {
+        this.artifactId = artifactId;
+        this.byteLength = byteLength;
+        this.createdAt = createdAt;
+        this.mediaType = mediaType;
+        this.name = name;
+        this.sessionId = sessionId;
+        this.sha256 = sha256;
+    }
+}
+export class MobiusUploadingArtifact extends MobiusArtifact {
+    expiresAt;
+    state = "uploading";
+    constructor(sessionId, artifactId, name, mediaType, byteLength, sha256, createdAt, expiresAt) {
+        super(sessionId, artifactId, name, mediaType, byteLength, sha256, createdAt);
+        this.expiresAt = expiresAt;
+    }
+}
+export class MobiusArtifactUpload extends MobiusUploadingArtifact {
+    uploadToken;
+    constructor(artifact, uploadToken) {
+        super(artifact.sessionId, artifact.artifactId, artifact.name, artifact.mediaType, artifact.byteLength, artifact.sha256, artifact.createdAt, artifact.expiresAt);
+        this.uploadToken = uploadToken;
+    }
+}
+export class MobiusAvailableArtifact extends MobiusArtifact {
+    availableAt;
+    state = "available";
+    constructor(sessionId, artifactId, name, mediaType, byteLength, sha256, createdAt, availableAt) {
+        super(sessionId, artifactId, name, mediaType, byteLength, sha256, createdAt);
+        this.availableAt = availableAt;
+    }
+}
+export class MobiusExpiredArtifact extends MobiusArtifact {
+    expiredAt;
+    state = "expired";
+    constructor(sessionId, artifactId, name, mediaType, byteLength, sha256, createdAt, expiredAt) {
+        super(sessionId, artifactId, name, mediaType, byteLength, sha256, createdAt);
+        this.expiredAt = expiredAt;
+    }
+}
+function artifactFields(value) {
+    const sha256 = stringField(value, "sha256", 64);
+    if (!/^[a-f0-9]{64}$/.test(sha256)) {
+        throw invalidResponse("The service returned an invalid artifact digest");
+    }
+    return {
+        artifactId: identifierField(value, "artifactId"),
+        byteLength: integerField(value, "byteLength"),
+        createdAt: validateTimestamp(stringField(value, "createdAt", 128), "createdAt"),
+        mediaType: stringField(value, "mediaType", 255),
+        name: stringField(value, "name", 500),
+        sessionId: identifierField(value, "sessionId"),
+        sha256,
+    };
+}
+function uploadingArtifact(value) {
+    const fields = artifactFields(value);
+    return new MobiusUploadingArtifact(fields.sessionId, fields.artifactId, fields.name, fields.mediaType, fields.byteLength, fields.sha256, fields.createdAt, validateTimestamp(stringField(value, "expiresAt", 128), "expiresAt"));
+}
+export function decodeMobiusArtifactUpload(value) {
+    const artifact = record(value, "artifact upload authorization");
+    return new MobiusArtifactUpload(uploadingArtifact(artifact), stringField(artifact, "uploadToken", 256));
+}
+export function decodeMobiusArtifact(value) {
+    const artifact = record(value, "artifact");
+    const state = stringField(artifact, "state", 32);
+    if (state === "uploading") {
+        return uploadingArtifact(artifact);
+    }
+    const fields = artifactFields(artifact);
+    if (state === "available") {
+        return new MobiusAvailableArtifact(fields.sessionId, fields.artifactId, fields.name, fields.mediaType, fields.byteLength, fields.sha256, fields.createdAt, validateTimestamp(stringField(artifact, "availableAt", 128), "availableAt"));
+    }
+    if (state === "expired") {
+        return new MobiusExpiredArtifact(fields.sessionId, fields.artifactId, fields.name, fields.mediaType, fields.byteLength, fields.sha256, fields.createdAt, validateTimestamp(stringField(artifact, "expiredAt", 128), "expiredAt"));
+    }
+    throw invalidResponse("The service returned an invalid artifact state");
+}
+export function decodeMobiusAvailableArtifact(value) {
+    const artifact = decodeMobiusArtifact(value);
+    if (!(artifact instanceof MobiusAvailableArtifact)) {
+        throw invalidResponse("The service did not make the artifact available");
+    }
+    return artifact;
+}
+export class MobiusArtifactDownload {
+    artifact;
+    bytes;
+    constructor(artifact, bytes) {
+        this.artifact = artifact;
+        this.bytes = bytes;
+    }
+}
+export class MobiusBrowserCredential {
+    credentialId;
+    expiresAt;
+    projectId;
+    token;
+    constructor(credentialId, expiresAt, projectId, token) {
+        this.credentialId = credentialId;
+        this.expiresAt = expiresAt;
+        this.projectId = projectId;
+        this.token = token;
+    }
+}
+export function decodeMobiusBrowserCredential(value) {
+    const credential = record(value, "browser credential");
+    return new MobiusBrowserCredential(identifierField(credential, "credentialId"), validateTimestamp(stringField(credential, "expiresAt", 128), "expiresAt"), identifierField(credential, "projectId"), stringField(credential, "token", 256));
+}
+export class MobiusAgentDescriptor {
+    agentPath;
+    agentVersion;
+    capabilities;
+    id;
+    label;
+    constructor(agentPath, agentVersion, capabilities, id, label) {
+        this.agentPath = agentPath;
+        this.agentVersion = agentVersion;
+        this.capabilities = Object.freeze({ ...capabilities });
+        this.id = id;
+        this.label = label;
+    }
+}
+export function decodeMobiusAgentCapabilities(value) {
+    const capabilities = record(value, "Agent capabilities");
+    if (Object.keys(capabilities).length !== SESSION_CAPABILITY_FIELDS.length ||
+        SESSION_CAPABILITY_FIELDS.some((field) => !Object.hasOwn(capabilities, field))) {
+        throw invalidResponse("The service returned invalid Agent capabilities");
+    }
+    const parsed = sessionCapabilitiesSchema.safeParse(capabilities);
+    if (!parsed.success) {
+        throw invalidResponse("The service returned invalid Agent capabilities");
+    }
+    return parsed.data;
+}
+function decodeAgentDescriptor(value) {
+    const agent = record(value, "Agent descriptor");
+    if (Object.keys(agent).length !== 5 ||
+        !Object.hasOwn(agent, "agentPath") ||
+        !Object.hasOwn(agent, "agentVersion") ||
+        !Object.hasOwn(agent, "capabilities") ||
+        !Object.hasOwn(agent, "id") ||
+        !Object.hasOwn(agent, "label")) {
+        throw invalidResponse("The service returned an invalid Agent descriptor");
+    }
+    const agentPath = stringField(agent, "agentPath", 4_096);
+    const agentVersion = stringField(agent, "agentVersion", 128);
+    const label = stringField(agent, "label", 80);
+    if (agentPath.trim().length === 0 || agentVersion.trim().length === 0 || label.trim().length === 0) {
+        throw invalidResponse("The service returned an invalid Agent descriptor");
+    }
+    return new MobiusAgentDescriptor(agentPath, agentVersion, decodeMobiusAgentCapabilities(agent["capabilities"]), identifierField(agent, "id"), label.trim());
+}
+export class MobiusInstallableAgentDescriptor {
+    id;
+    label;
+    constructor(id, label) {
+        this.id = id;
+        this.label = label;
+    }
+}
+export class MobiusMissingAgentDescriptor extends MobiusInstallableAgentDescriptor {
+    status = "agent_not_installed";
+    // biome-ignore lint/complexity/noUselessConstructor: Exposes the protected base constructor publicly.
+    constructor(id, label) {
+        super(id, label);
+    }
+}
+export class MobiusAgentIntegrationDescriptor extends MobiusInstallableAgentDescriptor {
+    agentPath;
+    agentVersion;
+    status = "integration_not_installed";
+    constructor(agentPath, agentVersion, id, label) {
+        super(id, label);
+        this.agentPath = agentPath;
+        this.agentVersion = agentVersion;
+    }
+}
+function decodeInstallableAgentDescriptor(value) {
+    const agent = record(value, "installable Agent descriptor");
+    const id = identifierField(agent, "id");
+    const label = stringField(agent, "label", 80);
+    if (label.trim().length === 0) {
+        throw invalidResponse("The service returned an invalid installable Agent descriptor");
+    }
+    if (agent["status"] === "agent_not_installed" &&
+        Object.keys(agent).length === 3 &&
+        Object.hasOwn(agent, "id") &&
+        Object.hasOwn(agent, "label") &&
+        Object.hasOwn(agent, "status")) {
+        return new MobiusMissingAgentDescriptor(id, label.trim());
+    }
+    if (agent["status"] === "integration_not_installed" &&
+        Object.keys(agent).length === 5 &&
+        Object.hasOwn(agent, "agentPath") &&
+        Object.hasOwn(agent, "agentVersion") &&
+        Object.hasOwn(agent, "id") &&
+        Object.hasOwn(agent, "label") &&
+        Object.hasOwn(agent, "status")) {
+        const agentPath = stringField(agent, "agentPath", 4_096);
+        const agentVersion = stringField(agent, "agentVersion", 128);
+        if (agentPath.trim().length === 0 || agentVersion.trim().length === 0) {
+            throw invalidResponse("The service returned an invalid installable Agent descriptor");
+        }
+        return new MobiusAgentIntegrationDescriptor(agentPath, agentVersion.trim(), id, label.trim());
+    }
+    throw invalidResponse("The service returned an invalid installable Agent descriptor");
+}
+export class MobiusRuntimeDescriptor {
+    agents;
+    channelId;
+    installableAgents;
+    machineName;
+    online;
+    projectId;
+    runtimeId;
+    workspaceName;
+    constructor(agents, channelId, installableAgents, machineName, online, projectId, runtimeId, workspaceName) {
+        this.agents = agents;
+        this.channelId = channelId;
+        this.installableAgents = installableAgents;
+        this.machineName = machineName;
+        this.online = online;
+        this.projectId = projectId;
+        this.runtimeId = runtimeId;
+        this.workspaceName = workspaceName;
+    }
+}
+function decodeRuntimeDescriptor(value) {
+    const runtime = record(value, "Runtime descriptor");
+    return new MobiusRuntimeDescriptor(arrayField(runtime, "agents", 100).map(decodeAgentDescriptor), identifierField(runtime, "channelId"), arrayField(runtime, "installableAgents", 100).map(decodeInstallableAgentDescriptor), stringField(runtime, "machineName", 255), booleanField(runtime, "online"), identifierField(runtime, "projectId"), identifierField(runtime, "runtimeId"), stringField(runtime, "workspaceName", 255));
+}
+export function decodeMobiusRuntimeList(value) {
+    const response = record(value, "Runtime list");
+    return arrayField(response, "runtimes", 100).map(decodeRuntimeDescriptor);
+}
+export class MobiusRuntimePairing {
+    channelId;
+    expiresAt;
+    pairingCode;
+    pairingId;
+    pollToken;
+    projectId;
+    runtimeId;
+    constructor(channelId, expiresAt, pairingCode, pairingId, pollToken, projectId, runtimeId) {
+        this.channelId = channelId;
+        this.expiresAt = expiresAt;
+        this.pairingCode = pairingCode;
+        this.pairingId = pairingId;
+        this.pollToken = pollToken;
+        this.projectId = projectId;
+        this.runtimeId = runtimeId;
+    }
+}
+export class MobiusRuntimePairingWaitOptions {
+    pollIntervalMilliseconds;
+    timeoutMilliseconds;
+    constructor(timeoutMilliseconds = 120_000, pollIntervalMilliseconds = 1_000) {
+        if (!Number.isSafeInteger(timeoutMilliseconds) ||
+            timeoutMilliseconds < 1 ||
+            timeoutMilliseconds > 30 * 60 * 1_000 ||
+            !Number.isSafeInteger(pollIntervalMilliseconds) ||
+            pollIntervalMilliseconds < 1 ||
+            pollIntervalMilliseconds > timeoutMilliseconds) {
+            throw new MobiusValidationError("The Runtime pairing wait bounds are invalid");
+        }
+        this.pollIntervalMilliseconds = pollIntervalMilliseconds;
+        this.timeoutMilliseconds = timeoutMilliseconds;
+    }
+}
+export function decodeMobiusRuntimePairing(value) {
+    const pairing = record(value, "Runtime pairing");
+    const pairingCode = stringField(pairing, "pairingCode", 24);
+    const pollToken = stringField(pairing, "pollToken", 256);
+    if (!/^[A-HJ-NP-Z2-9]{4}(?:-[A-HJ-NP-Z2-9]{4}){4}$/.test(pairingCode) ||
+        !/^[a-zA-Z0-9_-]{32,256}$/.test(pollToken)) {
+        throw invalidResponse("The service returned invalid Runtime pairing credentials");
+    }
+    return new MobiusRuntimePairing(identifierField(pairing, "channelId"), validateTimestamp(stringField(pairing, "expiresAt", 128), "expiresAt"), pairingCode, identifierField(pairing, "pairingId"), pollToken, identifierField(pairing, "projectId"), identifierField(pairing, "runtimeId"));
+}
+export const MobiusRuntimePairingLifecycle = Object.freeze({
+    Expired: "expired",
+    Paired: "paired",
+    Pending: "pending",
+    Revoked: "revoked",
+});
+export class MobiusRuntimePairingStatus {
+}
+export class MobiusPendingRuntimePairingStatus extends MobiusRuntimePairingStatus {
+    expiresAt;
+    status = MobiusRuntimePairingLifecycle.Pending;
+    constructor(expiresAt) {
+        super();
+        this.expiresAt = expiresAt;
+    }
+}
+export class MobiusExpiredRuntimePairingStatus extends MobiusRuntimePairingStatus {
+    status = MobiusRuntimePairingLifecycle.Expired;
+}
+export class MobiusPairedRuntimePairingStatus extends MobiusRuntimePairingStatus {
+    agents;
+    channelId;
+    installableAgents;
+    machineName;
+    projectId;
+    runtimeId;
+    status = MobiusRuntimePairingLifecycle.Paired;
+    workspaceName;
+    constructor(agents, channelId, installableAgents, machineName, projectId, runtimeId, workspaceName) {
+        super();
+        this.agents = agents;
+        this.channelId = channelId;
+        this.installableAgents = installableAgents;
+        this.machineName = machineName;
+        this.projectId = projectId;
+        this.runtimeId = runtimeId;
+        this.workspaceName = workspaceName;
+    }
+}
+export class MobiusRevokedRuntimePairingStatus extends MobiusRuntimePairingStatus {
+    revokedAt;
+    status = MobiusRuntimePairingLifecycle.Revoked;
+    constructor(revokedAt) {
+        super();
+        this.revokedAt = revokedAt;
+    }
+}
+export function decodeMobiusRuntimePairingStatus(value) {
+    const status = record(value, "Runtime pairing status");
+    const lifecycle = stringField(status, "status", 32);
+    if (lifecycle === MobiusRuntimePairingLifecycle.Pending) {
+        return new MobiusPendingRuntimePairingStatus(validateTimestamp(stringField(status, "expiresAt", 128), "expiresAt"));
+    }
+    if (lifecycle === MobiusRuntimePairingLifecycle.Expired) {
+        return new MobiusExpiredRuntimePairingStatus();
+    }
+    if (lifecycle === MobiusRuntimePairingLifecycle.Revoked) {
+        return new MobiusRevokedRuntimePairingStatus(validateTimestamp(stringField(status, "revokedAt", 128), "revokedAt"));
+    }
+    if (lifecycle === MobiusRuntimePairingLifecycle.Paired) {
+        return new MobiusPairedRuntimePairingStatus(arrayField(status, "agents", 100).map(decodeAgentDescriptor), identifierField(status, "channelId"), arrayField(status, "installableAgents", 100).map(decodeInstallableAgentDescriptor), stringField(status, "machineName", 255), identifierField(status, "projectId"), identifierField(status, "runtimeId"), stringField(status, "workspaceName", 255));
+    }
+    throw invalidResponse("The service returned an unsupported Runtime pairing status");
+}
+export class MobiusInteractionResponseRequest {
+    responderId;
+    constructor(responderId) {
+        this.responderId = responderId;
+    }
+}
+export class MobiusPermissionResponseRequest extends MobiusInteractionResponseRequest {
+    kind = "permission";
+    optionId;
+    outcome;
+    constructor(responderId, outcome, optionId) {
+        super(responderId);
+        this.optionId = optionId;
+        this.outcome = outcome;
+    }
+}
+export class MobiusElicitationResponseRequest extends MobiusInteractionResponseRequest {
+    action;
+    content;
+    kind = "elicitation";
+    constructor(responderId, action, content) {
+        super(responderId);
+        this.action = action;
+        this.content = content;
+    }
+}
+export function decodeMobiusInteraction(value) {
+    try {
+        return decodeInteraction(value);
+    }
+    catch (cause) {
+        throw new MobiusProtocolError("The service returned an invalid Interaction", { cause });
+    }
+}
+export function decodeMobiusInteractionList(value) {
+    const response = record(value, "Interaction list");
+    return arrayField(response, "interactions", 100).map(decodeMobiusInteraction);
+}
+export class MobiusPageRequest {
+    cursor;
+    limit;
+    constructor(limit, cursor) {
+        if (!Number.isSafeInteger(limit) || limit < 1 || limit > 100 || cursor.length > 512) {
+            throw new MobiusValidationError("The page request is invalid");
+        }
+        this.cursor = cursor;
+        this.limit = limit;
+    }
+}
+export class MobiusSessionBinding {
+    agentRef;
+    bindingId;
+    configRevision;
+    createdAt;
+    runtimeId;
+    sessionId;
+    workspaceRef;
+    constructor(agentRef, bindingId, configRevision, createdAt, runtimeId, sessionId, workspaceRef) {
+        this.agentRef = agentRef;
+        this.bindingId = bindingId;
+        this.configRevision = configRevision;
+        this.createdAt = createdAt;
+        this.runtimeId = runtimeId;
+        this.sessionId = sessionId;
+        this.workspaceRef = workspaceRef;
+    }
+}
+export class MobiusSessionState {
+}
+export class MobiusReadySessionState extends MobiusSessionState {
+    kind = "ready";
+}
+export class MobiusDeletingSessionState extends MobiusSessionState {
+    kind = "deleting";
+    requestedAt;
+    constructor(requestedAt) {
+        super();
+        this.requestedAt = requestedAt;
+    }
+}
+export class MobiusDeletedSessionState extends MobiusSessionState {
+    completedAt;
+    kind = "deleted";
+    constructor(completedAt) {
+        super();
+        this.completedAt = completedAt;
+    }
+}
+export class MobiusSession {
+    agentId;
+    createdAt;
+    createdBy;
+    defaultBinding;
+    hasNativeHistory;
+    lastCommittedSequence;
+    policy;
+    projectId;
+    runtimeId;
+    sessionId;
+    state;
+    title;
+    updatedAt;
+    constructor(agentId, createdAt, createdBy, defaultBinding, hasNativeHistory, lastCommittedSequence, policy, projectId, runtimeId, sessionId, state, title, updatedAt) {
+        this.agentId = agentId;
+        this.createdAt = createdAt;
+        this.createdBy = createdBy;
+        this.defaultBinding = defaultBinding;
+        this.hasNativeHistory = hasNativeHistory;
+        this.lastCommittedSequence = lastCommittedSequence;
+        this.policy = policy;
+        this.projectId = projectId;
+        this.runtimeId = runtimeId;
+        this.sessionId = sessionId;
+        this.state = state;
+        this.title = title;
+        this.updatedAt = updatedAt;
+    }
+}
+export function decodeMobiusSessionState(value) {
+    const state = record(value, "Session lifecycle");
+    const kind = stringField(state, "kind", 32);
+    if (kind === "ready") {
+        return new MobiusReadySessionState();
+    }
+    if (kind === "deleting") {
+        return new MobiusDeletingSessionState(validateTimestamp(stringField(state, "requestedAt", 128), "requestedAt"));
+    }
+    if (kind === "deleted") {
+        return new MobiusDeletedSessionState(validateTimestamp(stringField(state, "completedAt", 128), "completedAt"));
+    }
+    throw invalidResponse("The service returned an unsupported Session lifecycle");
+}
+function decodeBinding(value) {
+    const binding = record(value, "Session binding");
+    return new MobiusSessionBinding(identifierField(binding, "agentRef"), identifierField(binding, "bindingId"), integerField(binding, "configRevision"), validateTimestamp(stringField(binding, "createdAt", 128), "createdAt"), identifierField(binding, "runtimeId"), identifierField(binding, "sessionId"), identifierField(binding, "workspaceRef"));
+}
+function decodeRecordingPolicy(value) {
+    const policy = record(value, "Session recording policy");
+    return new MobiusRecordingPolicy(stringField(policy, "level", 32), integerField(policy, "retentionMilliseconds"), integerField(policy, "hotEventLimit"), integerField(policy, "contentLimitBytes"), integerField(policy, "idempotencyRetentionMilliseconds"));
+}
+export function decodeMobiusSession(value) {
+    const session = record(value, "Session");
+    const sequence = stringField(session, "lastCommittedSeq", 40);
+    if (!/^(?:0|[1-9][0-9]*)$/.test(sequence)) {
+        throw invalidResponse("The service returned an invalid event sequence");
+    }
+    return new MobiusSession(identifierField(session, "agentId"), validateTimestamp(stringField(session, "createdAt", 128), "createdAt"), identifierField(session, "createdBy"), decodeBinding(session["defaultBinding"]), booleanField(session, "hasNativeHistory"), sequence, decodeRecordingPolicy(session["policy"]), identifierField(session, "projectId"), identifierField(session, "runtimeId"), identifierField(session, "sessionId"), decodeMobiusSessionState(session["lifecycle"]), stringField(session, "title", 500), validateTimestamp(stringField(session, "updatedAt", 128), "updatedAt"));
+}
+export class MobiusSessionPage {
+    nextCursor;
+    sessions;
+    constructor(sessions, nextCursor) {
+        this.nextCursor = nextCursor;
+        this.sessions = sessions;
+    }
+}
+export function decodeMobiusSessionPage(value) {
+    const page = record(value, "Session page");
+    return new MobiusSessionPage(arrayField(page, "sessions", 100).map(decodeMobiusSession), nullableCursor(page, "nextCursor"));
+}
+export class MobiusTurnState {
+}
+export class MobiusQueuedTurnState extends MobiusTurnState {
+    kind = "queued";
+}
+export class MobiusRunningTurnState extends MobiusTurnState {
+    kind = "running";
+    startedAt;
+    constructor(startedAt) {
+        super();
+        this.startedAt = startedAt;
+    }
+}
+export class MobiusSucceededTurnState extends MobiusTurnState {
+    completedAt;
+    kind = "succeeded";
+    stopReason;
+    constructor(completedAt, stopReason) {
+        super();
+        this.completedAt = completedAt;
+        this.stopReason = stopReason;
+    }
+}
+export class MobiusFailedTurnState extends MobiusTurnState {
+    code;
+    failedAt;
+    kind = "failed";
+    message;
+    retryable;
+    constructor(failedAt, code, message, retryable) {
+        super();
+        this.code = code;
+        this.failedAt = failedAt;
+        this.message = message;
+        this.retryable = retryable;
+    }
+}
+export class MobiusCancelledTurnState extends MobiusTurnState {
+    cancelledAt;
+    kind = "cancelled";
+    constructor(cancelledAt) {
+        super();
+        this.cancelledAt = cancelledAt;
+    }
+}
+export class MobiusIndeterminateTurnState extends MobiusTurnState {
+    detectedAt;
+    kind = "indeterminate";
+    reason;
+    constructor(detectedAt, reason) {
+        super();
+        this.detectedAt = detectedAt;
+        this.reason = reason;
+    }
+}
+export class MobiusTurn {
+    acceptedAt;
+    bindingId;
+    content;
+    idempotencyKey;
+    sessionId;
+    state;
+    turnId;
+    constructor(acceptedAt, bindingId, content, idempotencyKey, sessionId, state, turnId) {
+        this.acceptedAt = acceptedAt;
+        this.bindingId = bindingId;
+        this.content = content;
+        this.idempotencyKey = idempotencyKey;
+        this.sessionId = sessionId;
+        this.state = state;
+        this.turnId = turnId;
+    }
+}
+export function decodeMobiusTurn(value) {
+    const turn = decodeTurn(value);
+    let state;
+    switch (turn.state.kind) {
+        case "queued":
+            state = new MobiusQueuedTurnState();
+            break;
+        case "running":
+            state = new MobiusRunningTurnState(turn.state.startedAt);
+            break;
+        case "succeeded":
+            state = new MobiusSucceededTurnState(turn.state.completedAt, turn.state.result.stopReason);
+            break;
+        case "failed":
+            state = new MobiusFailedTurnState(turn.state.failedAt, turn.state.error.code, turn.state.error.message, turn.state.error.retryable);
+            break;
+        case "cancelled":
+            state = new MobiusCancelledTurnState(turn.state.cancelledAt);
+            break;
+        case "indeterminate":
+            state = new MobiusIndeterminateTurnState(turn.state.reconciliation.detectedAt, turn.state.reconciliation.reason);
+            break;
+    }
+    return new MobiusTurn(turn.acceptedAt, turn.bindingId, turn.request.content, turn.idempotencyKey, turn.sessionId, state, turn.turnId);
+}
+export function decodeMobiusAttempt(value) {
+    try {
+        return decodeAttempt(value);
+    }
+    catch (cause) {
+        throw new MobiusProtocolError("The service returned an invalid Attempt", {
+            cause,
+        });
+    }
+}
+export class MobiusAttemptSummary {
+}
+export class MobiusNoAttemptSummary extends MobiusAttemptSummary {
+    kind = "none";
+}
+export class MobiusPresentAttemptSummary extends MobiusAttemptSummary {
+    attemptId;
+    constructor(attemptId) {
+        super();
+        this.attemptId = attemptId;
+    }
+}
+export class MobiusDispatchingAttemptSummary extends MobiusPresentAttemptSummary {
+    dispatchedAt;
+    kind = "dispatching";
+    constructor(attemptId, dispatchedAt) {
+        super(attemptId);
+        this.dispatchedAt = dispatchedAt;
+    }
+}
+export class MobiusRunningAttemptSummary extends MobiusPresentAttemptSummary {
+    kind = "running";
+    startedAt;
+    constructor(attemptId, startedAt) {
+        super(attemptId);
+        this.startedAt = startedAt;
+    }
+}
+export class MobiusSucceededAttemptSummary extends MobiusPresentAttemptSummary {
+    completedAt;
+    kind = "succeeded";
+    startedAt;
+    stopReason;
+    constructor(attemptId, startedAt, completedAt, stopReason) {
+        super(attemptId);
+        this.completedAt = completedAt;
+        this.startedAt = startedAt;
+        this.stopReason = stopReason;
+    }
+}
+export class MobiusCancelledAttemptSummary extends MobiusPresentAttemptSummary {
+    cancelledAt;
+    kind = "cancelled";
+    startedAt;
+    constructor(attemptId, startedAt, cancelledAt) {
+        super(attemptId);
+        this.cancelledAt = cancelledAt;
+        this.startedAt = startedAt;
+    }
+}
+export class MobiusWaitingInputAttemptSummary extends MobiusPresentAttemptSummary {
+    interactionIds;
+    kind = "waiting_input";
+    startedAt;
+    constructor(attemptId, startedAt, interactionIds) {
+        super(attemptId);
+        this.interactionIds = interactionIds;
+        this.startedAt = startedAt;
+    }
+}
+export class MobiusFailedBeforeStartAttemptSummary extends MobiusAttemptSummary {
+    code;
+    failedAt;
+    kind = "failed";
+    message;
+    constructor(code, message, failedAt) {
+        super();
+        this.code = code;
+        this.failedAt = failedAt;
+        this.message = message;
+    }
+}
+export class MobiusFailedAttemptSummary extends MobiusPresentAttemptSummary {
+    code;
+    failedAt;
+    kind = "failed";
+    message;
+    startedAt;
+    constructor(attemptId, startedAt, code, message, failedAt) {
+        super(attemptId);
+        this.code = code;
+        this.failedAt = failedAt;
+        this.message = message;
+        this.startedAt = startedAt;
+    }
+}
+export class MobiusIndeterminateAttemptSummary extends MobiusPresentAttemptSummary {
+    detectedAt;
+    kind = "indeterminate";
+    startedAt;
+    constructor(attemptId, startedAt, detectedAt) {
+        super(attemptId);
+        this.detectedAt = detectedAt;
+        this.startedAt = startedAt;
+    }
+}
+export function decodeMobiusAttemptSummary(value) {
+    if (value === null) {
+        return new MobiusNoAttemptSummary();
+    }
+    const attempt = record(value, "Attempt summary");
+    const kind = stringField(attempt, "kind", 32);
+    if (kind === "failed") {
+        const attemptId = attempt["attemptId"];
+        const startedAt = attempt["startedAt"];
+        const code = identifierField(attempt, "code");
+        const message = stringField(attempt, "message", 2_000);
+        const failedAt = validateTimestamp(stringField(attempt, "failedAt", 128), "failedAt");
+        if (attemptId === null && startedAt === null) {
+            return new MobiusFailedBeforeStartAttemptSummary(code, message, failedAt);
+        }
+        if (typeof attemptId !== "string" || typeof startedAt !== "string") {
+            throw invalidResponse("The service returned an invalid failed Attempt");
+        }
+        return new MobiusFailedAttemptSummary(attemptId, validateTimestamp(startedAt, "startedAt"), code, message, failedAt);
+    }
+    const attemptId = identifierField(attempt, "attemptId");
+    if (kind === "dispatching") {
+        return new MobiusDispatchingAttemptSummary(attemptId, validateTimestamp(stringField(attempt, "dispatchedAt", 128), "dispatchedAt"));
+    }
+    const startedAt = validateTimestamp(stringField(attempt, "startedAt", 128), "startedAt");
+    if (kind === "running") {
+        return new MobiusRunningAttemptSummary(attemptId, startedAt);
+    }
+    if (kind === "succeeded") {
+        return new MobiusSucceededAttemptSummary(attemptId, startedAt, validateTimestamp(stringField(attempt, "completedAt", 128), "completedAt"), stringField(attempt, "stopReason", 128));
+    }
+    if (kind === "cancelled") {
+        return new MobiusCancelledAttemptSummary(attemptId, startedAt, validateTimestamp(stringField(attempt, "cancelledAt", 128), "cancelledAt"));
+    }
+    if (kind === "waiting_input") {
+        return new MobiusWaitingInputAttemptSummary(attemptId, startedAt, arrayField(attempt, "interactionIds", 100).map((interactionId) => {
+            if (typeof interactionId !== "string") {
+                throw invalidResponse("The service returned an invalid interaction identifier");
+            }
+            return identifierField({ interactionId }, "interactionId");
+        }));
+    }
+    if (kind === "indeterminate") {
+        return new MobiusIndeterminateAttemptSummary(attemptId, startedAt, validateTimestamp(stringField(attempt, "detectedAt", 128), "detectedAt"));
+    }
+    throw invalidResponse("The service returned an unsupported Attempt state");
+}
+export class MobiusActivitySummary {
+    activityId;
+    attemptId;
+    activityType;
+    detailAvailability;
+    input;
+    locations;
+    name;
+    output;
+    sequence;
+    status;
+    title;
+    toolCallId;
+    toolKind;
+    constructor(activityId, attemptId, activityType, detailAvailability, input, locations, name, output, sequence, status, title, toolCallId, toolKind) {
+        this.activityId = activityId;
+        this.attemptId = attemptId;
+        this.activityType = activityType;
+        this.detailAvailability = detailAvailability;
+        this.input = input;
+        this.locations = locations;
+        this.name = name;
+        this.output = output;
+        this.sequence = sequence;
+        this.status = status;
+        this.title = title;
+        this.toolCallId = toolCallId;
+        this.toolKind = toolKind;
+    }
+}
+export function decodeMobiusActivitySummary(value) {
+    const activity = record(value, "Activity summary");
+    return new MobiusActivitySummary(identifierField(activity, "activityId"), identifierField(activity, "attemptId"), stringField(activity, "activityType", 128), stringField(activity, "detailAvailability", 32), stringField(activity, "input", 100_000), arrayField(activity, "locations", 100).map((location) => {
+        if (typeof location !== "string" || location.length > 2_048) {
+            throw invalidResponse("The service returned an invalid Activity location");
+        }
+        return location;
+    }), stringField(activity, "name", 128), stringField(activity, "output", 100_000), integerField(activity, "sequence"), stringField(activity, "status", 64), stringField(activity, "title", 500), identifierField(activity, "toolCallId"), stringField(activity, "toolKind", 128));
+}
+export class MobiusMessage {
+    activities;
+    additionalDirectoryIds;
+    agentId;
+    attempt;
+    commandId;
+    createdAt;
+    disposition;
+    images;
+    messageId;
+    prompt;
+    resources;
+    response;
+    sessionId;
+    targetCommandId;
+    constructor(activities, additionalDirectoryIds, agentId, attempt, commandId, createdAt, disposition, images, messageId, prompt, resources, response, sessionId, targetCommandId) {
+        this.activities = activities;
+        this.additionalDirectoryIds = additionalDirectoryIds;
+        this.agentId = agentId;
+        this.attempt = attempt;
+        this.commandId = commandId;
+        this.createdAt = createdAt;
+        this.disposition = disposition;
+        this.images = images;
+        this.messageId = messageId;
+        this.prompt = prompt;
+        this.resources = resources;
+        this.response = response;
+        this.sessionId = sessionId;
+        this.targetCommandId = targetCommandId;
+    }
+}
+function decodeMobiusMessage(value) {
+    const message = record(value, "Session message");
+    return new MobiusMessage(arrayField(message, "activities", 10_000).map(decodeMobiusActivitySummary), arrayField(message, "additionalDirectoryIds", 100).map((directoryId) => {
+        if (typeof directoryId !== "string") {
+            throw invalidResponse("The service returned an invalid additional directory identifier");
+        }
+        return identifierField({ directoryId }, "directoryId");
+    }), identifierField(message, "agentId"), decodeMobiusAttemptSummary(message["attempt"]), identifierField(message, "commandId"), validateTimestamp(stringField(message, "createdAt", 128), "createdAt"), stringField(message, "disposition", 16), decodePromptImagesValue(message["images"]), stringField(message, "messageId", 255), stringField(message, "prompt", 100_000), decodePromptResourcesValue(message["resources"]), stringField(message, "response", 8_500_000), identifierField(message, "sessionId"), stringField(message, "targetCommandId", 128));
+}
+export class MobiusMessagePage {
+    lastCommittedSequence;
+    messages;
+    nextCursor;
+    constructor(lastCommittedSequence, messages, nextCursor) {
+        this.lastCommittedSequence = lastCommittedSequence;
+        this.messages = messages;
+        this.nextCursor = nextCursor;
+    }
+}
+export function decodeMobiusMessagePage(value) {
+    const page = record(value, "Session message page");
+    const sequence = stringField(page, "lastCommittedSeq", 40);
+    if (!/^(?:0|[1-9][0-9]*)$/.test(sequence)) {
+        throw invalidResponse("The service returned an invalid event sequence");
+    }
+    return new MobiusMessagePage(sequence, arrayField(page, "messages", 100).map(decodeMobiusMessage), nullableCursor(page, "nextCursor"));
+}
+export class MobiusToolCallDetail {
+}
+export class MobiusAvailableToolCallDetail extends MobiusToolCallDetail {
+    artifactId;
+    content;
+    input;
+    kind = "available";
+    output;
+    storage;
+    constructor(artifactId, content, input, output, storage) {
+        super();
+        this.artifactId = artifactId;
+        this.content = content;
+        this.input = input;
+        this.output = output;
+        this.storage = storage;
+    }
+}
+export class MobiusTruncatedToolCallDetail extends MobiusToolCallDetail {
+    capturedBytes;
+    kind = "truncated";
+    originalBytes;
+    constructor(capturedBytes, originalBytes) {
+        super();
+        this.capturedBytes = capturedBytes;
+        this.originalBytes = originalBytes;
+    }
+}
+export class MobiusUnrecordedToolCallDetail extends MobiusToolCallDetail {
+    kind = "unrecorded";
+}
+export class MobiusDeletedToolCallDetail extends MobiusToolCallDetail {
+    deletedAt;
+    kind = "deleted";
+    constructor(deletedAt) {
+        super();
+        this.deletedAt = deletedAt;
+    }
+}
+export function decodeMobiusToolCallDetail(value) {
+    const detail = record(value, "ToolCall detail");
+    const kind = stringField(detail, "kind", 32);
+    if (kind === "available") {
+        const storage = stringField(detail, "storage", 32);
+        if (storage !== "archive" && storage !== "hot") {
+            throw invalidResponse("The service returned an invalid ToolCall storage state");
+        }
+        return new MobiusAvailableToolCallDetail(identifierField(detail, "artifactId"), arrayField(detail, "content", 100_000), stringField(detail, "input"), stringField(detail, "output"), storage);
+    }
+    if (kind === "truncated") {
+        return new MobiusTruncatedToolCallDetail(integerField(detail, "capturedBytes"), integerField(detail, "originalBytes"));
+    }
+    if (kind === "unrecorded") {
+        return new MobiusUnrecordedToolCallDetail();
+    }
+    if (kind === "deleted") {
+        return new MobiusDeletedToolCallDetail(validateTimestamp(stringField(detail, "deletedAt", 128), "deletedAt"));
+    }
+    throw invalidResponse("The service returned an invalid ToolCall detail");
+}
+export class MobiusEventPage {
+    cursor;
+    events;
+    hasMore;
+    constructor(cursor, events, hasMore) {
+        this.cursor = cursor;
+        this.events = events;
+        this.hasMore = hasMore;
+    }
+}
+export function decodeMobiusEventPage(value) {
+    const page = record(value, "Session event page");
+    return new MobiusEventPage(stringField(page, "cursor", 512), arrayField(page, "events", 100).map(decodeMobiusSessionEvent), booleanField(page, "hasMore"));
+}
+export class MobiusSessionExport {
+    formatVersion;
+    session;
+    constructor(formatVersion, session) {
+        this.formatVersion = formatVersion;
+        this.session = session;
+    }
+}
+export function decodeMobiusSessionExport(value) {
+    const exported = record(value, "Session export");
+    const formatVersion = stringField(exported, "formatVersion", 32);
+    if (formatVersion !== MOBIUS_SESSION_EXPORT_FORMAT_VERSION) {
+        throw invalidResponse("The service returned an unsupported Session export");
+    }
+    return new MobiusSessionExport(formatVersion, record(exported["session"], "Session export payload"));
+}
+export class MobiusEventSource {
+    sourceSequence;
+    constructor(sourceSequence) {
+        this.sourceSequence = sourceSequence;
+    }
+}
+export class MobiusRuntimeEventSource extends MobiusEventSource {
+    kind = "runtime";
+}
+export class MobiusAttemptEventSource extends MobiusEventSource {
+    attemptId;
+    kind = "attempt";
+    constructor(attemptId, sourceSequence) {
+        super(sourceSequence);
+        this.attemptId = attemptId;
+    }
+}
+export class MobiusRecordedEvent {
+    sessionId;
+    constructor(sessionId) {
+        this.sessionId = sessionId;
+    }
+}
+export class MobiusTurnStartedEvent extends MobiusRecordedEvent {
+    attemptId;
+    commandId;
+    kind = SESSION_STARTED_KIND;
+    constructor(sessionId, commandId, attemptId) {
+        super(sessionId);
+        this.attemptId = attemptId;
+        this.commandId = commandId;
+    }
+}
+export class MobiusAgentMessageEvent extends MobiusRecordedEvent {
+    commandId;
+    kind = AGENT_MESSAGE_DELTA_KIND;
+    text;
+    constructor(sessionId, commandId, text) {
+        super(sessionId);
+        this.commandId = commandId;
+        this.text = text;
+    }
+}
+export class MobiusAgentActivityEvent extends MobiusRecordedEvent {
+    activityId;
+    activityType;
+    commandId;
+    content;
+    detail;
+    input;
+    kind = AGENT_ACTIVITY_KIND;
+    locations;
+    name;
+    output;
+    sequence;
+    status;
+    title;
+    toolKind;
+    constructor(event) {
+        super(event.sessionId);
+        this.activityId = event.activityId;
+        this.activityType = event.activityType;
+        this.commandId = event.commandId;
+        this.content = event.content;
+        this.detail = event.detail;
+        this.input = event.input;
+        this.locations = event.locations;
+        this.name = event.name;
+        this.output = event.output;
+        this.sequence = event.sequence;
+        this.status = event.status;
+        this.title = event.title;
+        this.toolKind = event.toolKind;
+    }
+}
+export class MobiusTurnCompletedEvent extends MobiusRecordedEvent {
+    commandId;
+    kind = SESSION_COMPLETED_KIND;
+    stopReason;
+    constructor(sessionId, commandId, stopReason) {
+        super(sessionId);
+        this.commandId = commandId;
+        this.stopReason = stopReason;
+    }
+}
+export class MobiusTurnFailedEvent extends MobiusRecordedEvent {
+    code;
+    commandId;
+    kind = SESSION_FAILED_KIND;
+    message;
+    constructor(sessionId, commandId, code, message) {
+        super(sessionId);
+        this.code = code;
+        this.commandId = commandId;
+        this.message = message;
+    }
+}
+export class MobiusControlEvent extends MobiusRecordedEvent {
+    encodedPayload;
+    kind;
+    constructor(sessionId, kind, encodedPayload) {
+        super(sessionId);
+        this.encodedPayload = encodedPayload;
+        this.kind = kind;
+    }
+}
+function decodeRecordedEvent(encoded) {
+    const event = decodeRecordedSessionEvent(encoded);
+    switch (event.kind) {
+        case SESSION_STARTED_KIND:
+            return new MobiusTurnStartedEvent(event.sessionId, event.commandId, event.attemptId);
+        case AGENT_MESSAGE_DELTA_KIND:
+            return new MobiusAgentMessageEvent(event.sessionId, event.commandId, event.text);
+        case AGENT_ACTIVITY_KIND:
+            return new MobiusAgentActivityEvent(event);
+        case SESSION_COMPLETED_KIND:
+            return new MobiusTurnCompletedEvent(event.sessionId, event.commandId, event.stopReason);
+        case SESSION_FAILED_KIND:
+            return new MobiusTurnFailedEvent(event.sessionId, event.commandId, event.code, event.message);
+        default:
+            return new MobiusControlEvent(event.sessionId, event.kind, encoded);
+    }
+}
+export class MobiusSessionEvent {
+    cursor;
+    eventId;
+    payload;
+    recordedAt;
+    sequence;
+    sessionId;
+    source;
+    constructor(cursor, eventId, payload, recordedAt, sequence, sessionId, source) {
+        this.cursor = cursor;
+        this.eventId = eventId;
+        this.payload = payload;
+        this.recordedAt = recordedAt;
+        this.sequence = sequence;
+        this.sessionId = sessionId;
+        this.source = source;
+    }
+}
+export function decodeMobiusSessionEvent(value) {
+    const encoded = JSON.stringify(value);
+    if (typeof encoded !== "string") {
+        throw invalidResponse("The service returned an invalid Session event");
+    }
+    const event = decodeCommittedSessionEvent(encoded);
+    const source = event.source.kind === "attempt"
+        ? new MobiusAttemptEventSource(event.source.attemptId, event.source.sourceSeq)
+        : new MobiusRuntimeEventSource(event.source.sourceSeq);
+    return new MobiusSessionEvent(event.cursor, event.eventId, decodeRecordedEvent(event.payload), event.recordedAt, event.sequence, event.sessionId, source);
+}
+//# sourceMappingURL=resources.js.map