@jskit-ai/assistant-core 0.2.50 → 0.2.52

package/CHANGELOG.md

@@ -2,6 +2,8 @@
 
 ## Unreleased
 
+- New `latestAssistantQuestionsAwaitingUserReply(conversationLog, { lookback = 10 })` (from `/shared/conversation`) finds the questions the AI is still waiting for an answer to when it added a short message after them, such as "No files have changed. I'll build it once you've answered those three." `latestAssistantMessageAwaitingUserReply` returns only that last message, so a question form fed by it disappeared. The new helper starts where that one does, at the AI's newest completed reply (nothing while it is in progress, nothing after the person's latest message), reads back over that reply and the AI's earlier replies and commentary since the person's latest message, at most `lookback` of them (thinking does not count), and returns the text of the newest one with numbered questions or answer choices, or "". Questions the AI wrote before a tool call are saved as commentary, so they count. `latestAssistantMessageAwaitingUserReply` is unchanged and now reads the same walk.
+- A message lost on its way to an OpenCode conversation bound to its host no longer makes every later message fail as unconfirmed (`conversation_delivery_uncertain`, or the host's own changeover code). When the host's prepared-message inspection proves that the prompt never arrived (`admission: "not-admitted"`, for example a prompt absent from complete native history whose receiving server was replaced), the OpenCode driver passes that proof to the runtime as `notAdmitted`, as the Claude driver does, instead of dropping it so that the runtime read it as unknown. `inspectDelivery({ messageId })` then reports the message `not-sent`, the conversation is ready again and the next message is sent; the lost prompt is never sent again. An inspection that answers `unknown` stays unknown.
 - A Claude conversation keeps working when a Stop, a crashed Claude process or the next message arrives while Claude's previous turn still waits on its host (publishing, saving, storing an admission). The shared Claude turn now gives each native frame a lease on its turn: a Stop, a reset or the next turn's start supersedes it, and a superseded frame ends at that wait before it reads, changes or publishes anything of the turn that replaced it. Such a frame used to fail with "Cannot read properties of null (reading 'status')", publish the old turn's message, phase or diagnostic into the next turn, or complete the next turn with the old turn's result; a finished turn's goal refresh now resolves that turn's own completion. A steer to the same turn still lands, and a frame decides from the state it finds after each wait. A message being prepared for a turn that a Stop or the next message replaces meanwhile is no longer written to the stopped Claude, and its failure no longer stops the Claude that replaced it: it fails as not sent (`conversation_claude_turn_superseded`).
 - A message lost with a failed Claude process no longer makes every later message fail as unconfirmed (`conversation_delivery_uncertain`, or the host's own changeover code). When the next message checks the earlier attempt, a Claude history without it and no live process that it was written to prove that it never arrived (`not-admitted`), and the conversation runtime now passes that proof to the changeover instead of reading every answer but `accepted` as unknown. A message Claude did record is accepted and never sent again, a prompt whose pipe write failed is reported `delivery: "not-sent"`, and a prompt written to a process still running stays unknown until that process settles it. The server records which process it wrote each prompt to, so a prompt it has no record of was written, if at all, by an earlier server, and only that server's Claude can still record it while its exit is unproven: a conversation already holding such an attempt clears it with its next message.
 - A Claude goal's running time no longer counts the time a server was stopped mid-turn. When Claude starts again after a request that was cut off, it saves a "No response requested." placeholder just before the goal continues, and the history reader counted the wait up to that placeholder as work: a restart in the middle of a turn added the whole downtime to the goal's clock. The wait before that placeholder now counts like the wait before an authored message; the cut-off request's unsaved part is not counted.

package/examples/conversation/package.json

@@ -8,7 +8,7 @@
     "build": "vite build"
   },
   "dependencies": {
-    "@jskit-ai/assistant-core": "0.2.50",
+    "@jskit-ai/assistant-core": "0.2.52",
     "@jskit-ai/http-runtime": "0.2.21",
     "@jskit-ai/kernel": "0.2.21",
     "@jskit-ai/material-web": "0.1.6",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/assistant-core",
-  "version": "0.2.50",
+  "version": "0.2.52",
   "type": "module",
   "scripts": {
     "test": "jskit test"

package/src/server/conversation/providers/opencodeDriver.js

@@ -273,7 +273,8 @@ export function createOpenCodeConversationDriver({
         async inspectAdmission({ context, representation, ...input }) {
           const acquired = await supplied.acquire(context);
           const result = await supplied.owner.inspectPreparedMessage(await supplied.preparation.inspection(input, acquired.options));
-          return representation === "native" ? result : { accepted: result.admission === "accepted" };
+          return representation === "native" ? result
+            : { accepted: result.admission === "accepted", notAdmitted: result.admission === "not-admitted" };
         },
         async run(command) {
           if (disposed || current) throw Object.assign(new Error("This OpenCode conversation is closed or already working."), {

package/src/shared/conversation/questions.js

@@ -1,3 +1,8 @@
+import { parseAnswerChoicePrompt } from "./answerChoiceSugar.js";
+import { parseNumberedQuestionPrompt } from "./numberedQuestionSugar.js";
+
+const ASSISTANT_QUESTION_LOOKBACK = 10;
+
 function messageText(value = "") {
   return String(value || "").trim();
 }
@@ -10,40 +15,88 @@ function conversationTurns(conversationLog = {}) {
   return Array.isArray(conversationLog) ? conversationLog : [];
 }
 
-function latestAssistantMessageAwaitingUserReply(conversationLog = {}) {
+/**
+ * The conversation's messages, newest first. A turn without a message list
+ * offers its person's message first, then its reply, then its commentary.
+ */
+function* messagesNewestFirst(conversationLog) {
   const turns = conversationTurns(conversationLog);
   for (let turnIndex = turns.length - 1; turnIndex >= 0; turnIndex -= 1) {
     const turn = turns[turnIndex];
     const messages = Array.isArray(turn?.messages) ? turn.messages : [];
     if (messages.length) {
-      for (let index = messages.length - 1; index >= 0; index -= 1) {
-        const message = messages[index];
-        const text = messageText(message?.text);
-        if (!text) {
-          continue;
-        }
-        if (message?.role === "user") {
-          return "";
-        }
-        if (message?.role === "assistant") {
-          if (message.status === "inProgress") return "";
-          return text;
-        }
-      }
+      for (let index = messages.length - 1; index >= 0; index -= 1) yield messages[index];
       continue;
     }
-    if (messageText(turn?.user?.text)) {
+    if (turn?.user) yield { ...turn.user, role: "user" };
+    if (turn?.assistant) yield { ...turn.assistant, role: "assistant" };
+    const commentary = Array.isArray(turn?.commentary) ? turn.commentary : [];
+    for (let index = commentary.length - 1; index >= 0; index -= 1) yield { ...commentary[index], role: "commentary" };
+  }
+}
+
+/** The same messages for which the standard composer offers answer fields. */
+function asksPerson(text) {
+  return parseNumberedQuestionPrompt(text).questions.length > 0 || parseAnswerChoicePrompt(text).choices.length > 0;
+}
+
+function latestAssistantMessageAwaitingUserReply(conversationLog = {}) {
+  for (const message of messagesNewestFirst(conversationLog)) {
+    const text = messageText(message?.text);
+    if (!text) {
+      continue;
+    }
+    if (message?.role === "user") {
       return "";
     }
-    const assistantText = messageText(turn?.assistant?.text);
-    if (assistantText) {
-      if (turn.assistant.status === "inProgress") return "";
-      return assistantText;
+    if (message?.role === "assistant") {
+      return message.status === "inProgress" ? "" : text;
+    }
+  }
+  return "";
+}
+
+/**
+ * The text of the newest AI message that asks the person numbered questions or
+ * offers answer choices and still awaits their reply, or "". The search starts at
+ * the AI's newest completed reply, the message latestAssistantMessageAwaitingUserReply
+ * returns, so nothing is offered while the AI is still writing or working before it.
+ * From there it reads that reply and the AI's earlier replies and commentary, at most
+ * `lookback` of them, and stops at the person's latest message. A short message the
+ * AI adds after its questions therefore no longer hides them.
+ * @param {object | object[]} conversationLog
+ * @param {{ lookback?: number }} [options]
+ */
+function latestAssistantQuestionsAwaitingUserReply(conversationLog = {}, { lookback = ASSISTANT_QUESTION_LOOKBACK } = {}) {
+  let replied = false;
+  let read = 0;
+  for (const message of messagesNewestFirst(conversationLog)) {
+    const text = messageText(message?.text);
+    if (!text) {
+      continue;
+    }
+    if (message?.role === "user") {
+      return "";
+    }
+    if (message?.role === "assistant" && !replied) {
+      if (message.status === "inProgress") return "";
+      replied = true;
+    }
+    if (!replied || !["assistant", "commentary"].includes(message?.role)) {
+      continue;
+    }
+    if (asksPerson(text)) {
+      return text;
+    }
+    read += 1;
+    if (read >= lookback) {
+      return "";
     }
   }
   return "";
 }
 
 export {
-  latestAssistantMessageAwaitingUserReply
+  latestAssistantMessageAwaitingUserReply,
+  latestAssistantQuestionsAwaitingUserReply
 };

package/test/conversationQuestions.test.js

@@ -0,0 +1,97 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import {
+  latestAssistantMessageAwaitingUserReply,
+  latestAssistantQuestionsAwaitingUserReply
+} from "../src/shared/conversation/questions.js";
+
+const questions = "Before I build it:\n[1] Which page should hold the form?\n[2] Should the email field be required?";
+const laterQuestions = "One more thing:\n[1] Which colour should the button use?";
+const choices = "Which layout should I use?\nPossible answers:\n- Cards\n- Table";
+const followUp = "No files have changed. I'll build it once you've answered those questions.";
+
+const user = (text = "Add a sign-up form.") => ({ role: "user", text });
+const reply = (text, extra = {}) => ({ role: "assistant", text, ...extra });
+const commentary = text => ({ role: "commentary", text });
+const thinking = text => ({ role: "thinking", text });
+const turn = (...messages) => ({ turnId: "000001", messages });
+
+test("questions followed by a short closing message in the same turn are still found", () => {
+  const log = { turns: [turn(user(), reply(questions), reply(followUp))] };
+  assert.equal(latestAssistantQuestionsAwaitingUserReply(log), questions);
+  // The plain reader still answers with the closing message alone.
+  assert.equal(latestAssistantMessageAwaitingUserReply(log), followUp);
+});
+
+test("questions the AI wrote before a tool call (commentary) are found behind its final reply", () => {
+  const log = [turn(user(), thinking("Checking the files."), commentary(questions), thinking("Nothing changed."), reply(followUp))];
+  assert.equal(latestAssistantQuestionsAwaitingUserReply(log), questions);
+});
+
+test("answer choices count as questions", () => {
+  assert.equal(latestAssistantQuestionsAwaitingUserReply([turn(user(), reply(choices), reply(followUp))]), choices);
+});
+
+test("the search reads at most the lookback's AI messages, and thinking does not count", () => {
+  const between = count => Array.from({ length: count }, (_, index) => [thinking(`Step ${index}`), commentary(`Note ${index}`)]).flat();
+  // The questions are the tenth AI message from the end: found.
+  assert.equal(latestAssistantQuestionsAwaitingUserReply([turn(user(), reply(questions), ...between(8), reply(followUp))]), questions);
+  // The eleventh: not found.
+  assert.equal(latestAssistantQuestionsAwaitingUserReply([turn(user(), reply(questions), ...between(9), reply(followUp))]), "");
+  assert.equal(latestAssistantQuestionsAwaitingUserReply([turn(user(), reply(questions), reply(followUp))], { lookback: 1 }), "");
+});
+
+test("the person's message after the questions ends the search", () => {
+  assert.equal(latestAssistantQuestionsAwaitingUserReply([
+    turn(user(), reply(questions)),
+    turn(user("Page two, and yes."), reply("Done."))
+  ]), "");
+  assert.equal(latestAssistantQuestionsAwaitingUserReply([turn(user(), reply(questions)), turn(user("Page two."))]), "");
+});
+
+test("only the latest set of questions is offered", () => {
+  assert.equal(latestAssistantQuestionsAwaitingUserReply([
+    turn(user(), reply(questions), commentary(laterQuestions), reply(followUp))
+  ]), laterQuestions);
+});
+
+test("nothing is offered while the AI is still writing or still working", () => {
+  assert.equal(latestAssistantQuestionsAwaitingUserReply([
+    turn(user(), reply(questions), reply("No files have", { status: "inProgress" }))
+  ]), "");
+  assert.equal(latestAssistantQuestionsAwaitingUserReply([turn(user(), reply(questions, { status: "inProgress" }))]), "");
+  // Questions in commentary before the AI's final reply exists.
+  assert.equal(latestAssistantQuestionsAwaitingUserReply([turn(user(), commentary(questions), thinking("Reading files."))]), "");
+});
+
+test("the search crosses turns without a person's message and reads turns without a message list", () => {
+  assert.equal(latestAssistantQuestionsAwaitingUserReply([
+    turn(user(), reply(questions)),
+    { turnId: "000002", system: { text: "Review started." }, messages: [{ role: "system", text: "Review started." }] },
+    turn(reply(followUp))
+  ]), questions);
+  assert.equal(latestAssistantQuestionsAwaitingUserReply([
+    { user: { text: "Add a sign-up form." } },
+    { assistant: { text: questions } },
+    { assistant: { text: followUp } }
+  ]), questions);
+  assert.equal(latestAssistantQuestionsAwaitingUserReply([
+    { user: { text: "Add a sign-up form." } },
+    { assistant: { text: followUp }, commentary: [{ text: questions }] }
+  ]), questions);
+  assert.equal(latestAssistantQuestionsAwaitingUserReply([
+    { assistant: { text: questions } },
+    { user: { text: "Page two." } }
+  ]), "");
+  assert.equal(latestAssistantQuestionsAwaitingUserReply([
+    { assistant: { text: questions } },
+    { assistant: { text: "No files", status: "inProgress" } }
+  ]), "");
+});
+
+test("a reply without questions, or no reply, offers nothing", () => {
+  assert.equal(latestAssistantQuestionsAwaitingUserReply([turn(user(), reply("Done."))]), "");
+  assert.equal(latestAssistantQuestionsAwaitingUserReply([]), "");
+  assert.equal(latestAssistantQuestionsAwaitingUserReply(null), "");
+  assert.equal(latestAssistantQuestionsAwaitingUserReply({ turns: [turn(user())] }), "");
+});

package/test/opencodeConversationSession.test.js

@@ -4,7 +4,7 @@ import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import path from "node:path";
 import { setTimeout as delay } from "node:timers/promises";
-import { createConversationRuntime, createFileConversationStorage } from "../src/server/conversation/index.js";
+import { createConversationRuntime, createConversationTranscript, createFileConversationStorage, createMemoryConversationStorage } from "../src/server/conversation/index.js";
 import { createLocalConversationExecution } from "../src/server/conversation/localExecution.js";
 import { createOpenCodeConversationDriver } from "../src/server/conversation/providers/opencodeDriver.js";
 import { createActionCatalogue } from "@jskit-ai/kernel/server/actions";
@@ -686,6 +686,71 @@ test("unavailable or absent native admission remains unknown without replaying t
   }
 });
 
+test("a bound OpenCode message its host proves never arrived is not sent and no longer blocks the next one", async t => {
+  for (const admission of ["unknown", "not-admitted"]) {
+    const f = await boundMainFixture(t, admission);
+    await assert.rejects(f.conversation.send({ messageId: "lost-id", text: "lost" }), /acknowledgement was lost/);
+    assert.equal((await f.conversation.read()).status, "unconfirmed");
+    if (admission === "unknown") {
+      await assert.rejects(f.conversation.inspectDelivery({ messageId: "lost-id" }), { code: "conversation_delivery_uncertain" });
+      assert.equal((await f.conversation.read()).status, "unconfirmed");
+      await assert.rejects(f.conversation.send({ messageId: "retry", text: "Hello" }), /uncertain delivery/);
+      assert.deepEqual(f.dispatched, ["lost-id"]);
+      continue;
+    }
+    const receipt = await f.conversation.inspectDelivery({ messageId: "lost-id" });
+    assert.equal(receipt.status, "not-sent");
+    assert.equal(receipt.messageId, "lost-id");
+    assert.equal((await f.conversation.read()).status, "ready");
+    assert.deepEqual(f.dispatched, ["lost-id"], "Inspection never resends the lost prompt");
+    await f.conversation.send({ messageId: "retry", text: "Hello" });
+    assert.deepEqual(f.dispatched, ["lost-id", "retry"]);
+  }
+});
+
+// A host-bound OpenCode Main through the common runtime. The host's prepared
+// inspection projects the native observation to `admission`; the stand-in native
+// owner keeps the shared runtime's prepared-message seam, finds the prompt absent
+// from complete history, and records each dispatch in place of /prompt_async.
+async function boundMainFixture(t, admission) {
+  const storage = createMemoryConversationStorage();
+  const transcript = createConversationTranscript({ storage });
+  const threadId = "ses_bound_main";
+  const dispatched = [];
+  let delivery;
+  const owner = { turns: new Map(), processes: new Map(), monitors: new Map(),
+    readSessionState: async () => ({ ok: true, thread: { id: threadId } }),
+    async sendPreparedMessage(prepared) {
+      const { messageId, message } = prepared.input;
+      dispatched.push(messageId);
+      await prepared.input.onPromptSending({ threadId });
+      if (messageId === "lost-id") throw new Error("The OpenCode prompt acknowledgement was lost.");
+      return prepared.project({ delivered: true, conversationTurn: await transcript.writeConversationUserMessage("main", { messageId, text: message }) });
+    },
+    inspectPreparedMessage: async prepared => prepared.project({ accepted: false, messages: [] }),
+    interruptPreparedTurn: async () => ({ ok: true }),
+    closeSession: async () => ({ ok: true }) };
+  const binding = { sessionId: "main", namespace: "bound-main", engine: "opencode", runtime: { store: {} },
+    native: { owner, acquire: async context => ({ key: "bound-main", options: context || {} }), preparation: {
+      cleanup: () => ({ sessionId: "main", options: {}, application: {} }),
+      interruption: async () => ({}),
+      message: async input => ({ key: "bound-main", input, project: value => value }),
+      inspection: async input => ({ threadId: input.threadId, inputMessageId: `msg_${input.messageId}`,
+        project: observation => ({ ok: true, admission: observation?.accepted ? "accepted" : admission,
+          messageId: input.messageId, threadId: input.threadId }) })
+    } },
+    admission() {}, prepareInput: async input => input,
+    read: async () => ({ threadId, configuration: { model: "native" }, turn: { active: false }, delivery }),
+    readStream: async () => ({ messages: [] }),
+    state: { read: async () => delivery, write: async value => { delivery = structuredClone(value); } },
+    transcript: { history: async () => [], readConversationLog: () => transcript.readConversationLog("main"),
+      hasMessage: id => transcript.conversationMessageIdExists("main", id),
+      writeUserMessage: input => transcript.writeConversationUserMessage("main", input) } };
+  const runtime = createConversationRuntime({ authorize: () => true, host: { conversation: () => binding } });
+  t.after(() => runtime.close());
+  return { conversation: await runtime.open({ id: "main", context: { actor: { id: "owner" } } }), dispatched };
+}
+
 test("accepted OpenCode output can be recovered after restart without repeating inference", async t => {
   const f = await fixture(t);
   await f.conversation.send(input);