@jskit-ai/assistant-core 0.1.209 → 0.1.212

package/test/conversationTools.test.js

@@ -428,3 +428,301 @@ test("strict application calls settle safe receipts before rethrowing the exact
     }
   }
 });
+
+// Bound-host contract coverage: the original Claude driver carries its run
+// command, while the host owns admission/output. Native tool dispatch is not
+// supplied by this fixture and remains a separate integration prerequisite.
+import { createConversationTranscript } from "../src/server/conversation/transcript.js";
+
+async function boundToolFixture(t, options = {}) {
+  const memory = createMemoryConversationStorage();
+  const observed = { executions: [], contexts: [], mappings: [], commands: [], denied: false, failResults: false };
+  const storage = { read: memory.read, write: (scope, callback) => memory.write(observed.receiptScope || scope, async transaction => {
+    const result = await callback(transaction);
+    if (options.revokeAfterReservation) for (const id of await transaction.listTurnIds()) {
+      if ((await transaction.readTurn(id)).metadata.applicationTools?.some(call => call.id === "bound-call" && call.status === "running")) observed.denied = true;
+    }
+    if (observed.failResults) for (const id of await transaction.listTurnIds()) {
+      if ((await transaction.readTurn(id)).metadata.applicationTools?.some(call => call.id === "bound-call" && call.result)) throw new Error("Receipt disk unavailable");
+    }
+    return result;
+  }) };
+  const transcript = createConversationTranscript({ storage: memory });
+  const catalog = createServiceToolCatalog(actionCatalog(async (input, actual) => {
+    observed.executions.push(input);
+    observed.contexts.push(actual);
+    return options.execute ? options.execute(input, actual) : { total: input.left + input.right };
+  }));
+  let delivery;
+  let active = false;
+  let command;
+  const finish = Promise.withResolvers();
+  async function admit(current) {
+    await current.beforeDispatch({ threadId: "native-thread" });
+    const conversationTurn = await transcript.writeConversationUserMessage("one", { text: current.input.text,
+      messageId: current.input.messageId, turnMetadata: { nativeSentinel: "host-owned" } });
+    await current.accept({ conversationTurn, nativeTurnId: "native-turn", nativeResult: { value: { ok: true, delivered: true } } });
+    observed.commands.push(current);
+  }
+  const owner = {
+    acquire: async () => ({ id: "native-thread", context: { workdir: "/bound" } }),
+    snapshot: () => ({ active }),
+    async run(_control, current) {
+      command = current;
+      active = true;
+      await admit(current);
+      const abort = () => finish.resolve();
+      current.signal.addEventListener("abort", abort, { once: true });
+      if (current.signal.aborted) abort();
+      try { await finish.promise; }
+      finally { current.signal.removeEventListener("abort", abort); active = false; }
+    },
+    async steer(_control, current) { await admit(current); return { value: { ok: true, delivered: true } }; },
+    closeSession: async () => ({ ok: true }),
+    cancel: async () => { finish.resolve(); return { ok: true }; }
+  };
+  const binding = { sessionId: "one", namespace: "bound-one", engine: "claude",
+    runtime: { store: {} }, native: { owner, preparation: { cleanup: () => ({ context, application: {} }) } },
+    admission() {}, prepareInput: async input => input,
+    read: async () => ({ threadId: "native-thread", configuration: { model: "native" }, turn: { active }, delivery }),
+    readStream: async () => ({ messages: [] }),
+    state: { read: async () => delivery, write: async value => { delivery = structuredClone(value); } },
+    transcript: {
+      history: async () => [], readConversationLog: () => transcript.readConversationLog("one"),
+      hasMessage: id => transcript.conversationMessageIdExists("one", id),
+      writeUserMessage: input => transcript.writeConversationUserMessage("one", input)
+    },
+    ...(options.unconfigured ? {} : { applicationTools: { storage, prepareContext(actual, admission) {
+      observed.mappings.push({ actual, admission });
+      assert.equal(Object.isFrozen(admission), true);
+      if (observed.denied) throw new Error("Bound write authority revoked");
+      return { ...actual, boundAdmission: admission, fresh: observed.mappings.length };
+    } } })
+  };
+  const runtime = createConversationRuntime({ toolCatalog: catalog, authorize: () => true,
+    host: { conversation: () => binding } });
+  t.after(async () => { finish.resolve(); await runtime.close(); });
+  const conversation = await runtime.open({ id: "one", context });
+  async function currentCommand(index = 0) {
+    while (!observed.commands[index]) await new Promise(resolve => setImmediate(resolve));
+    return observed.commands[index];
+  }
+  const nativeCall = { id: "bound-call", name: "assistant_action_execute", arguments: JSON.stringify({ actionId: "numbers.add", input: { left: 2, right: 3 } }) };
+  return { runtime, conversation, storage, memory, observed, binding, finish, currentCommand, nativeCall,
+    tools: () => command.tools,
+    async loadContract() {
+      const result = await command.tools.execute({ id: "bound-contract", name: "assistant_action_contract",
+        arguments: JSON.stringify({ actionId: "numbers.add", version: 1 }) });
+      assert.equal(result.ok, true);
+      observed.mappings.length = 0;
+    } };
+}
+
+test("bound tools use exact accepted host rows and fresh server context without writing native output or status", async t => {
+  const f = await boundToolFixture(t);
+  await f.conversation.send({ ...message, data: { turnId: "caller-forgery", nativeTurnId: "caller-forgery" } });
+  await f.currentCommand();
+  await f.loadContract();
+  const before = (await f.conversation.read()).conversationLog[0];
+  const result = await f.tools().execute(f.nativeCall);
+  assert.deepEqual(result, { ok: true, result: { actionId: "numbers.add", version: 1, result: { total: 5 } } });
+  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 });
+  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);
+  assert.equal(f.observed.mappings.length, 3, "Receipt replay still checks fresh bound authority");
+  assert.equal(f.observed.executions.length, 1);
+  f.observed.denied = true;
+  await assert.rejects(f.tools().execute(f.nativeCall), /write authority revoked/);
+  f.finish.resolve();
+  const saved = (await f.conversation.wait()).conversationLog[0];
+  const { applicationTools, ...metadata } = saved.metadata;
+  const { applicationTools: previousTools, ...previousMetadata } = before.metadata;
+  assert.deepEqual(metadata, previousMetadata);
+  assert.equal(saved.assistant, before.assistant);
+  assert.deepEqual(applicationTools[0], previousTools[0]);
+  assert.equal(applicationTools.length, 2);
+  assert.equal(applicationTools[1].status, "complete");
+});
+
+test("bound tool result-save retry uses its original accepted request after steering without repeating the effect", async t => {
+  const f = await boundToolFixture(t);
+  await f.conversation.send(message);
+  await f.currentCommand();
+  await f.loadContract();
+  // The existing reservation is durable; simulate only result commits failing.
+  f.observed.failResults = true;
+  const firstCall = f.tools().execute(f.nativeCall);
+  await assert.rejects(firstCall, /Receipt disk unavailable/);
+  assert.equal(f.observed.executions.length, 1);
+  await f.conversation.send({ messageId: "steered", text: "Keep the original operation.", steer: true });
+  await f.currentCommand(1);
+  f.finish.resolve();
+  const unavailable = await f.conversation.wait();
+  assert.equal(unavailable.status, "unavailable");
+  assert.equal(unavailable.conversationLog[0].metadata.applicationTools[1].status, "running");
+  assert.equal(unavailable.conversationLog[1].metadata.applicationTools, undefined);
+  await assert.rejects(f.conversation.send({ messageId: "blocked", text: "Another operation" }), { code: "conversation_storage_unavailable" });
+  f.observed.failResults = false;
+  assert.deepEqual(await f.conversation.retrySave(), { saved: true });
+  const saved = (await f.conversation.read()).conversationLog;
+  assert.equal(saved[0].metadata.applicationTools[1].status, "complete");
+  assert.equal(saved[1].metadata.applicationTools, undefined);
+  assert.equal(f.observed.executions.length, 1);
+  assert.equal(f.observed.mappings.every(({ admission }) => admission.messageId === message.messageId), true);
+});
+
+test("bound receipt transaction refuses a mismatched authored message before effects", async t => {
+  const f = await boundToolFixture(t);
+  await f.conversation.send(message);
+  await f.currentCommand();
+  await f.loadContract();
+  const turn = (await f.conversation.read()).conversationLog[0];
+  await f.memory.write("other", async transaction => {
+    await transaction.appendMessage(turn.turnId, { role: "user", messageId: "other-author", text: "Other", at: new Date().toISOString() });
+  });
+  f.observed.receiptScope = "other";
+  await assert.rejects(f.tools().execute(f.nativeCall), /receipt does not belong/);
+  assert.equal(f.observed.executions.length, 0);
+  assert.equal((await f.conversation.read()).conversationLog[0].metadata.applicationTools.some(call => call.id === f.nativeCall.id), false);
+  f.finish.resolve();
+  assert.equal((await f.conversation.wait()).status, "unavailable");
+  f.observed.receiptScope = "";
+  await f.conversation.retrySave();
+});
+
+test("an unconfigured bound host keeps its original tool-free common-runtime branch", async t => {
+  const f = await boundToolFixture(t, { unconfigured: true });
+  await f.conversation.send(message);
+  await f.currentCommand();
+  assert.equal(f.tools(), undefined);
+  f.finish.resolve();
+  const saved = (await f.conversation.wait()).conversationLog[0];
+  assert.deepEqual(saved.metadata, { nativeSentinel: "host-owned" });
+  assert.equal(f.observed.mappings.length, 0);
+});
+
+test("fresh bound authority revoked after reservation saves a not-executed receipt", async t => {
+  const f = await boundToolFixture(t, { revokeAfterReservation: true });
+  await f.conversation.send(message);
+  await f.currentCommand();
+  await f.loadContract();
+  await assert.rejects(f.tools().execute(f.nativeCall), /write authority revoked/);
+  assert.equal(f.observed.mappings.length, 2);
+  assert.equal(f.observed.executions.length, 0);
+  f.finish.resolve();
+  const saved = (await f.conversation.wait()).conversationLog[0];
+  assert.equal(saved.metadata.applicationTools[1].status, "not-executed");
+  assert.equal(saved.metadata.applicationTools[1].result.error.code, "conversation_tool_not_executed");
+  assert.equal(saved.metadata.runtime, undefined);
+});
+
+test("an invoked bound tool retains its originating actor and receipt across steering and Stop drains it", async t => {
+  const entered = Promise.withResolvers(), effect = Promise.withResolvers();
+  const f = await boundToolFixture(t, { execute: async (_input, actual) => {
+    entered.resolve(actual);
+    return effect.promise;
+  } });
+  await f.conversation.send(message);
+  await f.currentCommand();
+  await f.loadContract();
+  const executing = f.tools().execute(f.nativeCall);
+  const actual = await entered.promise;
+  const originalTurnId = actual.boundAdmission.turnId;
+  const nextActor = { ...context, actor: { id: "other-authorized-actor" } };
+  const otherHandle = await f.runtime.open({ id: "one", context: nextActor });
+  await otherHandle.send({ messageId: "another-steer", text: "Keep going.", steer: true });
+  await f.currentCommand(1);
+  let stopped = false;
+  const stopping = otherHandle.cancel().then(() => { stopped = true; });
+  await new Promise(resolve => setImmediate(resolve));
+  assert.equal(stopped, false, "Original Stop must join an already invoked action");
+  effect.resolve({ total: 5 });
+  await executing;
+  await stopping;
+  const saved = (await f.conversation.wait()).conversationLog;
+  assert.equal(actual.actor.id, context.actor.id);
+  assert.equal(actual.boundAdmission.messageId, message.messageId);
+  assert.equal(saved[0].turnId, originalTurnId);
+  assert.equal(saved[0].metadata.applicationTools[1].status, "complete");
+  assert.equal(saved[1].metadata.applicationTools, undefined);
+  assert.equal(f.observed.mappings.every(({ actual }) => actual === context), true);
+  assert.equal(f.observed.executions.length, 1);
+});
+
+
+test("bound native identity comes from the accepted owner rather than authored data", async t => {
+  const f = await boundToolFixture(t);
+  await f.conversation.send({ ...message, data: { nativeThreadId: "forged-thread", nativeTurnId: "forged-turn" } });
+  await f.currentCommand();
+  await f.loadContract();
+  await f.tools().execute(f.nativeCall);
+  await f.tools().execute(f.nativeCall);
+  assert.equal(f.observed.executions.length, 1, "Replaying the receipt must not repeat its effect");
+  assert.equal(f.observed.mappings.length, 3, "Receipt replay still refreshes its admitted identity");
+  for (const { admission } of f.observed.mappings) {
+    assert.equal(Object.isFrozen(admission), true);
+    assert.equal(admission.nativeThreadId, "native-thread");
+    assert.equal(admission.nativeTurnId, "native-turn");
+    assert.equal(admission.messageId, message.messageId);
+  }
+  const first = f.observed.mappings[0].admission;
+  await f.conversation.send({ messageId: "thread-steer", text: "Keep going.", steer: true, data: { nativeThreadId: "another-forgery" } });
+  await f.currentCommand(1);
+  await f.tools().execute({ id: "steer-contract", name: "assistant_action_contract",
+    arguments: JSON.stringify({ actionId: "numbers.add", version: 1 }) });
+  const latest = f.observed.mappings.at(-1).admission;
+  assert.equal(latest.nativeThreadId, "native-thread");
+  assert.equal(latest.messageId, "thread-steer");
+  assert.equal(first.messageId, message.messageId, "Later steering must not retarget an earlier tool receipt");
+  assert.equal(first.nativeThreadId, "native-thread");
+});
+
+
+test("bound admission current guard fences a held host effect after steering or completion", async t => {
+  const f = await boundToolFixture(t);
+  await f.conversation.send(message);
+  await f.currentCommand();
+  await f.loadContract();
+  await f.tools().execute(f.nativeCall);
+  const original = f.observed.mappings[0].admission;
+  assert.equal(typeof original.assertCurrent, "function");
+  original.assertCurrent();
+  assert.equal(JSON.parse(JSON.stringify(original)).assertCurrent, undefined, "The guard is server-owned, not serialized authority");
+  const boundary = Promise.withResolvers();
+  const held = Promise.resolve().then(async () => { await boundary.promise; original.assertCurrent(); });
+  held.catch(() => {});
+  await f.conversation.send({ messageId: "guard-steer", text: "A new instruction.", steer: true });
+  await f.currentCommand(1);
+  boundary.resolve();
+  await assert.rejects(held, { code: "conversation_tool_request_retired" });
+  await f.tools().execute({ id: "guard-contract", name: "assistant_action_contract",
+    arguments: JSON.stringify({ actionId: "numbers.add", version: 1 }) });
+  const current = f.observed.mappings.at(-1).admission;
+  current.assertCurrent();
+  assert.equal(current.messageId, "guard-steer");
+  f.finish.resolve();
+  await f.conversation.wait();
+  assert.throws(() => current.assertCurrent(), { code: "conversation_tool_request_retired" });
+  assert.equal(f.observed.executions.length, 1, "Inspecting current authority must not dispatch or repeat work");
+});
+
+
+test("bound admission guard preserves the original Stop cancellation reason", async t => {
+  const f = await boundToolFixture(t);
+  await f.conversation.send(message);
+  const command = await f.currentCommand();
+  await f.loadContract();
+  await f.tools().execute({ id: "stop-contract", name: "assistant_action_contract",
+    arguments: JSON.stringify({ actionId: "numbers.add", version: 1 }) });
+  const admission = f.observed.mappings.at(-1).admission;
+  admission.assertCurrent();
+  await f.conversation.cancel();
+  assert.equal(command.signal.aborted, true);
+  assert.throws(() => admission.assertCurrent(), error => error === command.signal.reason);
+  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");
+});

