@jskit-ai/assistant-core 0.1.240 → 0.1.242

package/test/conversationAttachments.test.js

@@ -3,8 +3,11 @@ import assert from "node:assert/strict";
 import test from "node:test";
 import { createConversationRuntime, createMemoryConversationStorage } from "../src/server/conversation/index.js";
 import { codexLocalImageInput, codexTurnInput } from "../src/server/conversation/codexProvider.js";
-import { createConversationAttachmentReader } from "../src/server/conversation/attachments.js";
-import { conversationAttachmentManifest, prepareConversationAttachmentMessage } from "../src/shared/conversation/attachments.js";
+import { conversationAttachmentIds, createConversationAttachmentReader } from "../src/server/conversation/attachments.js";
+import { attachmentIdsField } from "../src/shared/index.js";
+import { ASSISTANT_ATTACHMENT_MAX_ITEMS as CLIENT_ATTACHMENT_MAX_ITEMS } from "../src/client/conversation/useAssistantAttachments.js";
+import { ASSISTANT_ATTACHMENT_ID_MAX_LENGTH, ASSISTANT_ATTACHMENT_MAX_ITEMS, conversationAttachmentManifest,
+  prepareConversationAttachmentMessage } from "../src/shared/conversation/attachments.js";
 
 const image = Buffer.from("iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+aN7sAAAAASUVORK5CYII=", "base64");
 const receipt = { attachmentId: "picture", fileName: "picture.png", size: image.length };
@@ -253,3 +256,25 @@ test("attachment validation displays the application's configured binary or deci
     }
   }
 });
+
+test("one attachment-ID limit governs the schema field, the server check, continuity batches and the composer", async () => {
+  assert.equal(attachmentIdsField.maxItems, ASSISTANT_ATTACHMENT_MAX_ITEMS);
+  assert.equal(attachmentIdsField.items.maxLength, ASSISTANT_ATTACHMENT_ID_MAX_LENGTH);
+  assert.equal(CLIENT_ATTACHMENT_MAX_ITEMS, ASSISTANT_ATTACHMENT_MAX_ITEMS);
+  const ids = Array.from({ length: ASSISTANT_ATTACHMENT_MAX_ITEMS }, (_, index) => `file-${index}`);
+  assert.deepEqual(conversationAttachmentIds(ids), ids);
+  assert.throws(() => conversationAttachmentIds([...ids, "one-too-many"]), { code: "conversation_invalid_attachments" });
+  assert.deepEqual(conversationAttachmentIds(["x".repeat(ASSISTANT_ATTACHMENT_ID_MAX_LENGTH)]).length, 1);
+  assert.throws(() => conversationAttachmentIds(["x".repeat(ASSISTANT_ATTACHMENT_ID_MAX_LENGTH + 1)]), { code: "conversation_invalid_attachments" });
+  const batches = [];
+  const reader = createConversationAttachmentReader({ context, conversationId: "one", signal: new AbortController().signal,
+    authorize: async () => {}, types: ["text"], maximumBytes: 1024 * 1024,
+    attachments: { resolve: ({ attachmentIds }) => {
+      batches.push(attachmentIds.length);
+      return { attachments: attachmentIds.map(attachmentId => ({ attachmentId, fileName: `${attachmentId}.txt`, size: 1 })),
+        content: [{ type: "text", text: "x" }] };
+    } } });
+  const continued = await reader([...ids, "one-more"].map(attachmentId => ({ attachmentId })));
+  assert.deepEqual(batches, [ASSISTANT_ATTACHMENT_MAX_ITEMS, 1]);
+  assert.equal(continued.attachments.length, ASSISTANT_ATTACHMENT_MAX_ITEMS + 1);
+});

package/test/conversationDeliveryTiming.test.js

@@ -1,6 +1,7 @@
 import assert from "node:assert/strict";
 import test from "node:test";
 import { createConversationDeliveryTiming } from "../src/server/conversation/deliveryTiming.js";
