@jskit-ai/assistant-runtime 0.1.193 → 0.1.195

package/test/assistantIntegrationBoundary.test.js

@@ -0,0 +1,103 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { createRouter } from "../../kernel/server/http/lib/router.js";
+import { actionIds } from "../src/server/actionIds.js";
+import { createAssistantSettingsActions } from "../src/server/createAssistantSettingsActions.js";
+import { registerSettingsRoutes } from "../src/server/registerSettingsRoutes.js";
+import { resolveRouteRequestState } from "../src/server/support/assistantRouteContext.js";
+
+const config = {
+  surfaceDefinitions: {
+    home: { enabled: true, requiresWorkspace: false },
+    console: { enabled: true, requiresWorkspace: false, accessPolicyId: "console_owner" },
+    admin: { enabled: true, requiresWorkspace: true }
+  },
+  assistantSurfaces: {
+    home: { settingsSurfaceId: "console", configScope: "global" },
+    admin: { settingsSurfaceId: "admin", configScope: "workspace" }
+  }
+};
+
+function request(surfaceId, hostSurfaceId = surfaceId) {
+  return {
+    headers: { "x-jskit-surface": hostSurfaceId },
+    input: { params: { surfaceId, workspaceSlug: "trusted-workspace" } }
+  };
+}
+
+test("the shared route boundary derives surface and workspace only from the existing host inputs", () => {
+  const input = request("admin");
+  input.input.body = { targetSurfaceId: "home", workspaceSlug: "other-workspace", actor: { id: "other-user" } };
+  const resolved = resolveRouteRequestState(input, {
+    resolveCurrentAppConfig: () => config,
+    requiresWorkspace: true,
+    workspaceScopeSupport: {
+      buildInputFromRouteParams(params) { return { workspaceSlug: params.workspaceSlug }; }
+    }
+  });
+  assert.equal(resolved.hostSurfaceId, "admin");
+  assert.deepEqual(resolved.actionInput, { targetSurfaceId: "admin", workspaceSlug: "trusted-workspace" });
+  assert.ok(Object.isFrozen(resolved.actionInput));
+  const settings = resolveRouteRequestState(request("home", "console"), {
+    resolveCurrentAppConfig: () => config,
+    kind: "settings"
+  });
+  assert.equal(settings.hostSurfaceId, "console");
+  assert.deepEqual(settings.actionInput, { targetSurfaceId: "home" });
+});
+
+test("the shared route boundary retains surface and workspace denial errors", () => {
+  for (const [input, options, status, message] of [
+    [request("home", ""), {}, 400, "Assistant surface header x-jskit-surface is required."],
+    [request("home", "admin"), {}, 403, "Assistant route is not available on this surface."],
+    [request("home"), { kind: "settings" }, 403, "Assistant route is not available on this surface."],
+    [request("admin"), {}, 404, "Assistant route not found."],
+    [request("missing"), {}, 404, "Assistant not found."]
+  ]) {
+    assert.throws(() => resolveRouteRequestState(input, {
+      resolveCurrentAppConfig: () => config,
+      ...options
+    }), { status, message });
+  }
+  assert.throws(() => resolveRouteRequestState(request("admin"), {
+    resolveCurrentAppConfig: () => config,
+    requiresWorkspace: true
+  }), /Assistant workspace routes require workspace server scope support/);
+});
+
+test("settings routes and actions compose independently of the chat service", async () => {
+  const calls = [];
+  const definitions = createAssistantSettingsActions({
+    settingsSurfaces: ["console"],
+    assistantConfigService: {
+      getSettings(input, options) { calls.push({ input, options }); return {}; },
+      updateSettings(input, patch, options) { calls.push({ input, patch, options }); return {}; }
+    }
+  });
+  assert.deepEqual(definitions.map(({ id }) => id), [actionIds.settingsRead, actionIds.settingsUpdate]);
+  assert.ok(definitions.every(({ permission }) => permission.require === "authenticated"));
+  assert.ok(definitions.every(({ extensions }) => extensions.assistant.exclude.includes("self-configuration is disabled")));
+  const router = createRouter();
+  registerSettingsRoutes(router, () => config);
+  const routes = router.list();
+  assert.deepEqual(routes.map(({ method, path }) => [method, path]), [
+    ["GET", "/api/assistant/:surfaceId/settings"],
+    ["PATCH", "/api/assistant/:surfaceId/settings"]
+  ]);
+  const context = { actor: { id: "authenticated-user" } };
+  const patch = { systemPrompt: "Use the existing settings service." };
+  for (const route of routes) {
+    await route.handler({
+      ...request("home", "console"),
+      input: { params: { surfaceId: "home" }, body: patch },
+      executeAction({ actionId, surface, input }) {
+        assert.equal(surface, "console");
+        return definitions.find(({ id }) => id === actionId).execute(input, context);
+      }
+    }, { code(status) { assert.equal(status, 200); return this; }, send() {} });
+  }
+  assert.deepEqual(calls, [
+    { input: { targetSurfaceId: "home" }, options: { context } },
+    { input: { targetSurfaceId: "home", patch }, patch, options: { context } }
+  ]);
+});