package/test/messageDelivery.test.js

@@ -4,6 +4,24 @@ import { nextTick, ref } from "vue";
 import { createAssistantMessageDelivery, unmatchedOptimisticMessages } from "../src/client/conversation/messageDelivery.js";
 import { normalizeConversationTurn } from "../src/shared/conversation/patches.js";
 
+test("proven no-admission releases only the exact uncertain message without accepting or losing its payload", async () => {
+  let accepted = 0;
+  const delivery = createAssistantMessageDelivery({ deliver: async () => { throw new Error("Connection lost"); } });
+  const payload = { message: "Keep these words", displayAttachments: [{ attachmentId: "keep-file" }] };
+  await assert.rejects(delivery.send(payload, { messageId: "not-sent", uncertainOnError: true, onAccepted: () => accepted++ }));
+  delivery.restoreUncertain({ messageId: "still-unknown", text: "An attempted message" });
+  assert.equal(delivery.rejectUnsent("different-id", "Not sent"), false);
+  assert.equal(delivery.rejectUnsent("not-sent", "Not sent"), true);
+  assert.equal(delivery.find("not-sent").status, "failed");
+  assert.deepEqual(delivery.find("not-sent").payload, payload);
+  assert.equal(delivery.find("still-unknown").status, "uncertain");
+  assert.equal(accepted, 0);
+  delivery.accept("not-sent");
+  assert.equal(delivery.rejectUnsent("not-sent", "Not sent"), false);
+  assert.equal(delivery.find("not-sent").status, "accepted");
+  assert.equal(accepted, 1);
+});
+
 test("sending immediately renders the message and reconciles only its authoritative receipt", async () => {
   const request = Promise.withResolvers();
   const delivery = createAssistantMessageDelivery({ deliver: () => request.promise });

package/test/openCodeRuntime.test.js

@@ -320,3 +320,32 @@ test("OpenCode bindings share atomic publication without overwriting another con
   assert.throws(() => runtime.writeBindings(path.join(root, "another.json"), "foreign", []), /one absolute private binding registry/);
   assert.deepEqual(await readOpenCodeEnvironments(""), []);
 });
+
+
+test("native output identity is opt-in for every existing OpenCode projection writer", async () => {
+  const runtime = createOpenCodeSharedRuntime();
+  for (const configured of [false, true]) {
+    const writes = [];
+    const streams = [];
+    const native = { id: "native-final", type: "assistant", text: "Exact native final words.", time: { created: 1_000 } };
+    const unchanged = structuredClone(native);
+    const projection = {
+      messageId: (id, role) => `${id}:${role}`,
+      ...(configured ? { outputId: (id, role) => `${id}:${role}` } : {}),
+      readError: () => "", reasoning: async () => {},
+      store: {
+        async writeConversationAssistantMessage(id, message) { writes.push({ id, message }); return { id, message }; },
+        updateConversationStream(id, message) { streams.push({ id, message }); return { id, message }; },
+        completeConversationStreamMessage() {}
+      },
+      publishTurn: async () => {}, publishStream: async () => {}
+    };
+    await runtime.writeConversationProjection("conversation", [native], { inputMessageId: "", streaming: false }, projection);
+    await runtime.writeConversationProjection("conversation", [native], { inputMessageId: "", streaming: true }, projection);
+    await runtime.writeConversationProjection("conversation", [native, { id: "next", type: "assistant", text: "", time: { created: 2_000 } }], { streaming: true }, projection);
+    const message = { messageId: "native-final:assistant", ...(configured ? { outputId: "native-final:assistant" } : {}), text: native.text };
+    assert.deepEqual(writes, [{ id: "conversation", message }, { id: "conversation", message }]);
+    assert.deepEqual(streams, [{ id: "conversation", message: { turnId: "", ...message } }]);
+    assert.deepEqual(native, unchanged, "The original native history is never rewritten.");
+  }
+});