@jskit-ai/assistant-core 0.1.219 → 0.1.220

package/examples/conversation/package.json

@@ -8,14 +8,14 @@
     "build": "vite build"
   },
   "dependencies": {
-    "@jskit-ai/assistant-core": "0.1.219",
-    "@jskit-ai/http-runtime": "0.1.239",
-    "@jskit-ai/kernel": "0.1.241",
+    "@jskit-ai/assistant-core": "0.1.220",
+    "@jskit-ai/http-runtime": "0.1.240",
+    "@jskit-ai/kernel": "0.1.242",
     "@mdi/js": "^7.4.47",
     "vue": "^3.5.13",
     "vuetify": "^4.0.0",
-    "@jskit-ai/connectors-core": "0.1.58",
-    "@jskit-ai/connectors-catalog": "0.1.58"
+    "@jskit-ai/connectors-core": "0.1.59",
+    "@jskit-ai/connectors-catalog": "0.1.59"
   },
   "devDependencies": {
     "@vitejs/plugin-vue": "^6.0.7",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/assistant-core",
-  "version": "0.1.219",
+  "version": "0.1.220",
   "type": "module",
   "scripts": {
     "test": "node --test --test-concurrency=1"
@@ -47,8 +47,8 @@
     "@ai-sdk/perplexity": "^4.0.43",
     "@ai-sdk/togetherai": "^3.0.49",
     "@ai-sdk/xai": "^4.0.58",
-    "@jskit-ai/resource-core": "0.1.183",
-    "@jskit-ai/resource-crud-core": "0.1.183",
+    "@jskit-ai/resource-core": "0.1.184",
+    "@jskit-ai/resource-crud-core": "0.1.184",
     "@mdi/js": "^7.4.47",
     "@openrouter/ai-sdk-provider": "^3.0.0",
     "ai": "^7.0.101",
@@ -57,8 +57,8 @@
     "ws": "^8.20.1"
   },
   "peerDependencies": {
-    "@jskit-ai/http-runtime": "0.1.239",
-    "@jskit-ai/kernel": "0.1.241",
+    "@jskit-ai/http-runtime": "0.1.240",
+    "@jskit-ai/kernel": "0.1.242",
     "vue": "^3.5.13",
     "vuetify": "^4.0.0"
   },

package/src/server/conversation/openCodeRuntime.js

@@ -1634,7 +1634,9 @@ export function createOpenCodeSharedRuntime({ onStop = () => {}, scope } = {}) {
 
   async function interruptTurn(key, target, { threadId = "", writeRun } = {}) {
     const turn = turns.get(key);
-    if (!target) {
+    // Helpers can acquire the shared process before a main conversation exists.
+    // Their cleanup is owned by closeSession, not a native main-turn interrupt.
+    if (!target || (!text(target.upstreamSessionId) && !turn?.active)) {
       return {
         interrupted: false,
         ok: true,

package/src/server/conversation/runtime.js

@@ -241,7 +241,8 @@ export function createConversationRuntime({ engine: defaultEngine = "api", defau
         await emit(entry, { type: "message", turnId: turn.turnId, messageId: message.messageId,
           ...(message.outputId ? { outputId: message.outputId } : {}),
           ...(["user", "application"].includes(turn.metadata?.runtime?.origin) ? { origin: turn.metadata.runtime.origin } : {}),
-          role: message.role, text: message.text, status: "complete", streaming: payload.conversationStream || streams.read(entry.id) });
+          role: message.role, text: message.text, at: message.at, status: "complete", persisted: true,
+          streaming: payload.conversationStream || streams.read(entry.id) });
       }
     }
     if (payload.conversationStream) {

package/test/codexConversationSession.test.js

@@ -3108,6 +3108,8 @@ test("default Codex commentary publishes its saved output identity rather than a
   assert.equal(completed.every(event => event.messageId === progress[0].messageId), true,
     "The existing canonical publication owns this exact output; its native stream must not complete a second identity");
   assert.equal(completed.every(event => event.outputId === progress[0].outputId && event.text === progress[0].text), true);
+  assert.equal(completed.every(event => event.persisted === true && event.at === progress[0].at), true,
+    "Saved output notifications retain their timestamp and cannot masquerade as transient output outside a loaded history page");
   assert.equal((await f.conversation.read()).streaming.completedMessages, undefined);
   assert.equal((await f.trace()).filter(row => row.method === "turn/start").length, 1);
 });

package/test/openCodeRuntime.test.js

@@ -4,6 +4,7 @@ import os from "node:os";
 import path from "node:path";
 import test from "node:test";
 import { createOpenCodeSharedRuntime, ensureOpenCodeSession, openCodeServerForDirectory, readOpenCodeEnvironments } from "../src/server/conversation/openCodeRuntime.js";
+import { createOpenCodeServerClient } from "../src/server/conversation/openCodeClient.js";
 
 function fixture(options = {}) {
   const runtime = createOpenCodeSharedRuntime();
@@ -186,6 +187,54 @@ test("OpenCode shares one lazy server across open sessions and stops it after th
   assert.equal(f.stops.length, 2);
 });
 
+test("an acquired OpenCode process without a main conversation can close without interrupting a peer", async () => {
+  const interrupted = [];
+  const f = fixture({ interrupt: id => { interrupted.push(id); return true; } });
+  const target = await f.acquire("empty");
+  target.sessionId = "empty";
+  const peer = await f.acquire("peer");
+  peer.upstreamSessionId = "peer-native";
+  const nativeClient = createOpenCodeServerClient({ baseUrl: "http://127.0.0.1:1",
+    fetchImpl: async () => assert.fail("No native main conversation exists to interrupt.") });
+  target.server = { ...target.server, client: nativeClient };
+  const stopped = await f.runtime.interruptPreparedTurn({
+    key: "empty", threadId: "", failure: error => { throw error; }
+  });
+  assert.equal(stopped.ok, true);
+  assert.equal(stopped.interrupted, false);
+  const calls = [];
+  const closed = await f.runtime.closeSession("empty", {}, {
+    closeTerminals: async () => { calls.push("terminals"); return { ok: true, closed: 0 }; },
+    beforeRelease: async () => { calls.push("helpers"); },
+    onRemoved: async () => { calls.push("removed"); },
+    afterRelease: async () => { calls.push("history"); },
+    failure: error => { throw error; }
+  });
+  assert.equal(closed.ok, true);
+  assert.equal(closed.closed, 1);
+  assert.deepEqual(calls, ["terminals", "helpers", "removed", "history"]);
+  assert.equal(target.abortController.signal.aborted, true);
+  assert.equal(peer.abortController.signal.aborted, false);
+  assert.equal(f.stops.length, 0);
+  assert.deepEqual(interrupted, []);
+  await f.runtime.interruptTurn("peer", peer);
+  assert.deepEqual(interrupted, ["peer-native"]);
+  await f.runtime.release(peer);
+  assert.equal(f.stops.length, 1);
+});
+
+test("an active OpenCode turn with missing native identity still fails instead of claiming Stop", async () => {
+  const runtime = createOpenCodeSharedRuntime();
+  const client = createOpenCodeServerClient({ baseUrl: "http://127.0.0.1:1",
+    fetchImpl: async () => assert.fail("Invalid identity must fail before transport.") });
+  const turn = { active: true, state: "inProgress" };
+  runtime.turns.set("invalid", turn);
+  await assert.rejects(runtime.interruptTurn("invalid", { upstreamSessionId: "", server: { client } }),
+    /OpenCode session requests require a session id/u);
+  assert.equal(turn.active, true);
+  assert.equal(turn.interruptRequested, false);
+});
+
 test("a pending OpenCode session start retains the shared server while another session closes", async () => {
   const f = fixture();
   const first = await f.acquire("session-1");