package/test/assistantRuntimeComposition.test.js

@@ -0,0 +1,68 @@
+import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import test from "node:test";
+
+test("assistant services compose with supplied repositories without database imports", () => {
+  const result = spawnSync(process.execPath, ["--input-type=module", "-e", `
+    import assert from "node:assert/strict";
+    import { registerHooks } from "node:module";
+
+    registerHooks({ resolve(specifier, context, nextResolve) {
+      if (["@jskit-ai/database-runtime", "knex"].some((name) => specifier === name || specifier.startsWith(name + "/"))) {
+        throw new Error("Unexpected database import: " + specifier);
+      }
+      return nextResolve(specifier, context);
+    } });
+
+    for (const name of ["@jskit-ai/database-runtime", "knex"]) {
+      await assert.rejects(() => import(name), /Unexpected database import/);
+    }
+
+    const { createAssistantRuntime } = await import(${JSON.stringify(new URL("../src/server/createAssistantRuntime.js", import.meta.url).href)});
+    let record = { targetSurfaceId: "home", workspaceId: null, settings: { systemPrompt: "Initial prompt" } };
+    const scope = { targetSurfaceId: "home", workspaceId: null };
+    const repositories = {
+      config: {
+        async findByScope(input) {
+          assert.deepEqual(input, scope);
+          return record;
+        },
+        async upsertByScope({ patch, ...input }) {
+          assert.deepEqual(input, scope);
+          record = { ...record, settings: patch };
+          return record;
+        },
+        createDefaultRecord() { throw new Error("The supplied record should be used."); }
+      },
+      conversations: {},
+      messages: {},
+      turnRequests: {}
+    };
+    const assistant = createAssistantRuntime({
+      repositories,
+      actionCatalogue: { listDefinitions: () => [], async execute() {} },
+      config: {
+        surfaceDefinitions: { home: { enabled: true, requiresWorkspace: false } },
+        assistantSurfaces: { home: { settingsSurfaceId: "home", configScope: "global" } }
+      },
+      env: {}
+    });
+
+    for (const [name, repository] of Object.entries(repositories)) {
+      assert.equal(assistant.repositories[name], repository);
+    }
+    const options = { context: { actor: { id: 23 } } };
+    assert.equal(await assistant.services.config.getSettings({ targetSurfaceId: "home" }, options), record);
+    const updated = await assistant.services.config.updateSettings(
+      { targetSurfaceId: "home" }, { systemPrompt: "Updated prompt" }, options
+    );
+    assert.equal(updated, record);
+    assert.equal(await assistant.services.config.resolveSystemPrompt({ targetSurfaceId: "home" }), "Updated prompt");
+    assert.equal(typeof assistant.services.chat.streamChat, "function");
+    assert.equal(typeof assistant.services.transcript.getConversationMessagesForUser, "function");
+    assert.equal(typeof assistant.aiClientFactory.resolveClient, "function");
+    assert.equal(typeof assistant.toolCatalog.resolveToolSet, "function");
+  `], { encoding: "utf8" });
+
+  assert.equal(result.status, 0, result.stderr);
+});

