@moxt-ai/mobius-sdk 0.0.28 → 0.0.30

package/dist/resources.js

@@ -1,5 +1,10 @@
-import { sessionCapabilitiesSchema } from "@moxt-ai/mobius-protocol";
+import { AGENT_ACTIVITY_DETAIL_LIMIT, AGENT_ACTIVITY_KIND, AGENT_ACTIVITY_NARRATION_KIND, AGENT_MESSAGE_DELTA_KIND, decodeAgentDisplayContentValue, decodeAttempt, decodeCommittedSessionEvent, decodeInteraction, decodePromptImagesValue, decodePromptResourcesValue, decodeRecordedSessionEvent, decodeTurn, MOBIUS_API_VERSION, SESSION_COMPLETED_KIND, SESSION_FAILED_KIND, SESSION_STARTED_KIND, sessionCapabilitiesSchema, } from "@moxt-ai/mobius-protocol";
 import { MobiusProtocolError, MobiusValidationError } from "./errors.js";
+const MOBIUS_EVENT_FORMAT_VERSION = "1";
+const MOBIUS_SESSION_EVENT_STREAM_EVENT = "mobius.session-event.v1";
+const MOBIUS_SESSION_EVENT_STREAM_MEDIA_TYPE = "text/event-stream";
+const MOBIUS_SESSION_EVENT_STREAM_TRANSPORT = "sse";
+const MOBIUS_SESSION_EXPORT_FORMAT_VERSION = "1";
 const IDENTIFIER_PATTERN = /^[a-zA-Z0-9][a-zA-Z0-9._:-]{0,127}$/;
 const SESSION_CAPABILITY_FIELDS = [
     "additionalDirectories",
@@ -41,7 +46,7 @@ function identifierField(value, field) {
     }
     return candidate;
 }