+import { createConversationRuntime, createMemoryConversationStorage } from "../src/server/conversation/index.js";
 
 test("native engines share bounded, content-free timing and independent message identities", () => {
   for (const engine of ["codex", "claude", "opencode"]) {
@@ -48,3 +49,23 @@ test("diagnostic failures and unfinished asynchronous observers never block deli
   await Promise.resolve();
   pending.resolve();
 });
+
+test("host preparation stages are reported only when the host declares them", () => {
+  const events = [];
+  const report = event => events.push(event.stage);
+  const plain = createConversationDeliveryTiming({ engine: "claude", conversationId: "chat", messageId: "one", report });
+  plain("received"); plain("host-step");
+  assert.deepEqual(events, ["received"]);
+  const declared = createConversationDeliveryTiming({ engine: "claude", conversationId: "chat", messageId: "two", report,
+    hostStages: ["host-step"] });
+  declared("host-step"); declared("other-step");
+  assert.deepEqual(events, ["received", "host-step"]);
+});
+
+test("conversation runtimes reject malformed host delivery stage names", () => {
+  for (const hostDeliveryStages of ["host-step", ["Host"], ["host step"], [7], ["-step"]]) {
+    assert.throws(() => createConversationRuntime({ authorize: () => true, hostDeliveryStages }),
+      { name: "TypeError", message: "Host delivery stages must be lowercase hyphenated names." });
+  }
+  createConversationRuntime({ authorize: () => true, storage: createMemoryConversationStorage(), hostDeliveryStages: ["git-step"] });
+});

package/test/conversationNormalize.test.js

@@ -0,0 +1,11 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { normalizeNullableText } from "../src/server/conversation/normalize.js";
+
+test("conversation text normalization blanks only null and undefined", () => {
+  assert.equal(normalizeNullableText(null), "");
+  assert.equal(normalizeNullableText(undefined), "");
+  assert.equal(normalizeNullableText(0), "0");
+  assert.equal(normalizeNullableText(false), "false");
+  assert.equal(normalizeNullableText("  id  "), "id");
+});

package/test/fixtures/nestedListQuestionMessage.md

@@ -0,0 +1,37 @@
+Here's how I'd run a final sweep in three steps: I do a systematic pass on my own first, then a short session with you for the parts that need you, then I tidy up.
+
+**Step 1: I sweep on my own (no need for you)**
+- **Click everything.** I go through every visible control and compare it against the specs: every button, the + menu, every right-click menu (bots, messages, sections, Library items), every keyboard shortcut on the shortcuts sheet, and every settings row. Anything with no spec is a gap.
+- **Gather the "unverified" lists.** Every spec has one, and I'll merge them all into a single gap list. Each item gets labelled as one of three kinds:
+  - **I can observe it now:** for example, editing and deleting pages, or a bot made from a template.
+  - **Needs you:** real accounts, audio, a second account, payment, your phone, links that open in a browser.
+  - **Can't be observed at all.**
+- **Output:** one gap list, saved to your Session Dropzone, with every item marked done, observable, needs you, or impossible.
+
+**Step 2: a session with you, for the "needs you" items and things only you know about**
+- **You drive the reference over VNC**, using it as you normally would: your knowledge of features, the test Google account, the phone app, links opening in your browser.
+- **I record the screen** at a low frame rate while you work, and capture stills when you tell me something interesting is happening. Just tell me what you did in plain words ("now I'm connecting Gmail", "this is the share link in my browser").
+- **Things outside the reference machine:** put screenshots in the Session Dropzone, for example from the mobile app, the help pages, or emails it sends. I'll file them.
+- **What I need from you:**
+  - which features you know or suspect exist that I haven't covered (I'll ask about specific suspects from my list)
+  - the test Google account, so I can see the real connected states
+  - your call on anything that sends real data or costs money
+
+**Step 3: I tidy up**
+- **For mercbot:**
+  - Newly discovered areas go to mercbot as additions to the feature map.
+  - Each one gets a spec, sent when you or mercbot ask for it. The phase-2 rules allow that.
+- **For you:** a final coverage summary.
+
+**One thing to keep in mind:** you'll see more of the original than mercbot ever should. During this phase, keep sending findings through me rather than straight to mercbot.
+
+[1] Shall I start Step 1 (the solo sweep and gap list) now?
+Possible answers:
+- Yes, start now
+- Wait until I'm ready to do Step 2 as well
+
+[2] For Step 2, how would you like to work?
+Possible answers:
+- I drive over VNC while you record
+- I'll put screenshots in the Dropzone
+- A mix of both

package/test/frameworkActions.test.js

@@ -2,7 +2,7 @@ import assert from "node:assert/strict";
 import test from "node:test";
 import { readdir } from "node:fs/promises";
 import { createActionCatalogue } from "@jskit-ai/kernel/server/actions";
-import { resolveStructuredSchemaTransportSchema } from "@jskit-ai/kernel/shared/validators";
+import { resolveSchemaTransportSchemaDefinition } from "@jskit-ai/kernel/shared/validators";
 import { returnJsonApiData } from "@jskit-ai/http-runtime/shared";
 import { createServiceToolCatalog } from "../src/server/lib/serviceToolCatalog.js";
 import { createAssistantActions } from "../../assistant-runtime/src/server/actions.js";
@@ -95,7 +95,7 @@ test("every account, workspace, console and assistant automation action has a co
     direct++;
     assert.ok(assistant.description, spec.id);
     assert.equal(typeof assistant.transformResult, "function", spec.id);
-    assert.ok(resolveStructuredSchemaTransportSchema(assistant.output), spec.id);
+    assert.ok(resolveSchemaTransportSchemaDefinition(assistant.output), spec.id);
     assert.ok(fixtures[spec.id], `Add execution coverage for ${spec.id}`);
   }
   assert.equal(direct, 22);

package/test/longTextBlocks.test.js

@@ -0,0 +1,102 @@
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import test from "node:test";
+import { parseLongTextReviewBlocks } from "../src/shared/conversation/longTextBlocks.js";
+import { parseNumberedQuestionPrompt } from "../src/shared/conversation/numberedQuestionSugar.js";
+
+const message = readFileSync(new URL("./fixtures/nestedListQuestionMessage.md", import.meta.url), "utf8");
+
+function outline(blocks = []) {
+  return blocks.map((block) => {
+    if (block.type !== "ul" && block.type !== "ol") {
+      return `${block.type}: ${block.text.slice(0, 40)}`;
+    }
+    return {
+      [block.type]: block.items.map((item) => (
+        item.blocks ? { [item.text.slice(0, 40)]: outline(item.blocks) } : item.text.slice(0, 40)
+      ))
+    };
+  });
+}
+
+test("a question message keeps its intro paragraphs and nested lists apart from the question cards", () => {
+  const prompt = parseNumberedQuestionPrompt(message);
+  assert.deepEqual(prompt.questions.map((question) => [question.label, question.choices.length]), [
+    ["Shall I start Step 1 (the solo sweep and gap list) now?", 2],
+    ["For Step 2, how would you like to work?", 3]
+  ]);
+  assert.equal(prompt.outro, "");
+
+  assert.deepEqual(outline(parseLongTextReviewBlocks(prompt.intro)), [
+    "paragraph: Here's how I'd run a final sweep in thre",
+    "paragraph: **Step 1: I sweep on my own (no need for",
+    {
+      ul: [
+        "**Click everything.** I go through every",
+        {
+          "**Gather the \"unverified\" lists.** Every": [
+            { ul: ["**I can observe it now:** for example, e", "**Needs you:** real accounts, audio, a s", "**Can't be observed at all.**"] }
+          ]
+        },
+        "**Output:** one gap list, saved to your "
+      ]
+    },
+    "paragraph: **Step 2: a session with you, for the \"n",
+    {
+      ul: [
+        "**You drive the reference over VNC**, us",
+        "**I record the screen** at a low frame r",
+        "**Things outside the reference machine:*",
+        {
+          "**What I need from you:**": [
+            { ul: ["which features you know or suspect exist", "the test Google account, so I can see th", "your call on anything that sends real da"] }
+          ]
+        }
+      ]
+    },
+    "paragraph: **Step 3: I tidy up**",
+    {
+      ul: [
+        {
+          "**For mercbot:**": [
+            { ul: ["Newly discovered areas go to mercbot as ", "Each one gets a spec, sent when you or m"] }
+          ]
+        },
+        "**For you:** a final coverage summary."
+      ]
+    },
+    "paragraph: **One thing to keep in mind:** you'll se"
+  ]);
+});
+
+test("nested lists follow item content indentation and return to the parent level", () => {
+  assert.deepEqual(parseLongTextReviewBlocks([
+    "1. First",
+    "   - child a",
+    "\t- child b",
+    "      1) grandchild",
+    "2. Second",
+    "  - too shallow for the ordered item, so a sibling list item"
+  ].join("\n")), [
+    {
+      items: [
+        {
+          blocks: [{
+            items: [
+              { text: "child a" },
+              { blocks: [{ items: [{ text: "grandchild" }], type: "ol" }], text: "child b" }
+            ],
+            type: "ul"
+          }],
+          text: "First"
+        },
+        { text: "Second" }
+      ],
+      type: "ol"
+    },
+    {
+      items: [{ text: "too shallow for the ordered item, so a sibling list item" }],
+      type: "ul"
+    }
+  ]);
+});

package/test/messageDelivery.test.js

@@ -1,7 +1,7 @@
 import assert from "node:assert/strict";
 import test from "node:test";
 import { nextTick, ref } from "vue";
-import { createAssistantMessageDelivery, unmatchedOptimisticMessages } from "../src/client/conversation/messageDelivery.js";
+import { createAssistantMessageDelivery, draftWithRestoredMessage, 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 () => {
@@ -429,3 +429,9 @@ test("a deliberate new message can follow known uncertainty without resending th
   assert.equal(delivery.find("old").status, "uncertain");
   assert.equal(delivery.find("new").status, "accepted");
 });
+
+test("a restored message leads the draft once", () => {
+  assert.equal(draftWithRestoredMessage("First", ""), "First");
+  assert.equal(draftWithRestoredMessage("First", "New draft"), "First\n\nNew draft");
+  assert.equal(draftWithRestoredMessage("First", "First\n\nNew draft"), "First\n\nNew draft");
+});

package/test/openCodeClient.test.js

@@ -699,3 +699,23 @@ test("stopped native WAL inspection reads newest committed OpenCode rows without
   }), /Native storage changed during inspection/u);
   await assert.rejects(lstat(path.dirname(snapshot)), { code: "ENOENT" });
 });
