@moxt-ai/mobius 0.0.292 → 0.0.294

package/dist/runtime.js

@@ -958,6 +958,16 @@ function normalizeAcpCapabilities(initialized) {
     unstableForkSession: session?.fork != null
   });
 }
+function restrictAcpSessionCapabilities(capabilities, response) {
+  if (!isRecord(response) || !isRecord(response["_meta"])) {
+    return capabilities;
+  }
+  const steering = response["_meta"]["steering"];
+  if (!isRecord(steering) || steering["supported"] !== false) {
+    return capabilities;
+  }
+  return Object.freeze({ ...capabilities, steering: false });
+}
 
 // src/acp/agent/agent-definition.ts
 var AgentDefinition = class {
@@ -22572,7 +22582,7 @@ import { fetch as fetch3 } from "undici";
 // package.json
 var package_default = {
   name: "@moxt-ai/mobius",
-  version: "0.0.292",
+  version: "0.0.294",
   description: "Mobius CLI for pairing and running local AI agent services.",
   type: "module",
   bin: {
@@ -67317,6 +67327,7 @@ var queuePageSchema = external_exports.object({
   nextCursor: external_exports.string().nullish()
 });
 var CodexBorrowedAcpAgent = class {
+  steeringSupported = false;
   #client;
   #threadId;
   #emit;
@@ -67538,7 +67549,7 @@ var CodexBorrowedAcpAgent = class {
   nativeTurnId = () => null;
   steer = async (_params, signal) => {
     signal.throwIfAborted();
-    return { outcome: "promptRequired", reason: "noRunningTurn" };
+    throw new AcpExecutionError("This Codex session only supports queued input", {}, "steering_unsupported");
   };
   // The reader connection cannot receive or control the owner's live turn.
   onNotification = async (_method, _params) => {
@@ -67678,6 +67689,7 @@ function userInputSchema(questions) {
   return { properties, required: required2, type: "object" };
 }
 var CodexOwnedAcpAgent = class {
+  steeringSupported = true;
   #context;
   #appServer;
   #settings;
@@ -68729,7 +68741,10 @@ var CodexAcpAgent = class {
       await this.#resume(context.params.sessionId, context.params.cwd, context.signal);
       await this.#replaySavedHistory(context.signal);
       this.#advertiseCompactCommand();
-      return { configOptions: this.#settings.configOptions() };
+      return {
+        _meta: { steering: { supported: this.#sessionAgent.steeringSupported } },
+        configOptions: this.#settings.configOptions()
+      };
     }).onRequest(methods3.agent.session.fork, async (context) => {
       const forked = threadForkResponseSchema.parse(
         await this.#appServer.request(
@@ -68752,7 +68767,10 @@ var CodexAcpAgent = class {
     }).onRequest(methods3.agent.session.resume, async (context) => {
       await this.#resume(context.params.sessionId, context.params.cwd, context.signal);
       this.#advertiseCompactCommand();
-      return { configOptions: this.#settings.configOptions() };
+      return {
+        _meta: { steering: { supported: this.#sessionAgent.steeringSupported } },
+        configOptions: this.#settings.configOptions()
+      };
     }).onRequest(methods3.agent.session.prompt, async (context) => {
       if (isCompactCommand(context.params.prompt)) {
         return await this.#sessionAgent.compact(context.signal);
@@ -83630,6 +83648,7 @@ async function restoreSession(session, signal, recovery, origin) {
     session.setNativeHistoryOwnership({ kind: "fresh-session" });
     lifecycleResponse2 = created;
   }
+  session.restrictSessionCapabilities(lifecycleResponse2);
   session.setConfigOptions(session.sessionConfigProtocol.normalizeLifecycle(lifecycleResponse2));
   if (stored instanceof FoundStoredSession && session.restored) {
     await session.restoreStoredConfigurations(stored.session, signal);
@@ -83882,6 +83901,9 @@ var AgentSession = class _AgentSession {
       signal
     );
   };
+  restrictSessionCapabilities = (response) => {
+    this.#capabilities = restrictAcpSessionCapabilities(this.#capabilities, response);
+  };
   prepared = () => new PreparedSession(
     this.#agentName,
     this.#agentVersion,
@@ -83955,6 +83977,7 @@ var AgentSession = class _AgentSession {
         );
         await this.#updates.drained();
         signal.throwIfAborted();
+        this.restrictSessionCapabilities(response);
         const loaded = { history, kind: "loaded", response };
         this.#sessionLoad = loaded;
         return loaded;
@@ -86536,6 +86559,50 @@ var ExecutionReceipts = class {
   };
 };
 
+// src/session/turn/runtime-turn-activity.ts
+var RuntimeTurnActivity = class {
+  #turns = /* @__PURE__ */ new Set();
+  #admission = { kind: "open" };
+  acceptsPrompts = () => this.#admission.kind !== "reserved";
+  count = () => this.#turns.size;
+  start = (turn) => {
+    this.#turns.add(turn);
+  };
+  finish = (turn) => {
+    this.#turns.delete(turn);
+    if (this.#turns.size === 0 && this.#admission.kind === "waiting") {
+      this.#admission.reserve();
+    }
+  };
+  reserveWhenIdle = (signal) => {
+    signal.throwIfAborted();
+    if (this.#admission.kind !== "open") {
+      throw new Error("A daemon upgrade already owns admission");
+    }
+    return new Promise((resolve18, reject2) => {
+      const abort = () => {
+        this.#admission = { kind: "open" };
+        signal.removeEventListener("abort", abort);
+        reject2(signal.reason);
+      };
+      const reserve = () => {
+        this.#admission = { kind: "reserved" };
+        signal.removeEventListener("abort", abort);
+        resolve18({
+          [Symbol.dispose]: () => {
+            this.#admission = { kind: "open" };
+          }
+        });
+      };
+      this.#admission = { kind: "waiting", reserve };
+      signal.addEventListener("abort", abort, { once: true });
+      if (this.#turns.size === 0) {
+        reserve();
+      }
+    });
+  };
+};
+
 // src/session/turn/active-turn.ts
 import { randomUUID as randomUUID14 } from "node:crypto";
 var ActiveRuntimeTurn = class {
@@ -86752,9 +86819,12 @@ var SessionExecutionState = class {
 var SessionTurns = class {
   #bySessionId = /* @__PURE__ */ new Map();
   #operations;
-  constructor(operations) {
+  #activity;
+  constructor(operations, activity2 = new RuntimeTurnActivity()) {
     this.#operations = operations;
+    this.#activity = activity2;
   }
+  acceptsPrompts = () => this.#activity.acceptsPrompts();
   session = (sessionId) => {
     let session = this.#bySessionId.get(sessionId);
     if (session === void 0) {
@@ -86764,10 +86834,15 @@ var SessionTurns = class {
     return session;
   };
   get = (commandId, sessionId) => this.#bySessionId.get(sessionId)?.get(commandId);
-  start = (command, attemptId) => this.session(command.sessionId).start(command, attemptId);
+  start = (command, attemptId) => {
+    const turn = this.session(command.sessionId).start(command, attemptId);
+    this.#activity.start(turn);
+    return turn;
+  };
   finish = (turn) => {
     this.#bySessionId.get(turn.command.sessionId)?.finish(turn);
     this.sweep();
+    this.#activity.finish(turn);
   };
   recordEvent = (event) => "sessionId" in event ? this.#bySessionId.get(event.sessionId)?.recordEvent(event) ?? event : event;
   recordSessionEvent = (event) => {
@@ -87009,7 +87084,7 @@ function buildSessionLayer(options) {
   const sessionStore = new SqliteSessionStore(new AcpSessionTable(sessionDatabase), events);
   const externalContent = new LocalExternalContentStore(stateDirectory);
   const operations = new ExecutionReceipts();
-  const activeSessions = new SessionTurns(operations);
+  const activeSessions = new SessionTurns(operations, options.turnActivity);
   const directories = new WorkspaceDirectoryService(bindingId, defaultWorkspace);
   const manager = new SessionManager2({
     observer: new SessionLayerObserver((event) => eventProjection.record(event), sink.publishInfo),
@@ -89070,6 +89145,16 @@ var sessionPromptCommand = {
     if (message.kind !== SESSION_PROMPT_KIND) {
       throw new Error("Command kind mismatch");
     }
+    if (!context.sessionTurns.acceptsPrompts()) {
+      send(context.socket, {
+        code: "runtime_upgrading",
+        requestId: message.commandId,
+        kind: "session.operation.failed",
+        message: "The Runtime is upgrading. Retry after it reconnects.",
+        sessionId: message.sessionId
+      });
+      return;
+    }
     const receipt = context.operations.claimExecution(
       message.commandId,
       message.sessionId,
@@ -89875,6 +89960,7 @@ async function runRelayConnection({
         reject2(failure2);
       };
       const stop = () => {
+        publisher.flush();
         diagnostics.connectionClosed(connectionEpoch, 1e3, "Daemon stopped", "daemon_stop");
         closeRelaySocket(socket, 1e3, "Daemon stopped");
         resolveConnection();
@@ -90030,6 +90116,11 @@ var RuntimeSessionEventPublisher = class {
     this.#socket = null;
     this.dropPendingEvents();
   };
+  flush = () => {
+    if (this.#socket !== null) {
+      this.flushEvents(this.#socket);
+    }
+  };
   publishOperationFailure = (sessionId, requestId, code, message) => {
     this.#send({ kind: "session.operation.failed", sessionId, requestId, code, message });
   };
@@ -90163,6 +90254,7 @@ async function runRuntime(config2, parentSignal, timer = systemTimer, options =
   );
   const publisher = new RuntimeSessionEventPublisher(timer);
   const layer = buildSessionLayer({
+    ...options.turnActivity === void 0 ? {} : { turnActivity: options.turnActivity },
     bindingId: config2.bindingId,
     channelId: config2.channelId,
     defaultWorkspace: config2.defaultWorkspace,
@@ -90406,6 +90498,7 @@ var MobiusRuntimeEngine = class {
     this.#state = new RunningMobiusRuntimeState();
     try {
       await runRuntime(this.#config, signal, void 0, {
+        ...this.#options.turnActivity === void 0 ? {} : { turnActivity: this.#options.turnActivity },
         ...this.#options.onConnectionStatus === void 0 ? {} : { onConnectionStatus: this.#options.onConnectionStatus },
         ...this.#options.reportUpgradeAvailability === void 0 ? {} : { reportUpgradeAvailability: this.#options.reportUpgradeAvailability },
         ...this.#options.processLogsDirectory === void 0 ? {} : { processLogsDirectory: this.#options.processLogsDirectory }