@morty-build/cli 0.4.26 → 0.4.27

package/dist/{chunk-VKVKHAQ7.js → chunk-MLX3QFGN.js}

@@ -3,7 +3,7 @@ import {
   __export,
   __using,
   package_default
-} from "./chunk-P2Q7CY6D.js";
+} from "./chunk-GWFNC4EE.js";
 
 // src/engine/runtime/relay/runtime-revocation.ts
 var runtimeRevocationCloseCode = 1008;
@@ -20402,6 +20402,7 @@ var SESSION_PERMISSION_RESOLVED_KIND = "session.permission.resolved";
 var SESSION_ELICITATION_REQUESTED_KIND = "session.elicitation.requested";
 var SESSION_ELICITATION_RESPOND_KIND = "session.elicitation.respond";
 var SESSION_ELICITATION_RESOLVED_KIND = "session.elicitation.resolved";
+var SESSION_INTERACTION_ANSWERED_KIND = "session.interaction.answered";
 var permissionOptionSchema = external_exports.object({
   kind: external_exports.enum(["allow_once", "allow_always", "reject_once", "reject_always"]),
   name: external_exports.string().min(1).max(255),
@@ -20451,6 +20452,7 @@ var sessionPermissionRespondCommandSchema = external_exports.object({
   kind: external_exports.literal(SESSION_PERMISSION_RESPOND_KIND),
   optionId: external_exports.string().max(255),
   outcome: external_exports.enum(["cancelled", "selected"]),
+  requestId: identifierStringSchema,
   sessionId: identifierStringSchema
 }).readonly();
 var sessionPermissionResolvedEventSchema = external_exports.object({
@@ -20477,6 +20479,7 @@ var sessionElicitationRespondCommandSchema = external_exports.object({
   content: external_exports.string().max(1e5),
   interactionId: identifierStringSchema,
   kind: external_exports.literal(SESSION_ELICITATION_RESPOND_KIND),
+  requestId: identifierStringSchema,
   sessionId: identifierStringSchema
 }).readonly();
 var sessionElicitationResolvedEventSchema = external_exports.object({
@@ -20485,10 +20488,18 @@ var sessionElicitationResolvedEventSchema = external_exports.object({
   kind: external_exports.literal(SESSION_ELICITATION_RESOLVED_KIND),
   sessionId: identifierStringSchema
 }).readonly();
+var sessionInteractionAnsweredEventSchema = external_exports.object({
+  interactionId: identifierStringSchema,
+  kind: external_exports.literal(SESSION_INTERACTION_ANSWERED_KIND),
+  requestId: identifierStringSchema,
+  sessionId: identifierStringSchema
+}).readonly();
 var decodeSessionPermissionRespondCommand = (encoded) => decodeZodMessage(encoded, sessionPermissionRespondCommandSchema);
 var encodeSessionPermissionRespondCommand = (message) => encodeZodMessage(message, sessionPermissionRespondCommandSchema);
 var decodeSessionElicitationRespondCommand = (encoded) => decodeZodMessage(encoded, sessionElicitationRespondCommandSchema);
 var encodeSessionElicitationRespondCommand = (message) => encodeZodMessage(message, sessionElicitationRespondCommandSchema);
+var decodeSessionInteractionAnsweredEvent = (encoded) => decodeZodMessage(encoded, sessionInteractionAnsweredEventSchema);
+var encodeSessionInteractionAnsweredEvent = (message) => encodeZodMessage(message, sessionInteractionAnsweredEventSchema);
 
 // ../client/src/protocol/session/events/index.ts
 var MAX_EVENT_COUNT = 1e4;
@@ -21316,6 +21327,9 @@ var SESSION_PROMPT_KIND = "session.prompt";
 var SESSION_PROMPT_DISPOSITION_KIND = "session.prompt.disposition";
 var SESSION_CANCEL_KIND = "session.cancel";
 var SESSION_CANCEL_BEFORE_START_KIND = "session.cancel-before-start";
+var SESSION_PROMPT_STEERED_KIND = "session.prompt.steered";
+var SESSION_TURN_STOPPED_KIND = "session.turn.stopped";
+var SESSION_TURN_WITHDRAWN_KIND = "session.turn.withdrawn";
 var SessionPromptDisposition = Object.freeze({
   Append: "append",
   Steer: "steer"
@@ -21332,6 +21346,7 @@ function decodeSessionCancelBeforeStartCommand(encoded) {
   return {
     commandId: readIdentifier(value, "commandId"),
     kind: SESSION_CANCEL_BEFORE_START_KIND,
+    requestId: readIdentifier(value, "requestId"),
     sessionId: readIdentifier(value, "sessionId")
   };
 }
@@ -21407,6 +21422,7 @@ function decodeSessionCancelCommand(encoded) {
   return {
     commandId: readIdentifier(value, "commandId"),
     kind: SESSION_CANCEL_KIND,
+    requestId: readIdentifier(value, "requestId"),
     sessionId: readIdentifier(value, "sessionId")
   };
 }
@@ -21420,6 +21436,7 @@ function decodeSessionPromptDispositionCommand(encoded) {
     commandId: readIdentifier(value, "commandId"),
     disposition: SessionPromptDisposition.Steer,
     kind: SESSION_PROMPT_DISPOSITION_KIND,
+    requestId: readIdentifier(value, "requestId"),
     sessionId: readIdentifier(value, "sessionId")
   };
 }
@@ -21432,6 +21449,20 @@ function encodeSessionCancelCommand(message) {
 function encodeSessionPromptDispositionCommand(message) {
   return JSON.stringify(decodeSessionPromptDispositionCommand(JSON.stringify(message)));
 }
+var turnReplyFields = {
+  commandId: identifierStringSchema,
+  requestId: identifierStringSchema,
+  sessionId: identifierStringSchema
+};
+var sessionPromptSteeredEventSchema = external_exports.object({ ...turnReplyFields, kind: external_exports.literal(SESSION_PROMPT_STEERED_KIND) }).readonly();
+var sessionTurnStoppedEventSchema = external_exports.object({ ...turnReplyFields, kind: external_exports.literal(SESSION_TURN_STOPPED_KIND), stopReason: external_exports.string().min(1).max(128) }).readonly();
+var sessionTurnWithdrawnEventSchema = external_exports.object({ ...turnReplyFields, kind: external_exports.literal(SESSION_TURN_WITHDRAWN_KIND) }).readonly();
+var decodeSessionPromptSteeredEvent = (encoded) => decodeZodMessage(encoded, sessionPromptSteeredEventSchema);
+var encodeSessionPromptSteeredEvent = (message) => encodeZodMessage(message, sessionPromptSteeredEventSchema);
+var decodeSessionTurnStoppedEvent = (encoded) => decodeZodMessage(encoded, sessionTurnStoppedEventSchema);
+var encodeSessionTurnStoppedEvent = (message) => encodeZodMessage(message, sessionTurnStoppedEventSchema);
+var decodeSessionTurnWithdrawnEvent = (encoded) => decodeZodMessage(encoded, sessionTurnWithdrawnEventSchema);
+var encodeSessionTurnWithdrawnEvent = (message) => encodeZodMessage(message, sessionTurnWithdrawnEventSchema);
 
 // ../client/src/protocol/session/native/index.ts
 var NATIVE_SESSION_REQUEST_KIND = "native.session.request";
@@ -22051,6 +22082,26 @@ var daemonToServiceSignatures = {
     encodeSessionPromptAcceptedEvent,
     decodeSessionPromptAcceptedEvent
   ),
+  [SESSION_PROMPT_STEERED_KIND]: defineMessageSignature(
+    SESSION_PROMPT_STEERED_KIND,
+    encodeSessionPromptSteeredEvent,
+    decodeSessionPromptSteeredEvent
+  ),
+  [SESSION_TURN_STOPPED_KIND]: defineMessageSignature(
+    SESSION_TURN_STOPPED_KIND,
+    encodeSessionTurnStoppedEvent,
+    decodeSessionTurnStoppedEvent
+  ),
+  [SESSION_TURN_WITHDRAWN_KIND]: defineMessageSignature(
+    SESSION_TURN_WITHDRAWN_KIND,
+    encodeSessionTurnWithdrawnEvent,
+    decodeSessionTurnWithdrawnEvent
+  ),
+  [SESSION_INTERACTION_ANSWERED_KIND]: defineMessageSignature(
+    SESSION_INTERACTION_ANSWERED_KIND,
+    encodeSessionInteractionAnsweredEvent,
+    decodeSessionInteractionAnsweredEvent
+  ),
   [SESSION_HISTORY_PAGE_LOADED_KIND]: defineMessageSignature(
     SESSION_HISTORY_PAGE_LOADED_KIND,
     encodeSessionHistoryPageLoaded,
@@ -92717,7 +92768,7 @@ var PromptLifecycle = class {
     if (request?.sessionId !== sessionId || this.#executions.isTerminalExecution(commandId, sessionId)) {
       return;
     }
-    const recorded = await this.#recordLifecycle(sessionId, {
+    await this.#recordLifecycle(sessionId, {
       type: "lifecycle-metadata",
       payload: {
         kind: "prompt.completed",
@@ -92726,14 +92777,6 @@ var PromptLifecycle = class {
         ...this.#executions.hasStarted(commandId, sessionId) ? {} : { execution: "not-started" }
       }
     });
-    if (!recorded) {
-      this.#sink.publishOperationFailure(
-        sessionId,
-        commandId,
-        "cancelled",
-        "The prompt was cancelled before execution"
-      );
-    }
   };
   /**
    * Settles a failed command; whether it failed before or after starting is its receipt's fact. The unsettled
@@ -92744,13 +92787,10 @@ var PromptLifecycle = class {
     if (this.#executions.findUnsettledAttemptId(commandId, sessionId) === null) {
       return;
     }
-    const recorded = await this.#recordLifecycle(sessionId, {
+    await this.#recordLifecycle(sessionId, {
       type: "lifecycle-metadata",
       payload: this.#executions.hasStarted(commandId, sessionId) ? { kind: "prompt.failed", attemptId, commandId, code, message } : { kind: "prompt.failed-before-start", commandId, code, message }
     });
-    if (!recorded || code === SESSION_CLOSED_ERROR_CODE) {
-      this.#sink.publishOperationFailure(sessionId, commandId, code, message);
-    }
   };
   /** The recorded terminal events of the Session's settled prompts that name the user message they recorded. */
   promptOutcomes = (sessionId) => this.#executions.promptOutcomes(sessionId);
@@ -92860,6 +92900,8 @@ var ExecutionReceipts = class {
    * ledger keeps the commands unsettled and the next process reports that the restart interrupted them.
    */
   #shutdownSettlements = /* @__PURE__ */ new Map();
+  /** Requests waiting for a command's next transition; each listener hears every transition until removed. */
+  #watchers = /* @__PURE__ */ new Map();
   #closing = false;
   constructor(ledger, onCount = () => void 0) {
     this.#ledger = ledger;
@@ -92881,6 +92923,11 @@ var ExecutionReceipts = class {
     }
     return this.#agentOutcomes.get(commandId) ?? fate.outcome;
   };
+  #notify = (commandId, progress) => {
+    for (const listener of [...this.#watchers.get(commandId) ?? []]) {
+      listener(progress);
+    }
+  };
   #publishCount = () => {
     this.#onCount(this.#ledger.unsettled().filter((commandId) => !this.#shutdownSettlements.has(commandId)).length);
   };
@@ -92898,10 +92945,55 @@ var ExecutionReceipts = class {
       }
     }
     this.#publishCount();
+    this.#notify(commandId, "settled");
   };
   beginShutdown = () => {
     this.#closing = true;
   };
+  /** Waits for the first transition of the command that `accepts`; the waiter is released when `signal` aborts. */
+  #transition = (commandId, accepts, signal) => new Promise((resolve19, reject2) => {
+    if (signal.aborted) {
+      reject2(signal.reason);
+      return;
+    }
+    const watchers = this.#watchers.get(commandId) ?? /* @__PURE__ */ new Set();
+    const release2 = () => {
+      signal.removeEventListener("abort", aborted2);
+      watchers.delete(listener);
+      if (watchers.size === 0) {
+        this.#watchers.delete(commandId);
+      }
+    };
+    const listener = (progress) => {
+      if (accepts(progress)) {
+        release2();
+        resolve19(progress);
+      }
+    };
+    const aborted2 = () => {
+      release2();
+      reject2(signal.reason);
+    };
+    watchers.add(listener);
+    this.#watchers.set(commandId, watchers);
+    signal.addEventListener("abort", aborted2, { once: true });
+  });
+  /** Where the command stands now, or its next transition: `started` once it started, `settled` once it has ended. */
+  progress = async (commandId, sessionId, signal) => {
+    if (this.isTerminalExecution(commandId, sessionId)) {
+      return "settled";
+    }
+    if (this.hasStarted(commandId, sessionId)) {
+      return "started";
+    }
+    return await this.#transition(commandId, () => true, signal);
+  };
+  /** Resolves once the command has ended. */
+  settlement = async (commandId, sessionId, signal) => {
+    if (!this.isTerminalExecution(commandId, sessionId)) {
+      await this.#transition(commandId, (progress) => progress === "settled", signal);
+    }
+  };
   outcome = (commandId) => this.restatedOutcome(commandId)?.event;
   /** The outcome the ledger keeps for the command, with the time it was recorded. */
   restatedOutcome = (commandId) => {
@@ -93042,13 +93134,7 @@ var ExecutionReceipts = class {
         return standing;
     }
     const outcome = cancelledBeforeStartOutcome(commandId);
-    const commandHash = createHash8("sha256").update(
-      encodeSessionCancelBeforeStartCommand({
-        commandId,
-        kind: "session.cancel-before-start",
-        sessionId
-      })
-    ).digest("hex");
+    const commandHash = createHash8("sha256").update(JSON.stringify({ commandId, kind: "session.cancel-before-start", sessionId })).digest("hex");
     for (const dropped of this.#ledger.admitCancelled(
       { attemptId: randomUUID15(), commandHash, commandId, sessionId },
       JSON.stringify({ ...outcome, recordedAt: (/* @__PURE__ */ new Date()).toISOString() })
@@ -93069,6 +93155,7 @@ var ExecutionReceipts = class {
     const payload = event.payload;
     if (payload.kind === "prompt.started") {
       this.#ledger.start(payload.commandId, event.recordedAt);
+      this.#notify(payload.commandId, "started");
       return;
     }
     if (!isPromptTerminal(payload)) {
@@ -93171,6 +93258,7 @@ var ExecutionReceipts = class {
     return command2?.sessionId === sessionId && !isUnsettled(command2.fate);
   };
   close = () => {
+    this.#watchers.clear();
     this.#agentOutcomes.clear();
     this.#shutdownSettlements.clear();
   };
@@ -93830,12 +93918,11 @@ function buildSessionLayer(options) {
     sink,
     async (sessionId, event) => {
       if (await manager.recordLifecycleEvent(sessionId, event)) {
-        return true;
+        return;
       }
       const recorded = events.append(sessionId, event);
       operations.record(recorded);
       eventProjection.record(recorded);
-      return true;
     },
     (sessionId, event, recordedAt) => events.append(sessionId, event, recordedAt),
     activeSessions.recordSessionEvent,
@@ -94586,7 +94673,7 @@ var RelayConnectionDiagnostics = class {
 };
 
 // src/engine/runtime/relay/run-relay-connection.ts
-import { WebSocket as WebSocket8 } from "undici";
+import { WebSocket as WebSocket9 } from "undici";
 
 // src/engine/runtime/catalog/handle-agent-catalog-discovery.ts
 import { WebSocket as WebSocket3 } from "undici";
@@ -95694,67 +95781,157 @@ var previewHistoryPageLoadCommand = {
   }
 };
 
+// src/engine/runtime/command/turn-replies.ts
+import { WebSocket as WebSocket6 } from "undici";
+function settledCommand(operations, commandId) {
+  const outcome = operations.outcome(commandId);
+  if (outcome?.type !== "lifecycle-metadata") {
+    return { kind: "unavailable" };
+  }
+  const payload = outcome.payload;
+  switch (payload.kind) {
+    case "prompt.completed":
+      return {
+        kind: "completed",
+        stopReason: payload.stopReason,
+        cancelledBeforeStart: promptCompletion(payload).kind === "cancelled"
+      };
+    case "prompt.failed":
+    case "prompt.failed-before-start":
+      return { kind: "failed", code: payload.code, message: payload.message };
+    default:
+      return { kind: "unavailable" };
+  }
+}
+function reply(socket, message) {
+  if (socket.readyState === WebSocket6.OPEN) {
+    send(socket, message);
+  }
+}
+function replyFailure(socket, requestId, sessionId, code, message) {
+  reply(socket, { code, kind: "session.operation.failed", message, requestId, sessionId });
+}
+function replySettledFailure(socket, requestId, sessionId, settled) {
+  if (settled.kind === "failed") {
+    replyFailure(socket, requestId, sessionId, settled.code, settled.message);
+    return;
+  }
+  replyFailure(
+    socket,
+    requestId,
+    sessionId,
+    "command_result_expired",
+    "The command ended, but its result is no longer available."
+  );
+}
+
 // src/engine/runtime/command/registry/interactions.ts
+function replyStopped({ operations, socket }, {
+  commandId,
+  requestId,
+  sessionId
+}) {
+  const settled = settledCommand(operations, commandId);
+  if (settled.kind === "completed") {
+    reply(socket, {
+      commandId,
+      kind: SESSION_TURN_STOPPED_KIND,
+      requestId,
+      sessionId,
+      stopReason: settled.stopReason
+    });
+    return;
+  }
+  replySettledFailure(socket, requestId, sessionId, settled);
+}
 var sessionCancelCommand = {
   kind: SESSION_CANCEL_KIND,
-  handle: ({ eventProjection, operations, sessions, sessionTurns, signal, socket }, message) => {
+  handle: (context, message) => {
     if (message.kind !== SESSION_CANCEL_KIND) {
       throw new Error("Command kind mismatch");
     }
-    const turn = sessionTurns.get(message.commandId, message.sessionId);
-    if (turn === void 0) {
-      void settleAbandonedTurn(eventProjection, operations, message).catch((error62) => {
-        reportOperationFailure(socket, message.commandId, message.sessionId, error62);
-      });
-      return;
-    }
-    const cancellation = turn.requestCancellation();
-    if (cancellation.kind !== "running") {
-      return;
-    }
-    void sessions.cancelPrompt(message.sessionId, cancellation.execution, signal).catch((error62) => {
-      console.error("Morty daemon could not cancel the agent turn", error62);
+    const { eventProjection, operations, sessions, sessionTurns, signal, socket } = context;
+    const { commandId, requestId, sessionId } = message;
+    const turn = sessionTurns.get(commandId, sessionId);
+    const stop = async () => {
+      if (turn === void 0) {
+        await settleAbandonedTurn(eventProjection, operations, message);
+        if (!operations.isTerminalExecution(commandId, sessionId)) {
+          replyFailure(socket, requestId, sessionId, "turn_not_active", "The turn is not running.");
+          return;
+        }
+      } else {
+        const cancellation = turn.requestCancellation();
+        if (cancellation.kind === "running") {
+          await sessions.cancelPrompt(sessionId, cancellation.execution, signal);
+        }
+        await operations.settlement(commandId, sessionId, signal);
+      }
+      replyStopped(context, message);
+    };
+    void stop().catch((error62) => {
+      if (!signal.aborted) {
+        reportOperationFailure(socket, requestId, sessionId, error62);
+      }
     });
   }
 };
 var sessionCancelBeforeStartCommand = {
   kind: SESSION_CANCEL_BEFORE_START_KIND,
-  handle: ({ eventProjection, operations, sessionTurns, socket }, message) => {
+  handle: ({ eventProjection, operations, sessionTurns, signal, socket }, message) => {
     if (message.kind !== SESSION_CANCEL_BEFORE_START_KIND) {
       throw new Error("Command kind mismatch");
     }
-    if (operations.hasStarted(message.commandId, message.sessionId)) {
-      reportOperationFailure(
-        socket,
-        message.commandId,
-        message.sessionId,
-        new SessionError("turn_already_started", "The message already started and could not be withdrawn")
-      );
+    const { commandId, requestId, sessionId } = message;
+    const withdrawn = () => reply(socket, { commandId, kind: SESSION_TURN_WITHDRAWN_KIND, requestId, sessionId });
+    const alreadyStarted = () => reportOperationFailure(
+      socket,
+      requestId,
+      sessionId,
+      new SessionError("turn_already_started", "The message already started and could not be withdrawn")
+    );
+    if (operations.hasStarted(commandId, sessionId)) {
+      alreadyStarted();
       return;
     }
-    const turn = sessionTurns.get(message.commandId, message.sessionId);
+    const turn = sessionTurns.get(commandId, sessionId);
     if (turn === void 0) {
-      const cancelled = operations.recordCancellationBeforeAdmission(message.commandId, message.sessionId);
+      const cancelled = operations.recordCancellationBeforeAdmission(commandId, sessionId);
       const outcome = cancelled.kind === "unavailable" || cancelled.kind === "expired" ? void 0 : cancelled.kind === "restated" ? cancelled.outcome.event : cancelled.outcome;
       if (outcome?.type === "lifecycle-metadata" && outcome.payload.kind === "prompt.completed" && promptCompletion(outcome.payload).kind === "cancelled") {
         if (cancelled.kind === "restated") {
-          eventProjection.restateOutcome(message.sessionId, cancelled.outcome);
+          eventProjection.restateOutcome(sessionId, cancelled.outcome);
+          withdrawn();
           return;
         }
-        void eventProjection.recordOutcome(message.sessionId, outcome).catch((error62) => {
-          reportOperationFailure(socket, message.commandId, message.sessionId, error62);
+        void eventProjection.recordOutcome(sessionId, outcome).then(withdrawn).catch((error62) => {
+          reportOperationFailure(socket, requestId, sessionId, error62);
         });
         return;
       }
       reportOperationFailure(
         socket,
-        message.commandId,
-        message.sessionId,
+        requestId,
+        sessionId,
         new SessionError("turn_not_active", "The command is not waiting to start")
       );
       return;
     }
     turn.requestCancellation();
+    void operations.progress(commandId, sessionId, signal).then((progress) => {
+      if (progress === "started") {
+        alreadyStarted();
+        return;
+      }
+      const settled = settledCommand(operations, commandId);
+      if (settled.kind !== "completed") {
+        replySettledFailure(socket, requestId, sessionId, settled);
+      } else if (settled.cancelledBeforeStart) {
+        withdrawn();
+      } else {
+        alreadyStarted();
+      }
+    }).catch(() => void 0);
   }
 };
 var sessionCloseCommand = {
@@ -95772,23 +95949,42 @@ var sessionCloseCommand = {
 };
 var promptDispositionCommand = {
   kind: SESSION_PROMPT_DISPOSITION_KIND,
-  handle: ({ diagnostics, operations, sessionTurns, socket }, message) => {
+  handle: ({ diagnostics, operations, sessionTurns, signal, socket }, message) => {
     if (message.kind !== SESSION_PROMPT_DISPOSITION_KIND) {
       throw new Error("Command kind mismatch");
     }
-    const turn = sessionTurns.get(message.commandId, message.sessionId);
+    const { commandId, requestId, sessionId } = message;
+    const turn = sessionTurns.get(commandId, sessionId);
     const result = turn?.promoteQueuedPrompt(message) ?? "unavailable";
     if (result === "accepted") {
+      void operations.progress(commandId, sessionId, signal).then((progress) => {
+        if (progress === "started") {
+          reply(socket, { commandId, kind: SESSION_PROMPT_STEERED_KIND, requestId, sessionId });
+          return;
+        }
+        const settled = settledCommand(operations, commandId);
+        if (settled.kind !== "completed") {
+          replySettledFailure(socket, requestId, sessionId, settled);
+          return;
+        }
+        replyFailure(
+          socket,
+          requestId,
+          sessionId,
+          "turn_not_active",
+          "The message ended before it was steered."
+        );
+      }).catch(() => void 0);
       return;
     }
-    const started = result === "already-started" || operations.hasStarted(message.commandId, message.sessionId);
+    const started = result === "already-started" || operations.hasStarted(commandId, sessionId);
     const error62 = started ? new SessionError("turn_already_started", "The message already left the queue and could not be steered") : new SessionError("turn_not_active", "The message is no longer waiting to be steered");
-    diagnostics.daemonDiagnostic("session_prompt_disposition_failed", message.commandId, {
+    diagnostics.daemonDiagnostic("session_prompt_disposition_failed", commandId, {
       code: error62.code,
-      commandId: message.commandId,
-      sessionId: message.sessionId
+      commandId,
+      sessionId
     });
-    reportOperationFailure(socket, message.commandId, message.sessionId, error62);
+    reportOperationFailure(socket, requestId, sessionId, error62);
   }
 };
 var permissionRespondCommand = {
@@ -95797,8 +95993,9 @@ var permissionRespondCommand = {
     if (message.kind !== SESSION_PERMISSION_RESPOND_KIND) {
       throw new Error("Command kind mismatch");
     }
-    void sessions.respondPermission(message).catch((error62) => {
-      reportOperationFailure(socket, message.interactionId, message.sessionId, error62);
+    const { interactionId, requestId, sessionId } = message;
+    void sessions.respondPermission(message).then(() => reply(socket, { interactionId, kind: SESSION_INTERACTION_ANSWERED_KIND, requestId, sessionId })).catch((error62) => {
+      reportOperationFailure(socket, requestId, sessionId, error62);
     });
   }
 };
@@ -95808,14 +96005,15 @@ var elicitationRespondCommand = {
     if (message.kind !== SESSION_ELICITATION_RESPOND_KIND) {
       throw new Error("Command kind mismatch");
     }
-    void sessions.respondElicitation(message).catch((error62) => {
-      reportOperationFailure(socket, message.interactionId, message.sessionId, error62);
+    const { interactionId, requestId, sessionId } = message;
+    void sessions.respondElicitation(message).then(() => reply(socket, { interactionId, kind: SESSION_INTERACTION_ANSWERED_KIND, requestId, sessionId })).catch((error62) => {
+      reportOperationFailure(socket, requestId, sessionId, error62);
     });
   }
 };
 
 // src/engine/runtime/command/native-session-requests.ts
-import { WebSocket as WebSocket6 } from "undici";
+import { WebSocket as WebSocket7 } from "undici";
 function createNativeSessionRequestHandler(dependencies) {
   const { diagnostics, nativeSessions, signal, socket, timer } = dependencies;
   const pending = /* @__PURE__ */ new Map();
@@ -95866,7 +96064,7 @@ function createNativeSessionRequestHandler(dependencies) {
         }
         operationSignal.throwIfAborted();
         const result = await nativeSessions.execute(command2, operationSignal);
-        if (socket.readyState === WebSocket6.OPEN) {
+        if (socket.readyState === WebSocket7.OPEN) {
           send(socket, result);
         }
       } catch (error62) {
@@ -96286,7 +96484,7 @@ var sessionPromptCommand = {
       return;
     }
     if (receipt.kind === "duplicate") {
-      send(context.socket, {
+      reply(context.socket, {
         kind: "session.prompt.accepted",
         requestId: message.commandId,
         sessionId: message.sessionId,
@@ -96310,8 +96508,34 @@ var sessionPromptCommand = {
     }
     const turn = context.sessionTurns.start(message, receipt.attemptId);
     context.eventProjection.requested(message);
+    const { commandId, sessionId } = message;
+    let answered = false;
+    const accepted = (state) => {
+      if (!answered) {
+        answered = true;
+        reply(context.socket, { kind: "session.prompt.accepted", requestId: commandId, sessionId, state });
+      }
+    };
+    const ended = () => {
+      if (answered) {
+        return;
+      }
+      const settled = settledCommand(context.operations, commandId);
+      if (settled.kind === "completed") {
+        accepted("settled");
+        return;
+      }
+      answered = true;
+      replySettledFailure(context.socket, commandId, sessionId, settled);
+    };
+    const waiting = new AbortController();
+    context.operations.progress(commandId, sessionId, AbortSignal.any([waiting.signal, context.signal])).then((progress) => {
+      if (progress === "started") {
+        accepted("running");
+      }
+    }).catch(() => void 0);
     const queueChanged = () => {
-      void context.eventProjection.queueChanged(message.sessionId, message.commandId).catch((error62) => {
+      void context.eventProjection.queueChanged(sessionId, commandId).catch((error62) => {
         console.error("Could not record queue change", error62);
       });
     };
@@ -96337,12 +96561,15 @@ var sessionPromptCommand = {
       epoch: turn.epoch,
       waitForSessionAdmission: (signal) => context.sessionTurns.admitAndWait(turn, signal, () => {
         queueChanged();
+        accepted("queued");
       }),
       signal: turn.signal,
       cancellationRequested: turn.cancellationRequested
     }).catch((error62) => {
       console.error("Morty daemon turn failed", error62);
     }).finally(() => {
+      waiting.abort();
+      ended();
       context.sessionTurns.finish(turn);
       context.eventProjection.publishTerminal(message.sessionId, message.commandId);
       if (turn.enteredQueue()) {
@@ -96923,7 +97150,7 @@ function createRuntimeCommandDispatcher(options) {
 }
 
 // src/engine/runtime/relay/connect.ts
-import { WebSocket as WebSocket7 } from "undici";
+import { WebSocket as WebSocket8 } from "undici";
 var CONNECTION_TIMEOUT_MILLISECONDS = 6e4;
 var RelayConnectionError = class extends Error {
   code;
@@ -96995,7 +97222,7 @@ function connectRelay(url2, signal, transportFailed = () => void 0) {
     const endpoint = new URL(url2);
     const headers = relayAuthorization(endpoint);
     endpoint.searchParams.delete("token");
-    const socket = new WebSocket7(endpoint, {
+    const socket = new WebSocket8(endpoint, {
       dispatcher,
       headers
     });
@@ -97236,7 +97463,7 @@ async function runRelayConnection({
     timer
   });
   void reportUpgradeAvailability((result) => {
-    if (socket.readyState === WebSocket8.OPEN) {
+    if (socket.readyState === WebSocket9.OPEN) {
       send(socket, result);
     }
   }, signal).catch((cause) => {
@@ -97287,14 +97514,14 @@ async function runRelayConnection({
       };
       const connectionLiveness = new RelayConnectionLiveness(timer, {
         send: (message) => {
-          if (socket.readyState !== WebSocket8.OPEN) {
+          if (socket.readyState !== WebSocket9.OPEN) {
             return false;
           }
           try {
             send(socket, message);
             return true;
           } catch (error62) {
-            if (socket.readyState !== WebSocket8.OPEN) {
+            if (socket.readyState !== WebSocket9.OPEN) {
               return false;
             }
             throw error62;
@@ -97353,6 +97580,7 @@ async function runRelayConnection({
             diagnostics.daemonDiagnostic("protocol_message_discarded", "unknown", {
               reason: "unsupported_message"
             });
+            refuseUnsupportedRequest(socket, encoded);
             return;
           }
           const kind = message.kind;
@@ -97394,9 +97622,32 @@ async function runRelayConnection({
     relay.release(new Error("Relay connection released"));
   }
 }
+function refuseUnsupportedRequest(socket, encoded) {
+  let value;
+  try {
+    value = JSON.parse(encoded);
+  } catch {
+    return;
+  }
+  if (typeof value !== "object" || value === null) {
+    return;
+  }
+  const requestId = Reflect.get(value, "requestId");
+  const sessionId = Reflect.get(value, "sessionId");
+  if (!isIdentifier(requestId)) {
+    return;
+  }
+  replyFailure(
+    socket,
+    requestId,
+    isIdentifier(sessionId) ? sessionId : "",
+    "unsupported_operation",
+    "This Morty Runtime does not support the requested operation."
+  );
+}
 
 // src/engine/runtime/relay/session-event-publisher.ts
-import { WebSocket as WebSocket9 } from "undici";
+import { WebSocket as WebSocket10 } from "undici";
 var MAX_BUFFERED_BYTES = 32 * 1024 * 1024;
 var MAX_PENDING_BYTES2 = 32 * 1024 * 1024;
 var MAX_EVENT_BATCH_BYTES = 1024 * 1024;
@@ -97440,9 +97691,6 @@ var RuntimeSessionEventPublisher = class {
       this.flushEvents(this.#connection.socket);
     }
   };
-  publishOperationFailure = (sessionId, requestId, code, message) => {
-    this.#send({ kind: "session.operation.failed", sessionId, requestId, code, message });
-  };
   publishStatus = (event) => this.#send(event);
   publishInfo = (event) => this.#send(event);
   publishClosed = (event) => {
@@ -97451,7 +97699,7 @@ var RuntimeSessionEventPublisher = class {
   };
   #send = (message) => {
     const connection = this.#connection;
-    if (connection.kind !== "connected" || connection.socket.readyState !== WebSocket9.OPEN) {
+    if (connection.kind !== "connected" || connection.socket.readyState !== WebSocket10.OPEN) {
       return;
     }
     const socket = connection.socket;
@@ -97513,7 +97761,7 @@ var RuntimeSessionEventPublisher = class {
       });
     }
     const connection = this.#connection;
-    if (connection.kind !== "connected" || connection.socket.readyState !== WebSocket9.OPEN) {
+    if (connection.kind !== "connected" || connection.socket.readyState !== WebSocket10.OPEN) {
       return;
     }
     const socket = connection.socket;
@@ -97552,7 +97800,7 @@ var RuntimeSessionEventPublisher = class {
   flushEvents = (socket) => {
     this.cancelFlush();
     const connection = this.#connection;
-    if (connection.kind !== "connected" || connection.socket !== socket || socket.readyState !== WebSocket9.OPEN) {
+    if (connection.kind !== "connected" || connection.socket !== socket || socket.readyState !== WebSocket10.OPEN) {
       return;
     }
     let sent = 0;
@@ -98048,4 +98296,4 @@ export {
   * MIT Licensed
   *)
 */
-//# sourceMappingURL=chunk-VKVKHAQ7.js.map
+//# sourceMappingURL=chunk-MLX3QFGN.js.map