+
+test("OpenCode message reads continue with older native pages through the before cursor", async () => {
+  const requests = [];
+  const client = createOpenCodeServerClient({ baseUrl: "http://127.0.0.1:4096", password: "private",
+    fetchImpl: async (url) => {
+      requests.push(new URL(url).search);
+      const older = new URL(url).searchParams.get("before");
+      return new Response(JSON.stringify([{ info: { id: older ? "msg_old" : "msg_new", role: "user" }, parts: [] }]), {
+        headers: older ? {} : { "x-next-cursor": "opaque+/=" }
+      });
+    }
+  }).forDirectory("/work/selected");
+  const newest = await client.messages("ses_paged", { limit: 1 });
+  assert.equal(newest.nextCursor, "opaque+/=");
+  assert.equal(newest.data[0].id, "msg_new");
+  const older = await client.messages("ses_paged", { limit: 1, before: newest.nextCursor });
+  assert.equal(older.data[0].id, "msg_old");
+  assert.equal("nextCursor" in older, false);
+  assert.deepEqual(requests, ["?limit=1", `?limit=1&before=${encodeURIComponent("opaque+/=")}`]);
+});

package/test/openCodeRuntime.test.js

@@ -773,7 +773,7 @@ test("credential publication refuses another provider and unowned consumers befo
     await assert.rejects(runtime.invalidateRuntimes({ modelProviderId: "deepseek", publish() { published = true; } }, {
       release: { ownsTarget: target => !unowned || target !== peer,
         beforeRelease: async target => effects.push(target.key), onRemoved: async () => {}, failure: error => { throw error; } }
-    }), { code: "assistant_opencode_connection_in_use" });
+    }), { code: "assistant_opencode_connection_in_use", message: /^Close the other OpenCode conversations that use this connection, then retry/u });
     assert.equal(published, false);
     assert.deepEqual(effects, []);
     assert.deepEqual(stops, []);