-function _integerField(value, field) {
+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}`);
@@ -55,6 +60,16 @@ function booleanField(value, field) {
     }
     return candidate;
 }
+function busyStatusField(value, field) {
+    const candidate = value[field];
+    if (candidate === undefined || candidate === null) {
+        return undefined;
+    }
+    if (candidate !== "working" && candidate !== "failed") {
+        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) {
@@ -62,12 +77,189 @@ function arrayField(value, field, maximumLength = 10_000) {
     }
     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 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 {
+    attempts;
+    browserCredentials;
+    events;
+    interactions;
+    messages;
+    portability;
+    runtimePairings;
+    runtimes;
+    sessions;
+    toolCalls;
+    turns;
+    constructor(resources) {
+        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;
+    authentication;
+    portability;
+    resources;
+    sessionEvents;
+    constructor(apiVersion, authentication, portability, resources, sessionEvents) {
+        this.apiVersion = apiVersion;
+        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 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 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 ||
+        exportFormatVersion !== MOBIUS_SESSION_EXPORT_FORMAT_VERSION) {
+        throw invalidResponse("The service returned unsupported Mobius API capabilities");
+    }
+    return new MobiusServiceCapabilities(apiVersion, 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", 2_048);
+        if (!/^msession_[A-Za-z0-9_-]{22}_[A-Za-z0-9_-]+_[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) {
@@ -354,4 +546,825 @@ export function decodeMobiusRuntimePairingStatus(value) {
     }
     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;
+    }
+}
+/** A Session returned by the listing endpoint, including its latest turn status. */
+export class MobiusSessionListing extends MobiusSession {
+    busyStatus;
+    constructor(session, busyStatus) {
+        super(session.agentId, session.createdAt, session.createdBy, session.defaultBinding, session.hasNativeHistory, session.lastCommittedSequence, session.policy, session.projectId, session.runtimeId, session.sessionId, session.state, session.title, session.updatedAt);
+        this.busyStatus = busyStatus;
+    }
+}
+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 function decodeMobiusSessionListing(value) {
+    const session = record(value, "Session");
+    return new MobiusSessionListing(decodeMobiusSession(session), busyStatusField(session, "busyStatus"));
+}
+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(decodeMobiusSessionListing), 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;
+    idempotencyKey;
+    request;
+    sessionId;
+    state;
+    turnId;
+    constructor(acceptedAt, bindingId, content, idempotencyKey, sessionId, sessionConfigurations, state, turnId, request = { content, kind: "prompt", sessionConfigurations }) {
+        this.acceptedAt = acceptedAt;
+        this.bindingId = bindingId;
+        this.idempotencyKey = idempotencyKey;
+        this.request = request;
+        this.sessionId = sessionId;
+        this.state = state;
+        this.turnId = turnId;
+    }
+    get content() {
+        return this.request.kind === "prompt" ? this.request.content : "";
+    }
+    get sessionConfigurations() {
+        return this.request.kind === "prompt" ? this.request.sessionConfigurations : [];
+    }
+}
+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.kind === "prompt" ? turn.request.content : "", turn.idempotencyKey, turn.sessionId, turn.request.kind === "prompt" ? turn.request.sessionConfigurations : [], state, turn.turnId, turn.request);
+}
+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", AGENT_ACTIVITY_DETAIL_LIMIT), 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", AGENT_ACTIVITY_DETAIL_LIMIT), integerField(activity, "sequence"), stringField(activity, "status", 64), stringField(activity, "title", 500), identifierField(activity, "toolCallId"), stringField(activity, "toolKind", 128));
+}
+/**
+ * A stored step whose recorded shape a later protocol revision can no longer decode must cost only that
+ * step. Failing the whole page would hide every other Turn in the Session, so an unreadable summary is
+ * dropped from the restored conversation instead.
+ */
+function decodeMobiusActivitySummaries(values) {
+    const activities = [];
+    for (const value of values) {
+        try {
+            activities.push(decodeMobiusActivitySummary(value));
+        }
+        catch {
+            // Skip the unreadable entry and keep the rest of the conversation.
+        }
+    }
+    return activities;
+}
+export class MobiusMessageContent {
+    activities;
+    additionalDirectoryIds;
+    attempt;
+    createdAt;
+    disposition;
+    images;
+    messageId;
+    prompt;
+    resources;
+    response;
+    constructor(activities, additionalDirectoryIds, attempt, createdAt, disposition, images, messageId, prompt, resources, response) {
+        this.activities = activities;
+        this.additionalDirectoryIds = additionalDirectoryIds;
+        this.attempt = attempt;
+        this.createdAt = createdAt;
+        this.disposition = disposition;
+        this.images = images;
+        this.messageId = messageId;
+        this.prompt = prompt;
+        this.resources = resources;
+        this.response = response;
+    }
+}
+export class MobiusMessage extends MobiusMessageContent {
+    agentId;
+    commandId;
+    contents;
+    sessionId;
+    targetCommandId;
+    turnId;
+    constructor(content, agentId, commandId, contents, sessionId, targetCommandId, turnId = "") {
+        super(content.activities, content.additionalDirectoryIds, content.attempt, content.createdAt, content.disposition, content.images, content.messageId, content.prompt, content.resources, content.response);
+        this.agentId = agentId;
+        this.commandId = commandId;
+        this.contents = contents;
+        this.sessionId = sessionId;
+        this.targetCommandId = targetCommandId;
+        this.turnId = turnId;
+    }
+}
+export function decodeMobiusMessageContent(message) {
+    return new MobiusMessageContent(decodeMobiusActivitySummaries(arrayField(message, "activities", 10_000)), arrayField(message, "additionalDirectoryIds", 100).map((directoryId) => {
+        if (typeof directoryId !== "string") {
+            throw invalidResponse("The service returned an invalid additional directory identifier");
+        }
+        return identifierField({ directoryId }, "directoryId");
+    }), decodeMobiusAttemptSummary(message["attempt"]), 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));
+}
+function decodeMobiusMessage(value) {
+    const message = record(value, "Session message");
+    return new MobiusMessage(decodeMobiusMessageContent(message), identifierField(message, "agentId"), identifierField(message, "commandId"), arrayField(message, "contents", 100).map(decodeAgentDisplayContentValue), identifierField(message, "sessionId"), stringField(message, "targetCommandId", 128), stringField(message, "turnId", 128));
+}
+export class MobiusMessagePage {
+    lastCommittedSequence;
+    messages;
+    nextCursor;
+    tailEventCursor;
+    constructor(lastCommittedSequence, messages, nextCursor, tailEventCursor) {
+        this.lastCommittedSequence = lastCommittedSequence;
+        this.messages = messages;
+        this.nextCursor = nextCursor;
+        this.tailEventCursor = tailEventCursor;
+    }
+}
+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");
+    }
+    const tailEventCursor = page["tailEventCursor"];
+    if (tailEventCursor !== undefined && (typeof tailEventCursor !== "string" || tailEventCursor.length > 512)) {
+        throw invalidResponse("The service returned an invalid tailEventCursor");
+    }
+    return new MobiusMessagePage(sequence, arrayField(page, "messages", 100).map(decodeMobiusMessage), nullableCursor(page, "nextCursor"), tailEventCursor ?? "");
+}
+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;
+    }
+}
+/** One increment of a streamed narration activity, before it is folded into a snapshot. */
+export class MobiusAgentActivityNarrationEvent extends MobiusRecordedEvent {
+    activityId;
+    activityType;
+    commandId;
+    kind = AGENT_ACTIVITY_NARRATION_KIND;
+    sequence;
+    text;
+    constructor(event) {
+        super(event.sessionId);
+        this.activityId = event.activityId;
+        this.activityType = event.activityType;
+        this.commandId = event.commandId;
+        this.sequence = event.sequence;
+        this.text = event.text;
+    }
+}
+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 AGENT_ACTIVITY_NARRATION_KIND:
+            return new MobiusAgentActivityNarrationEvent(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 payload = decodeRecordedEvent(event.payload);
+    return new MobiusSessionEvent("", "", payload, "", "", event.sessionId, new MobiusRuntimeEventSource(""));
+}
 //# sourceMappingURL=resources.js.map