@moxt-ai/mobius 0.0.154 → 0.0.155

package/dist/daemon-turn-registry.d.ts

@@ -20,19 +20,6 @@ export declare class DaemonTurnRegistry {
             epoch: string;
             hasOlder: boolean;
             interaction: Readonly<{
-                commandId: string;
-                interactionId: string;
-                kind: "session.permission.requested";
-                options: readonly Readonly<{
-                    kind: "allow_always" | "allow_once" | "reject_always" | "reject_once";
-                    name: string;
-                    optionId: string;
-                }>[];
-                sessionId: string;
-                title: string;
-                toolCallId: string;
-                toolKind: string;
-            }> | Readonly<{
                 accepted: boolean;
                 commandId: string;
                 elicitationId: string;
@@ -64,6 +51,19 @@ export declare class DaemonTurnRegistry {
                 mode: "form" | "url";
                 sessionId: string;
                 url: string;
+            }> | Readonly<{
+                commandId: string;
+                interactionId: string;
+                kind: "session.permission.requested";
+                options: readonly Readonly<{
+                    kind: "allow_always" | "allow_once" | "reject_always" | "reject_once";
+                    name: string;
+                    optionId: string;
+                }>[];
+                sessionId: string;
+                title: string;
+                toolCallId: string;
+                toolKind: string;
             }> | null;
             messages: readonly (Readonly<{
                 id: string;

package/dist/index.js

@@ -20767,16 +20767,8 @@ function decodeSessionQueuedEvent(encoded) {
 function decodeRuntimeLivenessReadyEvent(encoded) {
   const value = parseJson2(encoded);
   assertKind(value, RUNTIME_LIVENESS_READY_KIND);
-  if (value["sessionEventDelivery"] === void 0) {
-    assertExactKeys(value, ["kind"]);
-    return { kind: RUNTIME_LIVENESS_READY_KIND };
-  }
-  assertExactKeys(value, ["kind", "sessionEventDelivery"]);
-  const sessionEventDelivery = readString(value, "sessionEventDelivery", 32);
-  if (sessionEventDelivery !== "reliable-v1") {
-    throw new ProtocolMessageError("Unsupported Session event delivery mode");
-  }
-  return { kind: RUNTIME_LIVENESS_READY_KIND, sessionEventDelivery };
+  assertExactKeys(value, ["kind"]);
+  return { kind: RUNTIME_LIVENESS_READY_KIND };
 }
 function decodeRuntimeHeartbeatEvent(encoded) {
   const value = parseJson2(encoded);
@@ -21243,60 +21235,13 @@ var encodeNativeSessionCancel = (value) => JSON.stringify(nativeSessionCancelSch
 
 // ../protocol/src/session-events.ts
 var SESSION_EVENT_KIND = "session.event";
-var SESSION_EVENT_ACK_KIND = "session.event.ack";
-var SESSION_EVENT_DEFERRED_KIND = "session.event.deferred";
-var SESSION_EVENT_REJECTED_KIND = "session.event.rejected";
 var SESSION_FORKED_KIND = "session.forked";
-var SessionEventRejectionCode = {
-  IdempotencyConflict: "idempotency_conflict",
-  InvalidEvent: "invalid_event",
-  RecordingRejected: "recording_rejected"
-};
 var MAX_RECORDED_EVENT_LENGTH = 8 * 1024 * 1024;
-var ephemeralEventEnvelopeSchema = external_exports.strictObject({
-  kind: external_exports.literal(SESSION_EVENT_KIND),
-  payload: external_exports.string().min(2).max(MAX_RECORDED_EVENT_LENGTH),
-  sessionId: identifierStringSchema
-}).readonly();
-var reliableDeliverySchema = external_exports.strictObject({
-  eventId: identifierStringSchema,
-  kind: external_exports.literal("reliable"),
-  sourceSeq: external_exports.string().regex(/^(?:0|[1-9][0-9]*)$/u).max(40),
-  streamId: identifierStringSchema
-}).readonly();
-var reliableSessionEventEnvelopeSchema = external_exports.strictObject({
-  delivery: reliableDeliverySchema,
+var sessionEventEnvelopeSchema = external_exports.strictObject({
   kind: external_exports.literal(SESSION_EVENT_KIND),
   payload: external_exports.string().min(2).max(MAX_RECORDED_EVENT_LENGTH),
   sessionId: identifierStringSchema
 }).readonly();
-var eventEnvelopeSchema = external_exports.union([ephemeralEventEnvelopeSchema, reliableSessionEventEnvelopeSchema]).readonly();
-var acknowledgementOutcomeSchema = external_exports.discriminatedUnion("kind", [
-  external_exports.strictObject({ kind: external_exports.literal("relayed") }).readonly(),
-  external_exports.strictObject({
-    kind: external_exports.literal("recorded"),
-    providerId: identifierStringSchema,
-    recordingEpoch: identifierStringSchema
-  }).readonly()
-]);
-var eventAcknowledgementSchema = external_exports.strictObject({
-  eventId: identifierStringSchema,
-  kind: external_exports.literal(SESSION_EVENT_ACK_KIND),
-  outcome: acknowledgementOutcomeSchema,
-  sessionId: identifierStringSchema
-}).readonly();
-var eventDeferredSchema = external_exports.strictObject({
-  eventId: identifierStringSchema,
-  kind: external_exports.literal(SESSION_EVENT_DEFERRED_KIND),
-  retryAfterMilliseconds: external_exports.number().int().min(100).max(6e4),
-  sessionId: identifierStringSchema
-}).readonly();
-var eventRejectedSchema = external_exports.strictObject({
-  code: external_exports.enum(SessionEventRejectionCode),
-  eventId: identifierStringSchema,
-  kind: external_exports.literal(SESSION_EVENT_REJECTED_KIND),
-  sessionId: identifierStringSchema
-}).readonly();
 var SESSION_QUEUE_CHANGED_KIND = "session.queue.changed";
 var sessionQueueChangedSchema = external_exports.strictObject({ kind: external_exports.literal(SESSION_QUEUE_CHANGED_KIND), sessionId: identifierStringSchema }).readonly();
 var sessionForkedSchema = external_exports.strictObject({
@@ -21329,14 +21274,8 @@ var encode4 = (message, schema) => {
   }
   return JSON.stringify(decoded.data);
 };
-var decodeSessionEventEnvelope = (encoded) => decode5(encoded, eventEnvelopeSchema);
-var encodeSessionEventEnvelope = (message) => encode4(message, eventEnvelopeSchema);
-var decodeSessionEventAcknowledgement = (encoded) => decode5(encoded, eventAcknowledgementSchema);
-var encodeSessionEventAcknowledgement = (message) => encode4(message, eventAcknowledgementSchema);
-var decodeSessionEventDeferred = (encoded) => decode5(encoded, eventDeferredSchema);
-var encodeSessionEventDeferred = (message) => encode4(message, eventDeferredSchema);
-var decodeSessionEventRejected = (encoded) => decode5(encoded, eventRejectedSchema);
-var encodeSessionEventRejected = (message) => encode4(message, eventRejectedSchema);
+var decodeSessionEventEnvelope = (encoded) => decode5(encoded, sessionEventEnvelopeSchema);
+var encodeSessionEventEnvelope = (message) => encode4(message, sessionEventEnvelopeSchema);
 function decodeRecordedSessionEvent(encoded) {
   const kind = decodeMessageKind(encoded);
   switch (kind) {
@@ -21510,21 +21449,6 @@ var serviceToDaemonSignatures = {
     encodeSessionElicitationRespondCommand,
     decodeSessionElicitationRespondCommand
   ),
-  [SESSION_EVENT_ACK_KIND]: defineMessageSignature(
-    SESSION_EVENT_ACK_KIND,
-    encodeSessionEventAcknowledgement,
-    decodeSessionEventAcknowledgement
-  ),
-  [SESSION_EVENT_DEFERRED_KIND]: defineMessageSignature(
-    SESSION_EVENT_DEFERRED_KIND,
-    encodeSessionEventDeferred,
-    decodeSessionEventDeferred
-  ),
-  [SESSION_EVENT_REJECTED_KIND]: defineMessageSignature(
-    SESSION_EVENT_REJECTED_KIND,
-    encodeSessionEventRejected,
-    decodeSessionEventRejected
-  ),
   [SESSION_LIVE_HISTORY_LOAD_KIND]: defineMessageSignature(
     SESSION_LIVE_HISTORY_LOAD_KIND,
     encodeSessionLiveHistoryLoad,
@@ -37660,7 +37584,7 @@ function isRuntimeRelayRevocation(closeCode, closeReason) {
 }
 
 // src/run-daemon.ts
-import { createHash as createHash6, randomUUID as randomUUID8 } from "node:crypto";
+import { createHash as createHash6, randomUUID as randomUUID7 } from "node:crypto";
 import { join as join18 } from "node:path";
 import { styleText } from "node:util";
 
@@ -43337,7 +43261,6 @@ async function runRelayConnection({
 }) {
   const relayUrl = new URL(config2.relayUrl);
   relayUrl.searchParams.set("liveness", "1");
-  relayUrl.searchParams.set("sessionEventDelivery", "reliable-v1");
   const socket = await connectRelay(relayUrl, signal);
   diagnostics.connectionOpened(connectionEpoch);
   const connectionController = new AbortController();
@@ -43457,10 +43380,7 @@ async function runRelayConnection({
           const message = decodeServiceToDaemonMessage(encoded);
           const kind = message.kind;
           if (kind === RUNTIME_LIVENESS_READY_KIND) {
-            publisher.connect(
-              socket,
-              message.sessionEventDelivery === "reliable-v1" ? "reliable" : "ephemeral"
-            );
+            publisher.connect(socket);
             connectionLiveness.start();
             return;
           }
@@ -43468,18 +43388,6 @@ async function runRelayConnection({
             connectionLiveness.acknowledge(message);
             return;
           }
-          if (kind === SESSION_EVENT_ACK_KIND) {
-            publisher.acknowledge(message);
-            return;
-          }
-          if (kind === SESSION_EVENT_DEFERRED_KIND) {
-            publisher.defer(message);
-            return;
-          }
-          if (kind === SESSION_EVENT_REJECTED_KIND) {
-            publisher.reject(message);
-            return;
-          }
           commands.handle(message);
         } catch (error62) {
           console.error("Mobius daemon rejected a message", error62);
@@ -43506,233 +43414,42 @@ async function runRelayConnection({
 
 // src/relay-connection/session-event-publisher.ts
 import { WebSocket as WebSocket9 } from "undici";
-
-// src/relay-connection/session-event-queue.ts
-import { randomUUID as randomUUID7 } from "node:crypto";
-var STANDARD_EVENT_BYTES = 96 * 1024 * 1024;
-var CRITICAL_EVENT_BYTES = 128 * 1024 * 1024;
-var SessionEventQueueCapacityError = class extends Error {
-  code = "session_event_queue_full";
-  constructor() {
-    super("The in-memory Session event queue is full");
-    this.name = "SessionEventQueueCapacityError";
-  }
-};
-var SessionEventQueue = class {
-  #streamId = randomUUID7();
-  #events = /* @__PURE__ */ new Map();
-  #nextSourceSeq = 1;
-  #totalBytes = 0;
-  enqueueBatch = (sessionId, payloads, critical) => {
-    if (payloads.length < 1 || payloads.length > 32) {
-      throw new Error("A Session event batch must contain between 1 and 32 events");
-    }
-    if (!Number.isSafeInteger(this.#nextSourceSeq + payloads.length)) {
-      throw new Error("The Session event source sequence is exhausted");
-    }
-    const entries = payloads.map((payload, index) => {
-      const envelope2 = {
-        delivery: {
-          eventId: randomUUID7(),
-          kind: "reliable",
-          sourceSeq: (this.#nextSourceSeq + index).toString(),
-          streamId: this.#streamId
-        },
-        kind: SESSION_EVENT_KIND,
-        payload,
-        sessionId
-      };
-      return { envelope: envelope2, byteLength: Buffer.byteLength(encodeSessionEventEnvelope(envelope2), "utf8") };
-    });
-    const byteLength = entries.reduce((total, entry) => total + entry.byteLength, 0);
-    if (this.#totalBytes + byteLength > (critical ? CRITICAL_EVENT_BYTES : STANDARD_EVENT_BYTES)) {
-      throw new SessionEventQueueCapacityError();
-    }
-    for (const entry of entries) {
-      this.#events.set(entry.envelope.delivery.eventId, entry);
-    }
-    this.#nextSourceSeq += entries.length;
-    this.#totalBytes += byteLength;
-  };
-  pending = (limit, excludedEventIds) => {
-    const result = [];
-    for (const [eventId, entry] of this.#events) {
-      if (!excludedEventIds.has(eventId)) {
-        result.push(entry.envelope);
-        if (result.length === limit) {
-          break;
-        }
-      }
-    }
-    return result;
-  };
-  remove = (eventId, sessionId) => {
-    const entry = this.#events.get(eventId);
-    if (entry === void 0 || entry.envelope.sessionId !== sessionId) {
-      return false;
-    }
-    this.#events.delete(eventId);
-    this.#totalBytes -= entry.byteLength;
-    return true;
-  };
-  clear = () => {
-    this.#events.clear();
-    this.#totalBytes = 0;
-  };
-};
-
-// src/relay-connection/session-event-publisher.ts
-var SESSION_EVENT_REPLAY_WINDOW = 16;
-var SESSION_EVENT_REPLAY_BYTE_LIMIT = 32 * 1024 * 1024;
-function reservesSessionEventCapacity(event) {
-  if (event.kind === SESSION_COMPLETED_KIND || event.kind === SESSION_FAILED_KIND || event.kind === SESSION_FORKED_KIND || event.kind === SESSION_READY_KIND) {
-    return true;
-  }
-  return event.kind === AGENT_ACTIVITY_KIND && (event.activityType === "progress" || event.activityType === "reasoning") && (event.status === "completed" || event.status === "failed");
-}
+var MAX_BUFFERED_BYTES = 32 * 1024 * 1024;
 var DaemonSessionEventPublisher = class {
-  #inFlight = /* @__PURE__ */ new Map();
-  #queue = new SessionEventQueue();
-  #reportedCapacityKinds = /* @__PURE__ */ new Set();
-  #timer;
-  #connection = { kind: "disconnected" };
-  #deferredReplay = null;
-  #inFlightBytes = 0;
-  constructor(timer) {
-    this.#timer = timer;
-  }
-  acknowledge = (acknowledgement) => {
-    if (!this.#queue.remove(acknowledgement.eventId, acknowledgement.sessionId)) {
-      return;
-    }
-    this.#removeInFlight(acknowledgement.eventId);
-    this.#publishNextBatch();
-  };
-  close = () => {
-    this.#deferredReplay?.cancel();
-    this.#deferredReplay = null;
-    this.#connection = { kind: "disconnected" };
-    this.#clearInFlight();
-    this.#queue.clear();
-  };
-  connect = (socket, delivery) => {
-    this.#connection = { delivery, kind: "connected", socket };
-    this.#clearInFlight();
-    this.#publishNextBatch();
-  };
-  defer = (deferred) => {
-    if (!this.#inFlight.has(deferred.eventId)) {
-      return;
-    }
-    this.#clearInFlight();
-    if (this.#deferredReplay !== null) {
-      return;
-    }
-    this.#deferredReplay = this.#timer.schedule(() => {
-      this.#deferredReplay = null;
-      this.#publishNextBatch();
-    }, deferred.retryAfterMilliseconds);
+  #socket = null;
+  connect = (socket) => {
+    this.#socket = socket;
   };
   disconnect = (socket) => {
-    if (this.#connection.kind !== "connected" || this.#connection.socket !== socket) {
-      return;
-    }
-    this.#connection = { kind: "disconnected" };
-    this.#clearInFlight();
-  };
-  publish = (sessionId, event) => {
-    try {
-      this.#queue.enqueueBatch(
-        sessionId,
-        [encodeRecordedSessionEvent(event)],
-        reservesSessionEventCapacity(event)
-      );
-    } catch (error62) {
-      if (!(error62 instanceof SessionEventQueueCapacityError)) {
-        throw error62;
-      }
-      if (!this.#reportedCapacityKinds.has(event.kind)) {
-        this.#reportedCapacityKinds.add(event.kind);
-        console.warn(`Mobius daemon could not buffer "${event.kind}" because the Session event queue is full`);
-      }
-      return;
-    }
-    this.#publishNextBatch();
-  };
-  publishBatch = (sessionId, events) => {
-    const critical = events.some(reservesSessionEventCapacity);
-    this.#queue.enqueueBatch(sessionId, events.map(encodeRecordedSessionEvent), critical);
-    this.#publishNextBatch();
-  };
-  reject = (rejection) => {
-    if (!this.#queue.remove(rejection.eventId, rejection.sessionId)) {
-      return;
+    if (this.#socket === socket) {
+      this.#socket = null;
     }
-    this.#removeInFlight(rejection.eventId);
-    console.error(`Mobius Relay rejected Session event ${rejection.eventId} with code ${rejection.code}`);
-    this.#publishNextBatch();
   };
-  #clearInFlight = () => {
-    this.#inFlight.clear();
-    this.#inFlightBytes = 0;
+  close = () => {
+    this.#socket = null;
   };
-  #publishNextBatch = () => {
-    if (this.#deferredReplay !== null || this.#connection.kind !== "connected") {
+  publish = (sessionId, event) => {
+    const socket = this.#socket;
+    if (socket === null || socket.readyState !== WebSocket9.OPEN) {
       return;
     }
-    while (this.#inFlight.size < SESSION_EVENT_REPLAY_WINDOW) {
-      const batch = this.#queue.pending(
-        SESSION_EVENT_REPLAY_WINDOW - this.#inFlight.size,
-        new Set(this.#inFlight.keys())
-      );
-      let sent = 0;
-      for (const envelope2 of batch) {
-        const encoded = encodeDaemonToServiceMessage(
-          this.#connection.delivery === "reliable" ? envelope2 : {
-            kind: envelope2.kind,
-            payload: envelope2.payload,
-            sessionId: envelope2.sessionId
-          }
-        );
-        const byteLength = Buffer.byteLength(encoded, "utf8");
-        if (this.#inFlightBytes + byteLength > SESSION_EVENT_REPLAY_BYTE_LIMIT) {
-          return;
-        }
-        if (!this.#send(encoded)) {
-          this.#clearInFlight();
-          return;
-        }
-        if (this.#connection.delivery === "ephemeral") {
-          this.#queue.remove(envelope2.delivery.eventId, envelope2.sessionId);
-          sent += 1;
-          continue;
-        }
-        this.#inFlight.set(envelope2.delivery.eventId, { byteLength });
-        this.#inFlightBytes += byteLength;
-        sent += 1;
-      }
-      if (sent === 0) {
-        return;
-      }
-    }
-  };
-  #removeInFlight = (eventId) => {
-    const inFlight = this.#inFlight.get(eventId);
-    if (inFlight === void 0) {
+    const encoded = encodeDaemonToServiceMessage({
+      kind: SESSION_EVENT_KIND,
+      payload: encodeRecordedSessionEvent(event),
+      sessionId
+    });
+    if (socket.bufferedAmount + Buffer.byteLength(encoded, "utf8") > MAX_BUFFERED_BYTES) {
+      socket.close(1013, "Live event transport overloaded");
       return;
     }
-    this.#inFlight.delete(eventId);
-    this.#inFlightBytes -= inFlight.byteLength;
-  };
-  #send = (encoded) => {
-    if (this.#connection.kind !== "connected" || this.#connection.socket.readyState !== WebSocket9.OPEN) {
-      return false;
-    }
     try {
-      this.#connection.socket.send(encoded);
-      return true;
+      socket.send(encoded);
     } catch {
-      return false;
+    }
+  };
+  publishBatch = (sessionId, events) => {
+    for (const event of events) {
+      this.publish(sessionId, event);
     }
   };
 };
@@ -43794,7 +43511,7 @@ async function installDetectedAgentIntegrations(config2, installations, signal)
       {
         agentId: agent.id,
         kind: AGENT_INSTALL_REQUEST_KIND,
-        requestId: `automatic-integration-${randomUUID8()}`
+        requestId: `automatic-integration-${randomUUID7()}`
       },
       signal
     );
@@ -43816,7 +43533,7 @@ async function runDaemon(config2, audit, signal, timer = systemDaemonTimer, opti
     join18(stateDirectory, "sessions", `${createHash6("sha256").update(config2.channelId).digest("hex")}.sqlite`)
   );
   const operations = new DaemonOperationState();
-  const publisher = new DaemonSessionEventPublisher(timer);
+  const publisher = new DaemonSessionEventPublisher();
   const activeTurns = new DaemonTurnRegistry(operations);
   const recordSessionEvent = (sessionId, event) => {
     publisher.publish(sessionId, activeTurns.recordEvent(event));