package/test/openCodeTurn.test.js

@@ -0,0 +1,90 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import {
+  inspectOpenCodeMessageAdmission,
+  readOpenCodeMessagesUntil,
+  runOpenCodeConversationTurn,
+  waitForOpenCodeMessages
+} from "../src/server/conversation/openCodeTurn.js";
+
+// Mirrors the native message route: a limited read returns the newest rows in
+// chronological order and an opaque cursor that continues with older rows.
+function pagedClient(history) {
+  const reads = [];
+  const prompts = [];
+  return {
+    reads,
+    prompts,
+    async messages(_sessionId, { limit, before } = {}) {
+      reads.push({ limit, before });
+      const end = before ? Number(before.slice("cursor-".length)) : history.length;
+      const start = Math.max(0, end - limit);
+      return { data: history.slice(start, end), ...(start > 0 ? { nextCursor: `cursor-${start}` } : {}) };
+    },
+    async sessionStatus() { return { type: "idle" }; },
+    async prompt(_sessionId, input) { prompts.push(input); return { id: input.id }; }
+  };
+}
+
+// One user input followed by many native model steps, the last one final.
+function longTurnHistory(steps = 150) {
+  const history = [
+    { id: "msg_older", type: "user", time: { created: 1 }, content: [{ type: "text", text: "earlier" }] },
+    { id: "msg_input", type: "user", time: { created: 2 }, content: [{ type: "text", text: "build it" }] }
+  ];
+  for (let step = 1; step <= steps; step += 1) {
+    const final = step === steps;
+    history.push({
+      id: `msg_step_${step}`,
+      type: "assistant",
+      time: { created: 2 + step, ...(final ? { completed: 3 + step } : {}) },
+      finish: final ? "stop" : "tool-calls",
+      content: final ? [{ type: "text", text: "Done." }] : [{ type: "tool", tool: "bash", callID: `call_${step}` }]
+    });
+  }
+  return history;
+}
+
+test("a turn with more than one native page of steps after its input still completes", async () => {
+  const client = pagedClient(longTurnHistory());
+  const completion = await waitForOpenCodeMessages(client, "ses_long", "msg_input", {
+    signal: AbortSignal.timeout(5_000)
+  });
+  assert.equal(completion.result.complete, true);
+  assert.equal(completion.result.text, "Done.");
+  assert.equal(completion.result.turnId, "msg_step_150");
+  // The input sits on the second page; reading stops there instead of exhausting history.
+  assert.deepEqual(client.reads.slice(0, 2), [{ limit: 100, before: undefined }, { limit: 100, before: "cursor-52" }]);
+});
+
+test("admission of an input followed by more than one native page of steps is still proven", async () => {
+  const client = pagedClient(longTurnHistory());
+  const observation = await inspectOpenCodeMessageAdmission(client, "ses_long", "msg_input");
+  assert.equal(observation.accepted, true);
+});
+
+test("a bounded turn whose input left the newest native page is not dispatched again", async () => {
+  const client = pagedClient(longTurnHistory());
+  const result = await runOpenCodeConversationTurn(client, "ses_long", {
+    inputMessageId: "msg_input", prompt: "build it", timeoutMs: 5_000
+  }, { completeResult: value => value });
+  assert.deepEqual(client.prompts, []);
+  assert.equal(result.text, "Done.");
+});
+
+test("paged native history reading stops when its rows are found or history ends", async () => {
+  const history = longTurnHistory(250);
+  const client = pagedClient(history);
+  const newest = await readOpenCodeMessagesUntil(client, "ses_long", () => true);
+  assert.equal(newest.data.length, 100);
+  assert.equal(client.reads.length, 1);
+
+  client.reads.length = 0;
+  const whole = await readOpenCodeMessagesUntil(client, "ses_long", () => false);
+  assert.deepEqual(whole.data.map(row => row.id), history.map(row => row.id));
+  assert.equal(client.reads.length, 3);
+
+  const repeating = { async messages() { return { data: [], nextCursor: "same" }; } };
+  await assert.rejects(readOpenCodeMessagesUntil(repeating, "ses_long", () => false), /repeated a native history cursor/u);
+});

