@jskit-ai/assistant-core 0.2.50 → 0.2.51

package/CHANGELOG.md

@@ -2,6 +2,7 @@
 
 ## Unreleased
 
+- 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.51",
     "@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.51",
   "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/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);