@jskit-ai/assistant-runtime 0.2.1 → 0.2.3

package/test/assistantConversationOperations.test.js

@@ -36,12 +36,18 @@ async function fixture(t, { workspace = false, conversationDataSchema = null, ap
   const dispatched = [Promise.withResolvers(), Promise.withResolvers()];
   const scopeInputs = [];
   const knownIds = new Set(["chat:one", "chat:two"]);
-  const access = { allowed: true };
+  const access = { allowed: true, authorized: [], hold: null };
   const storage = createFileConversationStorage({ directory });
   const runtime = createConversationRuntime({
     storage,
-    authorize: ({ context: actor, conversationId }) => access.allowed && actor?.actor?.id === "owner" && knownIds.has(conversationId) &&
-      (!workspace || actor.workspace?.id === trustedWorkspace.id),
+    async authorize({ context: actor, conversationId, operation }) {
+      access.authorized.push(operation);
+      // A test can hold one operation's authorization, and with it the conversation queue.
+      const hold = access.hold?.operation === operation && access.hold;
+      if (hold) { access.hold = null; hold.entered.resolve(); await hold.release; }
+      return access.allowed && actor?.actor?.id === "owner" && knownIds.has(conversationId) &&
+        (!workspace || actor.workspace?.id === trustedWorkspace.id);
+    },
     connections: {
       async resolve({ context: actor }) {
         assert.equal(actor.actor.id, "owner");
@@ -215,9 +221,9 @@ test("file-backed conversation routes return admission receipts and cancel one c
   const f = await fixture(t);
   assert.deepEqual(f.catalogue.listDefinitions().map(({ id }) => id), [
     actionIds.conversationRead, actionIds.conversationSend, actionIds.conversationCancel, actionIds.conversationSubscribe,
-    actionIds.conversationInspectDelivery, actionIds.conversationGoalRead, actionIds.conversationGoalUpdate
+    actionIds.conversationInspectDelivery, actionIds.conversationCancelDelivery, actionIds.conversationGoalRead, actionIds.conversationGoalUpdate
   ]);
-  assert.equal(f.routes.length, 6, "A supplied runtime does not register the old chat or optional settings routes");
+  assert.equal(f.routes.length, 7, "A supplied runtime does not register the old chat or optional settings routes");
   const initial = await f.invoke("GET");
   assert.equal(initial.status, 200);
   assert.equal(initial.payload.id, "chat:one");
@@ -255,11 +261,62 @@ test("file-backed conversation routes return admission receipts and cancel one c
   assert.equal((await readdir(f.directory)).length, 2, "Only the host's two conversation records are persisted");
 });
 
+test("Cancel of one message stops its own submission and always answers", async t => {
+  const f = await fixture(t);
+  const first = await f.invoke("POST", "/messages", { body: { messageId: "first", text: "First question" } });
+  assert.equal(first.payload.status, "accepted");
+  await f.dispatched[0].promise;
+  const cancelled = await f.invoke("POST", "/deliveries/:messageId/cancel", { messageId: "first" });
+  assert.equal(cancelled.status, 200);
+  assert.deepEqual(cancelled.payload, { ok: true, cancelled: true, messageId: "first", interrupted: true });
+  assert.equal(f.requests[0].signal.aborted, true, "the turn this message started stops");
+  const never = await f.invoke("POST", "/deliveries/:messageId/cancel", { messageId: "never-sent" });
+  assert.deepEqual(never.payload, { ok: true, cancelled: true, messageId: "never-sent", interrupted: false });
+  assert.equal((await f.invoke("GET")).payload.status, "ready");
+  assert.equal(f.requests.length, 1, "Cancel never submits a model request");
+});
+
+test("Cancel answers while earlier work holds the conversation queue and the queued send is refused as not sent", async t => {
+  const f = await fixture(t);
+  const entered = Promise.withResolvers();
+  const release = Promise.withResolvers();
+  f.access.hold = { operation: "inspectDelivery", entered, release: release.promise };
+  const inspecting = f.invoke("POST", "/deliveries/:messageId/inspect", { messageId: "earlier" });
+  inspecting.catch(() => {});
+  let sending;
+  let cancelling;
+  let timer;
+  try {
+    await entered.promise;
+    sending = f.invoke("POST", "/messages", { body: { messageId: "queued", text: "Queued question" } });
+    sending.catch(() => {});
+    // The send is authorized and waits in the queue behind the held inspection.
+    while (!f.access.authorized.includes("send")) await new Promise(resolve => setImmediate(resolve));
+    await new Promise(resolve => setImmediate(resolve));
+    cancelling = f.invoke("POST", "/deliveries/:messageId/cancel", { messageId: "queued" });
+    const answer = await Promise.race([cancelling,
+      new Promise(resolve => { timer = setTimeout(() => resolve(null), 2_000); })]);
+    assert.notEqual(answer, null, "Cancel answered while earlier work held the conversation queue");
+    assert.deepEqual(answer.payload, { ok: true, cancelled: true, messageId: "queued", interrupted: false });
+  } finally {
+    clearTimeout(timer);
+    release.resolve();
+  }
+  await inspecting.catch(() => {});
+  await cancelling;
+  await assert.rejects(sending, { code: "conversation_message_cancelled", statusCode: 409 });
+  await assert.rejects(f.invoke("POST", "/messages", { body: { messageId: "queued", text: "Queued question" } }),
+    { code: "conversation_message_cancelled" }, "a later send of the cancelled message is refused too");
+  assert.equal(f.requests.length, 0, "the cancelled message never reaches the model");
+  const next = await f.invoke("POST", "/messages", { body: { messageId: "next", text: "Next question" } });
+  assert.equal(next.payload.status, "accepted", "the conversation stays usable");
+});
+
 test("conversation routes keep authenticated ownership and reject unknown identities", async t => {
   const f = await fixture(t);
   const other = { ...f.context, actor: { id: "other-user" } };
   for (const [method, suffix] of [["GET", ""], ["POST", "/messages"], ["POST", "/cancel"],
-    ["POST", "/deliveries/:messageId/inspect"], ["GET", "/goal"], ["POST", "/goal"]]) {
+    ["POST", "/deliveries/:messageId/inspect"], ["POST", "/deliveries/:messageId/cancel"], ["GET", "/goal"], ["POST", "/goal"]]) {
     await assert.rejects(f.invoke(method, suffix, { actor: other, body: {
       action: "set", expectedSegmentId: "segment", objective: "A goal", messageId: "forged", text: "A forged request", actor: f.context.actor, context: f.context,
       host: { nativeTools: true }, configuration: { systemPrompt: "Override" }, engine: "codex"
@@ -296,7 +353,7 @@ test("workspace conversation actions use the host's resolved workspace and optio
   const options = { ...f.options, assistantConfigService: { getSettings() {}, updateSettings() {} } };
   assert.deepEqual(createAssistantActions(options).map(({ id }) => id), [
     actionIds.conversationRead, actionIds.conversationSend, actionIds.conversationCancel, actionIds.conversationSubscribe,
-    actionIds.conversationInspectDelivery, actionIds.conversationGoalRead, actionIds.conversationGoalUpdate,
+    actionIds.conversationInspectDelivery, actionIds.conversationCancelDelivery, actionIds.conversationGoalRead, actionIds.conversationGoalUpdate,
     actionIds.settingsRead, actionIds.settingsUpdate
   ]);
   const router = createRouter();
@@ -414,10 +471,10 @@ test("the supplied runtime route/action path imports without SQL or the old chat
     const { registerRoutes } = await import(${JSON.stringify(new URL("../src/server/registerRoutes.js", import.meta.url).href)});
     const conversationRuntime = { async open() { throw new Error("Registration cannot open conversations."); } };
     const options = { config: ${JSON.stringify(config)}, conversationRuntime };
-    assert.equal(createAssistantActions(options).length, 7);
+    assert.equal(createAssistantActions(options).length, 8);
     const routes = [];
     registerRoutes({ register(...args) { routes.push(args); } }, options);
-    assert.equal(routes.length, 6);
+    assert.equal(routes.length, 7);
   `], { encoding: "utf8" });
   assert.equal(result.status, 0, result.stderr);
 });

package/test/assistantConversationSubscriptions.test.js

@@ -162,6 +162,9 @@ async function fixture(t, { diagnostics = false, onSetup } = {}) {
     stopSubscriptions();
     stopProbe();
     await transport.shutdown();
+    // Realtime closes only Socket.IO; the fixture owns its HTTP server.
+    http.closeAllConnections();
+    await new Promise((resolve) => http.close(resolve));
     await runtime.close();
     await rm(directory, { recursive: true, force: true });
   });
@@ -329,45 +332,42 @@ test("slow successful subscriptions warn once with the blocked stage and no conv
   assert.equal(f.fetches.length, 0);
 });
 
-test("the real ten-second subscription deadline releases its late observer and Reload never repeats work", { timeout: 25_000 }, async t => {
+test("a real subscription slower than ten seconds keeps its observer, says it is still loading and delivers the late snapshot", { timeout: 25_000 }, async t => {
   const f = await fixture(t);
   const socket = await f.connect();
   const socketId = socket.id;
   const id = f.ids[0];
-  await f.conversations.get(id).send({ messageId: "survives-timeout", text: "Keep working through a slow snapshot" });
+  await f.conversations.get(id).send({ messageId: "survives-wait", text: "Keep working through a slow snapshot" });
   await until(f.changes, () => f.fetches.length === 1);
   const barrier = f.holdNextRead(id);
   const view = f.view(socket, id);
   await until(f.changes, () => barrier.started);
-  const firstSubscriptionEpoch = f.subscriptionTimings.at(-1).subscriptionEpoch;
-  while (!view.errors.length || f.active() !== 0) {
-    await once(f.changes, "change", { signal: AbortSignal.timeout(12_000) });
-  }
-  assert.equal(view.errors[0].message, "Chat updates could not reconnect. Retrying automatically; Reload chat to try now.");
-  assert.equal(view.errors[0].cause.message, "operation has timed out");
+  const subscriptionEpoch = f.subscriptionTimings.at(-1).subscriptionEpoch;
+  while (!view.errors.length) await once(f.changes, "change", { signal: AbortSignal.timeout(12_000) });
+  assert.equal(view.errors[0].message, "Chat is still loading. Waiting for the server; Reload chat to try now.");
+  assert.equal(view.errors[0].code, "assistant_subscription_waiting");
+  assert.equal(f.active(), 1, "The slow observer stays attached while its snapshot is read");
   assert.equal(socket.id, socketId);
   assert.equal(socket.connected, true);
   assert.equal(view.states.length, 0);
-  assert.equal(f.fetches[0].signal.aborted, false);
-  view.dispose.reload();
-  await until(f.changes, () => view.states.length === 1 && f.active() === 1);
-  assert.equal(view.states[0].conversationLog[0].user.messageId, "survives-timeout");
-  const statesBeforeLateRead = view.states.length;
   barrier.resolve();
-  await until(f.changes, () => f.subscriptionTimings.some(record =>
-    record.subscriptionEpoch === firstSubscriptionEpoch && record.stage === "abandoned"));
-  const abandoned = f.subscriptionTimings.find(record =>
-    record.subscriptionEpoch === firstSubscriptionEpoch && record.stage === "abandoned");
-  assert.equal(abandoned.level, "warn", "A timed-out snapshot remains visible at the production warning level");
-  assert.equal(abandoned.previousStage, "snapshot-read");
-  assert.ok(abandoned.durationMs >= 5_000);
-  assert.equal(view.states.length, statesBeforeLateRead, "The obsolete server read never acknowledges into the recovered view");
-  assert.equal(f.active(), 1, "The late read cannot release the recovered observer");
+  await until(f.changes, () => view.states.length === 1);
+  assert.equal(view.states[0].conversationLog[0].user.messageId, "survives-wait");
+  const records = f.subscriptionTimings.filter(record => record.subscriptionEpoch === subscriptionEpoch);
+  assert.equal(records.some(record => record.stage === "abandoned"), false, "Slow work is never abandoned");
+  const acknowledged = records.find(record => record.stage === "acknowledgement");
+  assert.equal(acknowledged.level, "warn", "A slow snapshot remains visible at the production warning level");
+  assert.equal(acknowledged.previousStage, "snapshot-read");
+  assert.ok(acknowledged.elapsedMs >= 10_000);
+  assert.equal(f.subscriptionTimings.filter(record => record.stage === "authentication").length, 1,
+    "Waiting never sends another subscription");
+  assert.equal(view.errors.length, 1);
+  assert.equal(f.active(), 1);
   assert.equal(f.fetches.length, 1);
   assert.equal(f.fetches[0].signal.aborted, false);
   assert.equal(socket.listeners(ASSISTANT_CONVERSATION_EVENT).length, 1);
-  f.fetches[0].text("Still running after the timed-out observation.");
-  await until(f.changes, () => view.received.some(event => event.text?.includes("timed-out observation")));
+  f.fetches[0].text("Still running after the slow snapshot.");
+  await until(f.changes, () => view.received.some(event => event.text?.includes("slow snapshot")));
   view.dispose();
   await until(f.changes, () => f.active() === 0);
 });
@@ -474,7 +474,7 @@ for (const failure of ["rejection", "timeout"]) {
     const requests = [], states = [], errors = [];
     let reads = 0;
     socket.timeout = timeout => ({ emit(name, input, acknowledge) {
-      assert.equal(timeout, 10_000);
+      assert.equal(timeout, 120_000, "Only a much longer silence counts as a lost answer");
       assert.equal(name, ASSISTANT_CONVERSATION_SUBSCRIBE);
       requests.push({ input, acknowledge });
     } });
@@ -911,6 +911,8 @@ async function hostSubscriptionFixture(t, authService = null, conversationRuntim
     for (const client of clients) client.disconnect();
     release();
     await transport.shutdown();
+    http.closeAllConnections();
+    await new Promise((resolve) => http.close(resolve));
   });
   http.listen(0, "127.0.0.1");
   await once(http, "listening");
@@ -1076,6 +1078,134 @@ test("a retried resubscribe keeps the loaded history its caller preserved", t =>
   subscription();
 });
 
+// Socket.IO's acknowledgement deadline and disconnect handling, on mocked timers.
+function slowServerSocket(t) {
+  t.mock.timers.enable({ apis: ["setTimeout"] });
+  const socket = new EventEmitter();
+  socket.connected = true;
+  const subscribes = [], unsubscribes = [];
+  socket.on(ASSISTANT_CONVERSATION_UNSUBSCRIBE, input => unsubscribes.push(input));
+  socket.timeout = milliseconds => ({ emit(name, input, acknowledge) {
+    let settled = false;
+    const settle = (...args) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      acknowledge(...args);
+    };
+    const timer = setTimeout(() => settle(new Error("operation has timed out")), milliseconds);
+    subscribes.push({ name, input, answer: response => settle(null, response),
+      drop: () => settle(new Error("socket has been disconnected")) });
+  } });
+  function disconnect() {
+    socket.connected = false;
+    socket.emit("disconnect");
+    for (const request of subscribes) request.drop();
+  }
+  return { socket, subscribes, unsubscribes, disconnect };
+}
+const slowState = { id: "chat", conversationLog: [], streaming: { revision: 0, messages: [] } };
+function slowView(socket) {
+  const states = [], errors = [];
+  const subscription = subscribeAssistantConversation({ socket, conversationId: "chat", targetSurfaceId: "home", hostSurfaceId: "home",
+    read: () => slowState, onState: state => states.push(state), onError: error => errors.push(error) });
+  return { states, errors, subscription };
+}
+
+test("a connected subscription keeps waiting for a slow server instead of abandoning its work at ten seconds", t => {
+  // Production: an overloaded daemon answered after 14-15 s; the client gave
+  // up at 10 s, unsubscribed and retried with 10 s again, so the chat never loaded.
+  const { socket, subscribes, unsubscribes } = slowServerSocket(t);
+  const { states, errors, subscription } = slowView(socket);
+  t.mock.timers.tick(9_999);
+  assert.equal(errors.length, 0);
+  t.mock.timers.tick(1);
+  assert.equal(errors.length, 1, "Past the normal budget the user is told the chat is still loading");
+  assert.equal(errors[0].code, "assistant_subscription_waiting");
+  assert.equal(errors[0].message, "Chat is still loading. Waiting for the server; Reload chat to try now.");
+  t.mock.timers.tick(5_000);
+  subscribes[0].answer({ ok: true, streamEpoch: "slow", state: slowState });
+  assert.equal(states.length, 1, "The fifteen-second answer is delivered");
+  assert.equal(subscribes.length, 1, "Waiting never starts another subscription");
+  assert.deepEqual(unsubscribes, [], "Waiting never abandons the server's work");
+  t.mock.timers.tick(300_000);
+  assert.equal(subscribes.length, 1);
+  assert.equal(errors.length, 1);
+  subscription();
+  assert.equal(unsubscribes.length, 1, "Disposal still releases the observer");
+});
+
+test("a subscription answer lost past the two-minute cap still unsubscribes and retries with backoff", t => {
+  const { socket, subscribes, unsubscribes } = slowServerSocket(t);
+  const { states, errors, subscription } = slowView(socket);
+  t.mock.timers.tick(119_999);
+  assert.deepEqual(errors.map(error => error.code), ["assistant_subscription_waiting"]);
+  assert.deepEqual(unsubscribes, []);
+  t.mock.timers.tick(1);
+  assert.deepEqual(unsubscribes, [{ subscriptionId: subscribes[0].input.subscriptionId }]);
+  assert.equal(errors[1].code, "assistant_subscription_transport_failed");
+  assert.equal(errors[1].cause.message, "operation has timed out");
+  t.mock.timers.tick(999);
+  assert.equal(subscribes.length, 1);
+  t.mock.timers.tick(1);
+  assert.equal(subscribes.length, 2, "The lost answer retries after the existing backoff");
+  assert.deepEqual(subscribes[1].input, subscribes[0].input);
+  t.mock.timers.tick(10_000);
+  assert.equal(errors[2].code, "assistant_subscription_waiting", "Each slow attempt says it is still loading");
+  subscribes[1].answer({ ok: true, streamEpoch: "recovered", state: slowState });
+  assert.equal(states.length, 1);
+  assert.equal(unsubscribes.length, 1);
+  subscription();
+});
+
+test("a disconnect while a slow subscription waits resets it and the next connect subscribes again", t => {
+  const { socket, subscribes, unsubscribes, disconnect } = slowServerSocket(t);
+  const { states, errors, subscription } = slowView(socket);
+  t.mock.timers.tick(10_000);
+  assert.equal(errors.length, 1);
+  disconnect();
+  t.mock.timers.tick(300_000);
+  assert.equal(subscribes.length, 1, "A disconnected socket waits for its own reconnect");
+  assert.deepEqual(unsubscribes, [], "There is no connection to unsubscribe on");
+  assert.equal(errors.length, 1, "A disconnect reports no lost answer and no further notice");
+  socket.connected = true;
+  socket.emit("connect");
+  assert.equal(subscribes.length, 2);
+  assert.deepEqual(subscribes[1].input, subscribes[0].input);
+  subscribes[1].answer({ ok: true, streamEpoch: "reconnected", state: slowState });
+  assert.equal(states.length, 1);
+  t.mock.timers.tick(300_000);
+  assert.equal(errors.length, 1);
+  subscription();
+});
+
+test("Reload chat while a slow subscription waits reads history or resubscribes, ignoring the earlier late answer", async t => {
+  const { socket, subscribes, unsubscribes } = slowServerSocket(t);
+  const { states, errors, subscription } = slowView(socket);
+  t.mock.timers.tick(10_000);
+  assert.equal(errors.length, 1);
+  await subscription.reload();
+  assert.equal(states.length, 1, "Reload reads canonical history while the subscription keeps waiting");
+  assert.equal(subscribes.length, 1);
+  subscription.reload({ resubscribe: true });
+  assert.equal(subscribes.length, 2, "A manual resubscribe replaces the waiting attempt by its identity");
+  assert.deepEqual(subscribes[1].input, subscribes[0].input);
+  assert.deepEqual(unsubscribes, []);
+  t.mock.timers.tick(5_000);
+  subscribes[0].answer({ ok: true, streamEpoch: "replaced", state: slowState });
+  assert.equal(states.length, 1, "The replaced attempt's late answer is ignored");
+  assert.equal(errors.length, 1);
+  t.mock.timers.tick(5_000);
+  assert.equal(errors.length, 2, "The replacement attempt has its own loading notice");
+  subscribes[1].answer({ ok: true, streamEpoch: "current", state: slowState });
+  assert.equal(states.length, 2);
+  t.mock.timers.tick(300_000);
+  assert.equal(errors.length, 2);
+  assert.equal(subscribes.length, 2);
+  assert.deepEqual(unsubscribes, []);
+  subscription();
+});
+
 for (const status of [401, 403, 503]) {
   test(`subscription read failure ${status} fences denied updates but retains transient history`, async t => {
     const changes = new EventEmitter();

package/test/chatServiceLifecycle.test.js

@@ -73,7 +73,7 @@ async function* completionStream(completion = {}) {
   yield { choices: [{ delta: {}, finish_reason: completion.toolCall ? "tool_calls" : "stop" }] };
 }
 
-function createHarness(completions, { executeToolCall = null, tools: configuredTools = null, attachments, supportsAttachments = true } = {}) {
+function createHarness(completions, { executeToolCall = null, tools: configuredTools = null, attachments, supportsAttachments = true, wrapRuntime = (runtime) => runtime } = {}) {
   const pendingCompletions = [...completions];
   const completionRequests = [];
   const transcriptMessages = [];
@@ -165,7 +165,7 @@ function createHarness(completions, { executeToolCall = null, tools: configuredT
     ...createMemoryAssistantRows({ messages: transcriptMessages }),
     aiClientFactory: dependencies.aiClientFactory, toolCatalog: dependencies.serviceToolCatalog, attachments
   });
-  const chatService = createChatService({ ...dependencies, conversationRuntime });
+  const chatService = createChatService({ ...dependencies, conversationRuntime: wrapRuntime(conversationRuntime) });
 
   const streamWriter = {};
   for (const method of [
@@ -555,3 +555,49 @@ test("attachment identifiers use the conversation runtime's shape before any fil
   }
   assert.deepEqual(calls, []);
 });
+
+function countDisposals(runtime) {
+  const counts = { opened: 0, disposed: 0 };
+  return { counts, runtime: { ...runtime, async open(input) {
+    const handle = await runtime.open(input);
+    counts.opened += 1;
+    return { ...handle, async dispose(options) { counts.disposed += 1; return handle.dispose(options); } };
+  } } };
+}
+
+test("each settled turn releases its conversation, and a later turn opens it again", async () => {
+  const counted = {};
+  const harness = createHarness([textCompletion("First answer."), textCompletion("Second answer.")], {
+    wrapRuntime(runtime) { Object.assign(counted, countDisposals(runtime)); return counted.runtime; }
+  });
+
+  assert.equal((await harness.run("First question", { messageId: "message_1" })).status, "completed");
+  assert.deepEqual(counted.counts, { opened: 1, disposed: 1 }, "a finished turn keeps no runtime conversation open");
+  assert.equal((await harness.run("Second question", { messageId: "message_2" })).status, "completed");
+  assert.deepEqual(counted.counts, { opened: 2, disposed: 2 });
+  assert.deepEqual(assistantMessages(harness.streamEvents), ["First answer.", "Second answer."]);
+});
+
+test("a conversation stays open until the last of its overlapping turns settles", async () => {
+  const counted = {};
+  const firstChunk = Promise.withResolvers();
+  const continueResponse = Promise.withResolvers();
+  async function* held() {
+    yield { choices: [{ delta: { content: "Held answer." } }] };
+    firstChunk.resolve();
+    await continueResponse.promise;
+    yield { choices: [{ delta: {}, finish_reason: "stop" }] };
+  }
+  const harness = createHarness([held()], {
+    wrapRuntime(runtime) { Object.assign(counted, countDisposals(runtime)); return counted.runtime; }
+  });
+
+  const first = harness.run("First question", { messageId: "message_1" });
+  await firstChunk.promise;
+  // A second tab sends while the first answer is still running; the runtime refuses it.
+  assert.equal((await harness.run("Second question", { messageId: "message_2" })).status, "failed");
+  assert.equal(counted.counts.disposed, 0, "the refused turn must not close the conversation the first turn still uses");
+  continueResponse.resolve();
+  assert.equal((await first).status, "completed");
+  assert.deepEqual(counted.counts, { opened: 2, disposed: 1 });
+});

package/test/featureRuntime.test.js

@@ -229,11 +229,11 @@ test("one AssistantFeature composes host access and declared data while settings
   await host.start();
   try {
     assert.equal(registrations, 1);
-    assert.equal(wrapped.length, 10);
+    assert.equal(wrapped.length, 11);
     assert.ok(wrapped.includes(access.subscribeActionId));
     assert.ok(!wrapped.includes(actionIds.conversationSubscribe));
-    assert.equal(actions.listDefinitions().length, 12);
-    assert.equal(routes.length, 11);
+    assert.equal(actions.listDefinitions().length, 13);
+    assert.equal(routes.length, 12);
     assert.ok(routes.filter(route => route.path.endsWith("/settings")).every(route => route.contract.auth === "required"));
     assert.ok(routes.filter(route => !route.path.endsWith("/settings")).every(route => route.contract.auth === "public"));
     assert.equal(actions.getDefinition(actionIds.settingsRead).permission.require, "authenticated");