package/test/assistantSurfacePattern.test.js

@@ -1,7 +1,7 @@
 import assert from "node:assert/strict";
 import { readFile } from "node:fs/promises";
 import test from "node:test";
-import { createAssistantAiClientFactory } from "../src/server/AssistantProvider.js";
+import { createAssistantAiClientFactory } from "../src/server/createAssistantRuntime.js";
 import { parse as parseSfc } from "@vue/compiler-sfc";
 
 const exampleRoot = new URL("../patterns/assistant-surface/example/", import.meta.url);

package/test/assistantSurfaces.test.js

@@ -1,6 +1,7 @@
 import assert from "node:assert/strict";
 import test from "node:test";
 import {
+  defineAssistantSurface,
   normalizeAssistantConfigScope,
   resolveAssistantSurfaceConfig
 } from "../src/shared/assistantSurfaces.js";
@@ -48,3 +49,25 @@ test("assistant surface config rejects invalid workspace-scoped assistant combin
   assert.equal(normalizeAssistantConfigScope("workspace"), "workspace");
   assert.equal(normalizeAssistantConfigScope("weird"), "global");
 });
+
+test("single-surface shorthand preserves explicit routing, scope and disabled surface boundaries", () => {
+  const home = defineAssistantSurface("home");
+  assert.deepEqual(home, {
+    surfaceDefinitions: { home: { pagesRoot: "", requiresWorkspace: false } },
+    assistantSurfaces: { home: { settingsSurfaceId: "home", configScope: "global" } }
+  });
+  assert.deepEqual(resolveAssistantSurfaceConfig(home, "home"), resolveAssistantSurfaceConfig({
+    surfaceDefinitions: { home: { enabled: true, pagesRoot: "", requiresWorkspace: false } },
+    assistantSurfaces: { home: { settingsSurfaceId: "home", configScope: "global" } }
+  }, "home"));
+  assert.equal(resolveAssistantSurfaceConfig(home, "console"), null);
+  const workspace = defineAssistantSurface("admin", {
+    pagesRoot: "w/[workspaceSlug]/admin", requiresWorkspace: true, accessPolicyId: "workspace_member"
+  });
+  assert.equal(workspace.surfaceDefinitions.admin.pagesRoot, "w/[workspaceSlug]/admin");
+  assert.equal(workspace.surfaceDefinitions.admin.accessPolicyId, "workspace_member");
+  assert.equal(resolveAssistantSurfaceConfig(workspace, "admin").configScope, "workspace");
+  assert.equal(resolveAssistantSurfaceConfig(defineAssistantSurface("home", { enabled: false }), "home"), null);
+  assert.equal(resolveAssistantSurfaceConfig(defineAssistantSurface("home", { configScope: "workspace" }), "home"), null);
+  assert.throws(() => defineAssistantSurface(""), /surface id is required/u);
+});

package/test/chatServiceLifecycle.test.js

@@ -2,6 +2,8 @@ import { createMemoryTurnRequests } from "./support/memoryTurnRequests.js";
 import assert from "node:assert/strict";
 import test from "node:test";
 import { createChatService } from "../src/server/services/chatService.js";
+import { createAssistantConversationRuntime } from "../src/server/createAssistantRuntime.js";
+import { createMemoryAssistantRows } from "./support/memoryAssistantRows.js";
 
 const APP_CONFIG = Object.freeze({
   surfaceDefinitions: {
@@ -68,6 +70,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 } = {}) {
@@ -89,7 +92,7 @@ function createHarness(completions, { executeToolCall = null, tools: configuredT
         }
       }));
 
