@jskit-ai/assistant-core 0.1.212 → 0.1.214

package/test/conversationTools.test.js

@@ -277,6 +277,39 @@ test("repeated calls in one admitted turn reuse receipts; interrupted reservatio
   assert.deepEqual(completed.records(), first.records(), "Restored receipts remain part of the turn's saved state");
 });
 
+test("completed-response tools retain discovery contracts only in their supplied worker catalogue set", async () => {
+  let executions = 0, allowed = true;
+  const catalog = createServiceToolCatalog(actionCatalog(async () => { executions++; return { total: 5 }; }),
+    { maxDirectTools: 0, isActionAvailable: () => allowed });
+  const toolSet = catalog.resolveToolSet(context);
+  const saved = [];
+  const create = retainedToolSet => createConversationTools({ catalog, toolSet: retainedToolSet, context,
+    signal: new AbortController().signal, authorize: async () => {},
+    save: async calls => saved.push(structuredClone(calls)), emit: async () => {} });
+  const contract = { id: "contract-response:operation", name: "assistant_action_contract",
+    arguments: JSON.stringify({ actionId: "numbers.add", version: 1 }) };
+  const execute = { id: "execute-response:operation", name: "assistant_action_execute",
+    arguments: JSON.stringify({ actionId: "numbers.add", version: 1, input: { left: 2, right: 3 } }) };
+  assert.equal((await create(toolSet).execute(contract)).ok, true);
+  const isolated = await create().execute(execute);
+  assert.equal(isolated.error.code, "assistant_action_contract_required");
+  assert.equal(executions, 0, "A separate worker must load its own contract");
+  const nextResponse = create(toolSet);
+  const result = await nextResponse.execute(execute);
+  assert.deepEqual(result, { ok: true, result: { actionId: "numbers.add", version: 1, result: { total: 5 } } });
+  assert.deepEqual(await nextResponse.execute(execute), result);
+  assert.equal(executions, 1, "Retaining the contract does not repeat the durable response operation");
+  assert.ok(saved.every(calls => calls.length === 1), "Each response retains its own durable operation receipt");
+  allowed = false;
+  const revoked = await create(toolSet).execute({ ...execute, id: "revoked-response:operation" });
+  assert.equal(revoked.error.code, "assistant_action_unknown");
+  assert.equal(executions, 1, "A retained contract never overrides current action availability");
+  allowed = true;
+  const reset = await create(catalog.resolveToolSet(context)).execute({ ...execute, id: "reset-response:operation" });
+  assert.equal(reset.error.code, "assistant_action_contract_required");
+  assert.equal(executions, 1, "A new worker or scope starts with no loaded contracts");
+});
+
 test("a later admitted turn can reuse a model's tool id with different arguments", async t => {
   const f = await fixture(t, { execute: ({ left, right }) => ({ total: left + right }),
     response: (_body, round, name) => round % 2 ? new Response(frame({ tool_calls: [{
@@ -529,7 +562,8 @@ test("bound tools use exact accepted host rows and fresh server context without
   assert.equal(f.observed.mappings.length, 2);
   assert.deepEqual(f.observed.mappings[1].admission, { conversationId: "one", turnId: before.turnId,
     messageId: message.messageId, nativeTurnId: "native-turn", nativeThreadId: "native-thread", origin: "user",
-    assertCurrent: f.observed.mappings[1].admission.assertCurrent });
+    assertCurrent: f.observed.mappings[1].admission.assertCurrent,
+    assertCompletionCurrent: f.observed.mappings[1].admission.assertCompletionCurrent });
   assert.equal(f.observed.mappings[0].actual, context);
   assert.deepEqual(f.observed.contexts[0].boundAdmission, f.observed.mappings[1].admission);
   await f.tools().execute(f.nativeCall);
@@ -726,3 +760,133 @@ test("bound admission guard preserves the original Stop cancellation reason", as
   assert.equal(command.signal.reason.message, "Work stopped.");
   assert.equal(f.observed.executions.length, 0, "Stop and its authority guard must not execute an application effect");
 });
+
+
+test("an invoked bound effect failing after accepted steering retains its error without failing the successor", async t => {
+  const entered = Promise.withResolvers(), effect = Promise.withResolvers();
+  const f = await boundToolFixture(t, { execute: async (_input, actual) => {
+    entered.resolve(actual);
+    return effect.promise;
+  } });
+  const events = [];
+  f.conversation.subscribe(event => events.push(event));
+  await f.conversation.send(message);
+  await f.currentCommand();
+  await f.loadContract();
+  const executing = f.tools().execute(f.nativeCall);
+  void executing.catch(() => {});
+  const origin = await entered.promise;
+  await f.conversation.send({ messageId: "late-effect-successor", text: "Continue with this current instruction.", steer: true });
+  await f.currentCommand(1);
+  effect.reject(Object.assign(new Error("Old effect acknowledgement failed"), { code: "old_effect_failure", statusCode: 503 }));
+  await assert.rejects(executing, { code: "conversation_tool_outcome_unknown" });
+  f.finish.resolve();
+  const result = await f.conversation.wait();
+  assert.equal(events.findLast(event => event.type === "settled").status, "complete");
+  assert.equal(result.error, "");
+  const old = result.conversationLog.find(turn => turn.turnId === origin.boundAdmission.turnId);
+  const successor = result.conversationLog.find(turn => turn.messages.some(message => message.messageId === "late-effect-successor"));
+  const receipt = old.metadata.applicationTools.find(call => call.id === f.nativeCall.id);
+  assert.equal(receipt.status, "unknown");
+  assert.equal(receipt.result.error.code, "old_effect_failure");
+  assert.equal(successor.metadata.applicationTools, undefined, "The earlier effect error stays on its originating receipt");
+  assert.equal(origin.boundAdmission.messageId, message.messageId);
+  assert.equal(f.observed.executions.length, 1, "Neither steering nor failed acknowledgement repeats the admitted effect");
+});
+
+test("a current bound effect failure still fails its own run and retains its original error receipt", async t => {
+  const f = await boundToolFixture(t, { execute: async () => {
+    throw Object.assign(new Error("Current effect acknowledgement failed"), { code: "current_effect_failure", statusCode: 503 });
+  } });
+  const events = [];
+  f.conversation.subscribe(event => events.push(event));
+  await f.conversation.send(message);
+  await f.currentCommand();
+  await f.loadContract();
+  await assert.rejects(f.tools().execute(f.nativeCall), { code: "conversation_tool_outcome_unknown" });
+  f.finish.resolve();
+  const result = await f.conversation.wait();
+  assert.equal(events.findLast(event => event.type === "settled").status, "failed");
+  assert.match(result.error, /Inspect its target/);
+  const receipt = result.conversationLog[0].metadata.applicationTools.find(call => call.id === f.nativeCall.id);
+  assert.equal(receipt.status, "unknown");
+  assert.equal(receipt.result.error.code, "current_effect_failure");
+  assert.equal(f.observed.executions.length, 1);
+});
+
+
+test("bound admission completion guard retains only its latest successful native settlement", async t => {
+  for (const boundary of ["completed", "steered", "stopped", "closed", "successor-active", "successor-completed", "recovered-successor", "rejected-successor"]) {
+    await t.test(boundary, async t => {
+      const f = await boundToolFixture(t);
+      await f.conversation.send(message);
+      const command = await f.currentCommand();
+      await f.loadContract();
+      await f.tools().execute(f.nativeCall);
+      const original = f.observed.mappings[0].admission;
+      assert.equal(typeof original.assertCompletionCurrent, "function");
+      assert.equal(JSON.parse(JSON.stringify(original)).assertCompletionCurrent, undefined);
+      assert.throws(() => original.assertCompletionCurrent(), { code: "conversation_tool_request_retired" },
+        "A working native turn cannot authorize completion");
+      if (boundary === "stopped") {
+        await f.conversation.cancel();
+        assert.throws(() => original.assertCompletionCurrent(), error => error === command.signal.reason);
+        return;
+      }
+      if (boundary === "steered") {
+        await f.conversation.send({ messageId: "completion-steer", text: "Use this newer instruction.", steer: true });
+        await f.currentCommand(1);
+      }
+      f.finish.resolve();
+      await f.conversation.wait();
+      assert.throws(() => original.assertCurrent(), { code: "conversation_tool_request_retired" },
+        "Native settlement never restores live tool authority");
+      if (boundary === "steered") {
+        assert.throws(() => original.assertCompletionCurrent(), { code: "conversation_tool_request_retired" });
+        return;
+      }
+      original.assertCompletionCurrent();
+      if (boundary === "closed") {
+        await f.runtime.close();
+        assert.throws(() => original.assertCompletionCurrent(), { code: "conversation_tool_request_retired" });
+      } else if (boundary === "rejected-successor") {
+        f.binding.prepareInput = async () => { throw new Error("The newer input was rejected before native dispatch."); };
+        await assert.rejects(f.conversation.send({ messageId: "unaccepted-successor", text: "Never admitted." }),
+          /rejected before native dispatch/u);
+        await f.conversation.wait();
+        original.assertCompletionCurrent();
+        assert.equal(f.observed.commands.length, 1, "Rejected input cannot replace the accepted receipt owner");
+      } else if (boundary === "recovered-successor") {
+        f.binding.native.owner.run = async (_control, current) => {
+          await current.beforeDispatch({ threadId: "native-thread" });
+          await f.binding.transcript.writeUserMessage({ messageId: current.input.messageId, text: current.input.text });
+          return { value: { ok: true, delivered: true } };
+        };
+        const receipt = await f.conversation.send({ messageId: "recovered-successor", text: "An original recovered native receipt." });
+        assert.equal(receipt.recovered, true);
+        await f.conversation.wait();
+        assert.throws(() => original.assertCompletionCurrent(), { code: "conversation_tool_request_retired" },
+          "Verified recovered admission also retires the previous completion receipt");
+      } else if (boundary.startsWith("successor-")) {
+        const gate = Promise.withResolvers();
+        const run = f.binding.native.owner.run;
+        f.binding.native.owner.run = async (...args) => {
+          await run(...args);
+          if (boundary === "successor-active") await gate.promise;
+        };
+        try {
+          await f.conversation.send({ messageId: "accepted-successor", text: "A genuinely accepted later input." });
+          await f.currentCommand(1);
+          if (boundary === "successor-active") {
+            assert.throws(() => original.assertCompletionCurrent(), { code: "conversation_tool_request_retired" });
+            gate.resolve();
+          }
+          await f.conversation.wait();
+          assert.throws(() => original.assertCompletionCurrent(), { code: "conversation_tool_request_retired" },
+            "A later accepted receipt stays current after its active slot clears");
+        } finally { gate.resolve(); }
+      }
+      assert.equal(f.observed.executions.length, 1, "Completion checks cannot dispatch or replay application effects");
+    });
+  }
+});

package/test/openCodeClient.test.js

@@ -513,3 +513,189 @@ test("OpenCode retained storage validates complete inventories and bounded cance
   await assert.rejects(cancelledPage, { name: "AbortError" });
 
 });
+
+
+test("stopped OpenCode native database retains the original MessageV2 projection without native writes", async t => {
+  const { mkdtemp, readFile, lstat, readdir, rm } = await import("node:fs/promises");
+  const { tmpdir } = await import("node:os");
+  const path = await import("node:path");
+  const { DatabaseSync } = await import("node:sqlite");
+  const { readOpenCodeConversationDatabase } = await import("../src/server/hosts/openCodeClient.js");
+  const { readStoppedNativeDatabase } = await import("../src/server/hosts/nativeHistory.js");
+  const root = await mkdtemp(path.join(tmpdir(), "assistant-native-opencode-"));
+  t.after(() => rm(root, { recursive: true, force: true }));
+  const file = path.join(root, "native space.db");
+  const db = new DatabaseSync(file);
+  db.exec(`CREATE TABLE session (id TEXT PRIMARY KEY, directory TEXT, project_id TEXT);
+    CREATE TABLE message (id TEXT PRIMARY KEY, session_id TEXT, time_created INTEGER, data TEXT);
+    CREATE TABLE part (id TEXT PRIMARY KEY, message_id TEXT, session_id TEXT, data TEXT);
+    CREATE TABLE session_input (session_id TEXT, promoted_seq INTEGER);`);
+  db.prepare("INSERT INTO session VALUES (?, ?, ?)").run("ses_original", "/private/actor/colleague_scope", "project_original");
+  const insert = db.prepare("INSERT INTO message VALUES (?, ?, ?, ?)");
+  insert.run("msg_original_user", "ses_original", 1, JSON.stringify({ id: "untrusted-payload-id", role: "user", time: { created: 1 } }));
+  insert.run("msg_original_answer", "ses_original", 2, JSON.stringify({ role: "assistant", parentID: "msg_original_user", finish: "stop", time: { created: 2, completed: 3 } }));
+  db.prepare("INSERT INTO part VALUES (?, ?, ?, ?)").run("prt_original_text", "msg_original_answer", "ses_original",
+    JSON.stringify({ type: "text", text: "Exact answer 🦊", id: "untrusted-part-id" }));
+  db.close();
+  const before = await readFile(file);
+  const stat = await lstat(file);
+  const messages = [];
+  const result = await readOpenCodeConversationDatabase({ databasePath: file, conversationId: "ses_original", onMessage: row => messages.push(row) });
+  assert.equal(result.session.directory, "/private/actor/colleague_scope");
+  assert.equal(result.session.project_id, "project_original");
+  assert.equal(result.recordCount, 2);
+  assert.match(result.revision, /^[a-f0-9]{64}$/u);
+  assert.deepEqual(messages.map(row => [row.id, row.sessionID, row.type]), [
+    ["msg_original_user", "ses_original", "user"], ["msg_original_answer", "ses_original", "assistant"]
+  ]);
+  assert.equal(messages[1].parentID, "msg_original_user");
+  assert.deepEqual(messages[1].content, [{ type: "text", text: "Exact answer 🦊", id: "prt_original_text", sessionID: "ses_original", messageID: "msg_original_answer" }]);
+  await assert.rejects(readStoppedNativeDatabase(file, database => database.exec("DELETE FROM message")), /readonly|read-only/iu);
+  const cancelled = new Error("Caller stopped original inspection");
+  await assert.rejects(readOpenCodeConversationDatabase({ databasePath: file, conversationId: "ses_original", onMessage() {}, signal: AbortSignal.abort(cancelled) }), error => error === cancelled);
+  assert.deepEqual(await readFile(file), before);
+  const after = await lstat(file);
+  for (const key of ["dev", "ino", "size", "mtimeMs", "ctimeMs", "mode"]) assert.equal(after[key], stat[key]);
+  assert.deepEqual(await readdir(root), ["native space.db"]);
+});
+
+test("stopped OpenCode database refuses pending native work and foreign parts with no storage changes", async t => {
+  const { mkdtemp, readFile, rm } = await import("node:fs/promises");
+  const { tmpdir } = await import("node:os");
+  const path = await import("node:path");
+  const { DatabaseSync } = await import("node:sqlite");
+  const { readOpenCodeConversationDatabase } = await import("../src/server/hosts/openCodeClient.js");
+  const root = await mkdtemp(path.join(tmpdir(), "assistant-native-opencode-refusal-"));
+  t.after(() => rm(root, { recursive: true, force: true }));
+  const file = path.join(root, "native.db");
+  const db = new DatabaseSync(file);
+  db.exec(`CREATE TABLE session (id TEXT PRIMARY KEY, directory TEXT);
+    CREATE TABLE message (id TEXT PRIMARY KEY, session_id TEXT, time_created INTEGER, data TEXT);
+    CREATE TABLE part (id TEXT PRIMARY KEY, message_id TEXT, session_id TEXT, data TEXT);
+    CREATE TABLE session_input (session_id TEXT, promoted_seq INTEGER);
+    INSERT INTO session VALUES ('ses_original', '/private/actor/scope');
+    INSERT INTO session_input VALUES ('ses_original', NULL);`);
+  db.close();
+  let seen = 0;
+  const before = await readFile(file);
+  await assert.rejects(readOpenCodeConversationDatabase({ databasePath: file, conversationId: "ses_original", onMessage() { seen += 1; } }), /unpromoted native request/u);
+  assert.equal(seen, 0);
+  assert.deepEqual(await readFile(file), before);
+  const edited = new DatabaseSync(file);
+  edited.exec("DELETE FROM session_input");
+  edited.prepare("INSERT INTO message VALUES (?, ?, ?, ?)").run("msg_original", "ses_original", 1, JSON.stringify({ role: "assistant", finish: "stop" }));
+  edited.prepare("INSERT INTO part VALUES (?, ?, ?, ?)").run("prt_foreign", "msg_original", "ses_other", JSON.stringify({ type: "text", text: "Other private owner" }));
+  edited.close();
+  const foreignBefore = await readFile(file);
+  await assert.rejects(readOpenCodeConversationDatabase({ databasePath: file, conversationId: "ses_original", onMessage() { seen += 1; } }), /could not be inspected completely/u);
+  assert.equal(seen, 0);
+  assert.deepEqual(await readFile(file), foreignBefore);
+});
+
+test("stopped native inspection rejects live journals and noncanonical files before opening storage", async t => {
+  const { mkdtemp, readFile, writeFile, readdir, symlink, rm } = await import("node:fs/promises");
+  const { tmpdir } = await import("node:os");
+  const path = await import("node:path");
+  const { DatabaseSync } = await import("node:sqlite");
+  const { readStoppedNativeDatabase } = await import("../src/server/hosts/nativeHistory.js");
+  const root = await mkdtemp(path.join(tmpdir(), "assistant-native-journal-"));
+  t.after(() => rm(root, { recursive: true, force: true }));
+  const file = path.join(root, "native.db");
+  const db = new DatabaseSync(file);
+  db.exec("CREATE TABLE retained (id TEXT)");
+  db.close();
+  const before = await readFile(file);
+  const sidecar = Buffer.from("Uncheckpointed native storage, retained exactly");
+  await writeFile(`${file}-wal`, sidecar);
+  let read = false;
+  await assert.rejects(readStoppedNativeDatabase(file, () => { read = true; }), /journal sidecar/u);
+  assert.equal(read, false);
+  assert.deepEqual(await readFile(file), before);
+  assert.deepEqual(await readFile(`${file}-wal`), sidecar);
+  await symlink(file, path.join(root, "link.db"));
+  await assert.rejects(readStoppedNativeDatabase(path.join(root, "link.db"), () => { read = true; }), /regular file.*canonical path/u);
+  assert.equal(read, false);
+  assert.deepEqual((await readdir(root)).sort(), ["link.db", "native.db", "native.db-wal"]);
+});
+
+
+test("stopped native WAL inspection reads newest committed OpenCode rows without changing native files and removes private snapshots", async t => {
+  const { mkdtemp, readFile, writeFile, lstat, readdir, rm } = await import("node:fs/promises");
+  const { tmpdir } = await import("node:os");
+  const path = await import("node:path");
+  const { spawnSync } = await import("node:child_process");
+  const { DatabaseSync } = await import("node:sqlite");
+  const { readOpenCodeConversationDatabase } = await import("../src/server/hosts/openCodeClient.js");
+  const { readStoppedNativeDatabase } = await import("../src/server/hosts/nativeHistory.js");
+  const root = await mkdtemp(path.join(tmpdir(), "assistant-native-stopped-wal-"));
+  t.after(() => rm(root, { recursive: true, force: true }));
+  const file = path.join(root, "native.db");
+  const db = new DatabaseSync(file);
+  db.exec(`CREATE TABLE session (id TEXT PRIMARY KEY, directory TEXT);
+    CREATE TABLE message (id TEXT PRIMARY KEY, session_id TEXT, time_created INTEGER, data TEXT);
+    CREATE TABLE part (id TEXT PRIMARY KEY, message_id TEXT, session_id TEXT, data TEXT);
+    INSERT INTO session VALUES ('ses_original', '/private/actor/colleague_scope');`);
+  db.close();
+  // Leave real committed SQLite WAL frames after the only fixture writer exits.
+  // The base contains the schema, but neither of these newly committed messages.
+  const writer = spawnSync(process.execPath, ["--input-type=module", "-e", `
+    import { DatabaseSync } from "node:sqlite";
+    const database = new DatabaseSync(process.argv[1]);
+    database.exec("PRAGMA journal_mode=WAL; PRAGMA wal_autocheckpoint=0; BEGIN");
+    const insert = database.prepare("INSERT INTO message VALUES (?, ?, ?, ?)");
+    insert.run("msg_user", "ses_original", 1, JSON.stringify({ role: "user", time: { created: 1 } }));
+    insert.run("msg_answer", "ses_original", 2, JSON.stringify({ role: "assistant", parentID: "msg_user", finish: "stop", time: { created: 2, completed: 3 } }));
+    database.prepare("INSERT INTO part VALUES (?, ?, ?, ?)").run("prt_text", "msg_answer", "ses_original", JSON.stringify({ type: "text", text: "Newest committed answer 🦊" }));
+    database.exec("COMMIT");
+    process.kill(process.pid, "SIGKILL");
+  `, file], { encoding: "utf8", timeout: 10_000 });
+  assert.equal(writer.signal, "SIGKILL", writer.stderr);
+  const before = {};
+  for (const suffix of ["", "-wal", "-shm"]) before[suffix] = { bytes: await readFile(file + suffix), stat: await lstat(file + suffix) };
+  assert.ok(before["-wal"].bytes.length > 32);
+  const nativeNames = await readdir(root);
+  let snapshot;
+  const count = await readStoppedNativeDatabase(file, database => {
+    snapshot = database.prepare("PRAGMA database_list").get().file;
+    assert.notEqual(snapshot, file, "WAL inspection opens only the private snapshot");
+    assert.equal(database.prepare("SELECT COUNT(*) AS count FROM message").get().count, 2);
+    assert.throws(() => database.exec("DELETE FROM message"), /readonly|read-only/iu);
+    return 2;
+  });
+  assert.equal(count, 2);
+  await assert.rejects(lstat(path.dirname(snapshot)), { code: "ENOENT" });
+  const messages = [];
+  const result = await readOpenCodeConversationDatabase({ databasePath: file, conversationId: "ses_original", onMessage: row => messages.push(row) });
+  assert.equal(result.recordCount, 2);
+  assert.deepEqual(messages.map(row => row.id), ["msg_user", "msg_answer"]);
+  assert.equal(messages[1].content[0].text, "Newest committed answer 🦊");
+  const cancelled = new Error("Cancel the private stopped snapshot");
+  const controller = new AbortController();
+  await assert.rejects(readStoppedNativeDatabase(file, database => {
+    snapshot = database.prepare("PRAGMA database_list").get().file;
+    controller.abort(cancelled);
+  }, { signal: controller.signal }), error => error === cancelled);
+  await assert.rejects(lstat(path.dirname(snapshot)), { code: "ENOENT" });
+  const interruptedProjection = new AbortController();
+  await assert.rejects(readOpenCodeConversationDatabase({ databasePath: file, conversationId: "ses_original", signal: interruptedProjection.signal,
+    onMessage() { interruptedProjection.abort(cancelled); } }), error => error === cancelled);
+  for (const suffix of ["", "-wal", "-shm"]) {
+    assert.deepEqual(await readFile(file + suffix), before[suffix].bytes);
+    const after = await lstat(file + suffix);
+    for (const key of ["dev", "ino", "size", "mtimeMs", "ctimeMs", "mode"]) assert.equal(after[key], before[suffix].stat[key]);
+  }
+  assert.deepEqual(await readdir(root), nativeNames);
+  const invalidWal = Buffer.from(before["-wal"].bytes);
+  invalidWal.writeUInt32BE(0, 0);
+  await writeFile(file + "-wal", invalidWal);
+  let invalidRead = false;
+  await assert.rejects(readStoppedNativeDatabase(file, () => { invalidRead = true; }), /journal sidecar/u);
+  assert.equal(invalidRead, false, "Malformed paired WAL refuses before the reader callback");
+  assert.deepEqual(await readFile(file + "-wal"), invalidWal);
+  await writeFile(file + "-wal", before["-wal"].bytes);
+  await assert.rejects(readStoppedNativeDatabase(file, async database => {
+    snapshot = database.prepare("PRAGMA database_list").get().file;
+    await writeFile(file + "-wal", Buffer.concat([before["-wal"].bytes, Buffer.from("Fixture writer changed native storage")]));
+  }), /Native storage changed during inspection/u);
+  await assert.rejects(lstat(path.dirname(snapshot)), { code: "ENOENT" });
+});