package/test/opencodeConversationSession.test.js

@@ -1813,7 +1813,7 @@ for (const kind of ["tool", "reply"]) test(`completed OpenCode ${kind} wire reta
     assert.equal(saved.assistant.messageId, `${receipt.turnId}:${answer.info.id}:assistant`);
     const prepared = await f.prepare(receipt);
     assert.equal(prepared.text, raw);
-    const { readAssistantResponseEnvelope } = await import("../src/server/lib/assistantToolLoop.js");
+    const { readAssistantResponseEnvelope } = await import("../src/server/conversation/boundedToolLoop.js");
     const decoded = readAssistantResponseEnvelope(prepared.text);
     assert.deepEqual(decoded, value);
     if (kind === "tool") assert.equal(JSON.parse(decoded.arguments).value, handover);

package/test/serviceToolCatalog.test.js

@@ -618,6 +618,33 @@ test("assistant tools reject unknown tools and return safe action failures", asy
   });
 });
 
+test("malformed tool arguments fail without running the action", async () => {
+  let executions = 0;
+  const actions = createActions([action({
+    kind: "command",
+    input: schema({ title: { type: "string" } }),
+    execute: async () => {
+      executions += 1;
+      return { ok: true };
+    }
+  })]);
+  const catalog = createServiceToolCatalog(actions);
+  const context = { actor: { id: "7" }, surface: "admin" };
+  const toolSet = catalog.resolveToolSet(context);
+  const toolName = toolSet.tools[0].name;
+
+  for (const argumentsText of ['{"title":"x"', "[]", '"x"', "null", "7"]) {
+    assert.deepEqual(await catalog.executeToolCall({ toolName, context, toolSet, argumentsText }), {
+      ok: false,
+      error: { code: "assistant_tool_arguments_invalid", message: "Tool arguments must be a JSON object.", status: 400 }
+    }, argumentsText);
+  }
+  assert.equal(executions, 0);
+
+  assert.equal((await catalog.executeToolCall({ toolName, context, toolSet, argumentsText: "  " })).ok, true);
+  assert.equal(executions, 1);
+});
+
 test("wildcard and empty surfaces match named surfaces without bypassing permissions", async () => {
   for (const [surfaces, allowed] of [
     [["*"], ["admin", "app", "console", "custom"]],