-  const chatService = createChatService({
+  const dependencies = {
     turnRequests: createMemoryTurnRequests(),
     attachments,
     aiClientFactory: {
@@ -127,6 +130,7 @@ function createHarness(completions, { executeToolCall = null, tools: configuredT
       }
     },
     serviceToolCatalog: {
+      limits: { maxToolArgumentBytes: 64 * 1024 },
       resolveToolSet() {
         return { tools };
       },
@@ -159,7 +163,12 @@ function createHarness(completions, { executeToolCall = null, tools: configuredT
       }
     },
     appConfig: APP_CONFIG
+  };
+  const conversationRuntime = createAssistantConversationRuntime({
+    ...createMemoryAssistantRows({ messages: transcriptMessages }),
+    aiClientFactory: dependencies.aiClientFactory, toolCatalog: dependencies.serviceToolCatalog, attachments
   });
+  const chatService = createChatService({ ...dependencies, conversationRuntime });
 
   const streamWriter = {};
   for (const method of [
@@ -476,6 +485,7 @@ test("answer text reaches the client before the provider finishes, then persists
     firstChunk.resolve();
     await continueResponse.promise;
     yield { choices: [{ delta: { content: " The second sentence." } }] };
+    yield { choices: [{ delta: {}, finish_reason: "stop" }] };
   }
   const harness = createHarness([response()]);
   const running = harness.run();
@@ -498,6 +508,7 @@ test("split internal tags and tool arguments never become answer deltas", async
     for (const content of ["<th", "ink>private reasoning", "</thi", "nk>", "<｜DSML｜function_", "calls><｜DSML｜invoke name=\"action_search\">", '{"secret":"private arguments"}', "</｜DSML｜invoke></｜DSML｜function_calls>"]) {
       yield { choices: [{ delta: { content } }] };
     }
+    yield { choices: [{ delta: {}, finish_reason: "stop" }] };
   }
   const harness = createHarness([response(), textCompletion("The search is complete.")]);
   await harness.run();

package/test/featureRuntime.test.js

@@ -1,9 +1,15 @@
 import assert from "node:assert/strict";
 import test from "node:test";
+import { spawnSync } from "node:child_process";
+import { EventEmitter } from "node:events";
+import { createSchema } from "json-rest-schema";
 
 import { createActionProvider } from "@jskit-ai/kernel/server/actions";
+import { attachDirectRequestActionExecutor } from "@jskit-ai/kernel/server/http";
 import { createCapabilityRuntime, defineProvider } from "@jskit-ai/kernel/shared/capabilities";
 import { AssistantFeature } from "../src/server/AssistantProvider.js";
+import { actionIds } from "../src/server/actionIds.js";
+import { ASSISTANT_CONVERSATION_SUBSCRIBE } from "../src/shared/conversationRealtime.js";
 
 function valueProvider(id, capability, value) {
   return defineProvider({
@@ -74,3 +80,235 @@ test("AssistantFeature composes chat, transcripts, settings, routes, and action
 
   await runtime.shutdown();
 });
+
+test("AssistantFeature uses a supplied file runtime without loading database or legacy chat integration", () => {
+  const result = spawnSync(process.execPath, ["--input-type=module", "-e", `
+    import assert from "node:assert/strict";
+    import { registerHooks } from "node:module";
+    import { mkdtemp, rm } from "node:fs/promises";
+    import { tmpdir } from "node:os";
+    import { join } from "node:path";
+    registerHooks({ resolve(specifier, context, nextResolve) {
+      if (["@jskit-ai/database-runtime", "knex"].some(name => specifier === name || specifier.startsWith(name + "/")) ||
+          specifier.endsWith("/chatService.js") || specifier.endsWith("/createAssistantRuntime.js")) {
+        throw new Error("Unexpected database/legacy import: " + specifier);
+      }
+      return nextResolve(specifier, context);
+    } });
+    for (const name of ["@jskit-ai/database-runtime", "knex"]) {
+      await assert.rejects(() => import(name), /Unexpected database/);
+    }
+    const { AssistantFeature } = await import("@jskit-ai/assistant-runtime/server");
+    const { createConversationRuntime, createFileConversationStorage } = await import("@jskit-ai/assistant-core/server/conversation");
+    const { createActionProvider } = await import("@jskit-ai/kernel/server/actions");
+    const { createCapabilityRuntime, defineProvider } = await import("@jskit-ai/kernel/shared/capabilities");
+    const directory = await mkdtemp(join(tmpdir(), "assistant-feature-"));
+    const runtime = createConversationRuntime({ storage: createFileConversationStorage({ directory }),
+      authorize: ({ context }) => context.actor?.id === "42",
+      connections: { resolve() { throw new Error("Reading a conversation must not invoke inference."); } } });
+    const context = { actor: { id: "42" } };
+    const conversation = await runtime.open({ id: "chat", context,
+      configuration: { systemPrompt: "Answer briefly.", integrationId: "selected" } });
+    const config = { surfaceDefinitions: { home: { enabled: true, requiresWorkspace: false } },
+      assistantSurfaces: { home: { settingsSurfaceId: "home", configScope: "global" } } };
+    const valueProvider = (capability, value) => defineProvider({ id: capability,
+      provides: { value: capability }, setup: () => ({ value }) });
+    let registrations = 0, detachments = 0;
+    try {
+      for (const unrelatedDatabase of [false, true]) {
+        const routes = [];
+        let assistant, actions;
+        const host = createCapabilityRuntime({ providers: [createActionProvider(),
+          valueProvider("runtime.config", config), valueProvider("runtime.env", {}),
+          valueProvider("runtime.http", { router: { register(...route) { routes.push(route); } } }),
+          valueProvider("assistant.conversations", runtime),
+          valueProvider("runtime.realtime", { onConnection(listener) {
+            assert.equal(typeof listener, "function"); registrations++;
+            return () => { detachments++; };
+          } }),
+          valueProvider("runtime.events", { publish() {} }),
+          ...(unrelatedDatabase ? [valueProvider("runtime.database", { get knex() {
+            throw new Error("Supplied conversation storage must not touch the host database.");
+          } })] : []),
+          AssistantFeature,
+          defineProvider({ id: "observer", requires: { assistant: "assistant.runtime", actions: "runtime.actions" },
+            setup(values) { ({ assistant, actions } = values); return {}; } })
+        ] });
+        try {
+          await host.start();
+          assert.equal(assistant.conversationRuntime, runtime);
+          assert.equal(assistant.services.conversations, runtime);
+          assert.equal(assistant.services.config, null);
+          assert.equal(assistant.services.chat, undefined);
+          assert.ok(actions.listDefinitions().some(entry => entry.id === "assistant.conversation.read"));
+          assert.ok(!actions.listDefinitions().some(entry => entry.id === "assistant.chat.stream"));
+          assert.ok(routes.some(([method, path]) => method === "GET" && path.endsWith("/:conversationId")));
+          assert.ok(routes.every(([, path]) => !path.endsWith("/settings") && !path.endsWith("/chat/stream")));
+        } finally { await host.shutdown(); }
+        assert.equal((await conversation.read()).id, "chat");
+      }
+      assert.equal(registrations, 2);
+      assert.equal(detachments, 2);
+    } finally {
+      await runtime.close();
+      await rm(directory, { recursive: true, force: true });
+    }
+  `], { encoding: "utf8" });
+  assert.equal(result.status, 0, result.stderr);
+});
+
+test("one AssistantFeature composes host access and declared data while settings retain authenticated access", { timeout: 10_000 }, async () => {
+  const routes = [], wrapped = [], sent = [], choices = [], observers = new Set();
+  let actions, connection, releaseConnection;
+  let registrations = 0, releases = 0, requestReads = 0;
+  const config = { surfaceDefinitions: { home: { enabled: true, requiresWorkspace: false } },
+    assistantSurfaces: { home: { settingsSurfaceId: "home", configScope: "global" } } };
+  const conversation = {
+    read: async () => ({ id: "persisted-local", status: "ready", conversationLog: [] }),
+    async send(input) { sent.push(input); return { messageId: input.messageId, status: "accepted" }; },
+    async configure(input) { choices.push({ configuration: input }); return input; },
+    async select(input) { choices.push({ selection: input }); return input; },
+    async replace(input) { choices.push({ replacement: input }); return input; },
+    async subscribe(listener) { observers.add(listener); return () => observers.delete(listener); }
+  };
+  const conversationRuntime = {
+    conversationDataSchema: createSchema({ clientId: { type: "string", required: true, minLength: 1 } }),
+    conversationConfigurationSchema: createSchema({ effort: { type: "string", required: true, enum: ["low"] } }),
+    conversationSelectionSchema: createSchema({ modelChoice: { type: "string", required: true, enum: ["offered"] } }),
+    conversationReplacementSchema: createSchema({ choice: { type: "string", required: true, enum: ["renew"] } }),
+    async open({ id, context }) {
+      assert.equal(id, "persisted-local");
+      assert.equal(context.hostAuthorized, true);
+      assert.equal(context.actor, null, "Host access must not fabricate an authenticated local actor.");
+      return conversation;
+    }
+  };
+  const router = { register(method, path, contract, handler) { routes.push({ method, path, contract, handler }); } };
+  function requireHostRequest(request) {
+    if (request?.headers?.["x-fixture-access"] !== "allowed") {
+      throw Object.assign(new Error("Host request denied."), { statusCode: 403 });
+    }
+  }
+  const access = {
+    router: { register(method, path, contract, handler) {
+      router.register(method, path, { ...contract, auth: "public" }, (request, reply) => {
+        requireHostRequest(request);
+        return handler(request, reply);
+      });
+    } },
+    wrapAction(definition) {
+      wrapped.push(definition.id);
+      return { ...definition, permission: { require: "none" }, execute(input, context, deps) {
+        requireHostRequest(context.requestMeta?.request);
+        return definition.execute(input, { ...context, hostAuthorized: true }, deps);
+      } };
+    },
+    subscribeActionId: "test.host.conversation.subscribe",
+    requestPolicy: "host"
+  };
+  const host = createCapabilityRuntime({
+    providers: [createActionProvider(), AssistantFeature, defineProvider({
+      id: "test.host.observer", requires: { catalogue: "runtime.actions", assistant: "assistant.runtime" },
+      setup({ catalogue, assistant }) {
+        actions = catalogue;
+        assert.equal(assistant.conversationRuntime, conversationRuntime);
+        return {};
+      }
+    })],
+    inputs: {
+      "runtime.config": config, "runtime.env": {}, "runtime.http": { router },
+      "assistant.conversations": conversationRuntime, "assistant.conversation.access": access,
+      "assistant.settings": {}, "runtime.events": { async publish() {} },
+      "runtime.realtime": { onConnection(listener) {
+        registrations++;
+        connection = listener;
+        return () => { releases++; releaseConnection?.(); };
+      } }
+    }
+  });
+  await host.start();
+  try {
+    assert.equal(registrations, 1);
+    assert.equal(wrapped.length, 10);
+    assert.ok(wrapped.includes(access.subscribeActionId));
+    assert.ok(!wrapped.includes(actionIds.conversationSubscribe));
+    assert.equal(actions.listDefinitions().length, 12);
+    assert.equal(routes.length, 11);
+    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");
+    const sendRoute = routes.find(route => route.path.endsWith("/:conversationId/messages"));
+    const body = { messageId: "authored-message", text: "A question", data: { clientId: "original-client" } };
+    assert.deepEqual(sendRoute.contract.body.schema.patch(body).errors, {});
+    const forged = { ...body, data: { ...body.data, actor: "other-user" } };
+    assert.notDeepEqual(sendRoute.contract.body.schema.patch(forged).errors, {});
+    const request = { headers: { "x-jskit-surface": "home", "x-fixture-access": "allowed" },
+      input: { params: { surfaceId: "home", conversationId: "persisted-local" }, body } };
+    attachDirectRequestActionExecutor({ actions, request });
+    const reply = { code(status) { this.status = status; return this; }, send(value) { this.value = value; } };
+    await sendRoute.handler(request, reply);
+    assert.equal(reply.status, 202);
+    assert.deepEqual(sent, [body]);
+    await assert.rejects(async () => sendRoute.handler({ ...request, headers: {} }, reply), /Host request denied/);
+    const context = { channel: "api", surface: "home", requestMeta: { request } };
+    await assert.rejects(actions.execute({ actionId: actionIds.conversationSend,
+      input: { targetSurfaceId: "home", conversationId: "persisted-local", ...forged }, context }),
+    error => error.code === "ACTION_VALIDATION_FAILED");
+    await assert.rejects(actions.execute({ actionId: actionIds.conversationRead,
+      input: { targetSurfaceId: "home", conversationId: "persisted-local" },
+      context: { channel: "api", surface: "home" } }), /Host request denied/);
+    await assert.rejects(actions.execute({ actionId: actionIds.settingsRead,
+      input: { targetSurfaceId: "home" }, context }), error => error.code === "ACTION_AUTHENTICATION_REQUIRED");
+    for (const [suffix, body] of [["configuration", { configuration: { effort: "low" } }],
+      ["selection", { selection: { modelChoice: "offered" } }],
+      ["replacement", { replacement: { choice: "renew" } }]]) {
+      const route = routes.find(route => route.path.endsWith(`/:conversationId/${suffix}`));
+      assert.deepEqual(route.contract.body.schema.patch(body).errors, {});
+      const choiceRequest = { ...request, input: { ...request.input, body } };
+      attachDirectRequestActionExecutor({ actions, request: choiceRequest });
+      await route.handler(choiceRequest, reply);
+      assert.equal(reply.status, 200);
+      await assert.rejects(async () => route.handler({ ...choiceRequest, headers: {} }, reply), /Host request denied/);
+    }
+    assert.deepEqual(choices, [{ configuration: { effort: "low" } }, { selection: { modelChoice: "offered" } },
+      { replacement: { choice: "renew" } }]);
+    const socket = Object.assign(new EventEmitter(), { id: "host-socket", connected: true });
+    releaseConnection = connection({ socket,
+      authenticate() { assert.fail("Explicit host policy must use the revalidating host request facility."); },
+      async readRequest() { requestReads++; return { headers: { "x-fixture-access": "allowed" } }; }
+    });
+    const subscribed = await new Promise(resolve => socket.emit(ASSISTANT_CONVERSATION_SUBSCRIBE, {
+      subscriptionId: "host-view", conversationId: "persisted-local", targetSurfaceId: "home", hostSurfaceId: "home"
+    }, resolve));
+    assert.equal(subscribed.ok, true);
+    assert.equal(subscribed.state.id, "persisted-local");
+    assert.equal(requestReads, 1);
+    assert.equal(observers.size, 1);
+    assert.equal(socket.listenerCount(ASSISTANT_CONVERSATION_SUBSCRIBE), 1);
+  } finally { await host.shutdown(); }
+  assert.equal(releases, 1);
+  assert.equal(observers.size, 0);
+  assert.equal((await conversation.read()).id, "persisted-local");
+});
+
+test("AssistantFeature rejects incomplete host access before registering routes or actions", async () => {
+  const validAccess = { router: { register() {} }, wrapAction: definition => definition,
+    subscribeActionId: "test.host.conversation.subscribe", requestPolicy: "host" };
+  for (const [conversationRuntime, access] of [
+    [{ open() {} }, { ...validAccess, router: null }],
+    [{ open() {} }, { ...validAccess, wrapAction: null }],
+    [{ open() {} }, { ...validAccess, requestPolicy: "public" }],
+    [{ open() {} }, { ...validAccess, subscribeActionId: actionIds.conversationSubscribe }],
+    [null, validAccess]
+  ]) {
+    let registrations = 0;
+    const host = createCapabilityRuntime({ providers: [createActionProvider(), AssistantFeature], inputs: {
+      "runtime.config": {}, "runtime.env": {},
+      "runtime.http": { router: { register() { registrations++; } } },
+      "assistant.conversation.access": access,
+      ...(conversationRuntime ? { "assistant.conversations": conversationRuntime } : {})
+    } });
+    await assert.rejects(host.start(), /assistant\.conversation\.access/);
+    assert.equal(registrations, 0);
+  }
+});