@jskit-ai/assistant-runtime 0.1.131-oldline.2 → 0.1.131

package/src/server/registerRoutes.js

@@ -1,5 +1,4 @@
 import { AppError } from "@jskit-ai/kernel/server/runtime";
-import { resolveAppConfig } from "@jskit-ai/kernel/server/support";
 import { composeSchemaDefinitions } from "@jskit-ai/kernel/shared/validators";
 import { normalizeSurfaceId } from "@jskit-ai/kernel/shared/surface/registry";
 import { createJsonApiResourceRouteContract } from "@jskit-ai/http-runtime/shared/validators/jsonApiRouteTransport";
@@ -22,7 +21,6 @@ import {
 import { resolveAssistantSurfaceConfig } from "../shared/assistantSurfaces.js";
 import { actionIds } from "./actionIds.js";
 import { assistantSurfaceRouteParamsValidator } from "./inputSchemas.js";
-import { resolveWorkspaceServerScopeSupport } from "./support/workspaceScopeSupport.js";
 
 function requireWorkspaceAssistantRouteParams(workspaceScopeSupport = null) {
   if (!workspaceScopeSupport) {
@@ -499,14 +497,11 @@ function registerRuntimeRoutes(
   );
 }
 
-function registerRoutes(app) {
-  if (!app || typeof app.make !== "function") {
-    throw new Error("registerRoutes requires application make().");
+function registerRoutes(router, { config = {}, workspaceScopeSupport = null } = {}) {
+  if (!router || typeof router.register !== "function") {
+    throw new Error("registerRoutes requires an HTTP router.");
   }
-
-  const router = app.make("jskit.http.router");
-  const resolveCurrentAppConfig = () => resolveAppConfig(app);
-  const workspaceScopeSupport = resolveWorkspaceServerScopeSupport(app);
+  const resolveCurrentAppConfig = () => config;
 
   registerSettingsRoutes(router, resolveCurrentAppConfig, {
     requiresWorkspace: false

package/src/server/repositories/assistantConfigRepository.js

@@ -1,7 +1,7 @@
 import { normalizeDbRecordId, createWithTransaction } from "@jskit-ai/database-runtime/shared";
 import { normalizeSurfaceId } from "@jskit-ai/kernel/shared/surface/registry";
 import { normalizeRecordId, normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
-import { resolveInsertedId } from "@jskit-ai/assistant-core/server";
+import { resolveInsertedId } from "./repositoryPersistenceUtils.js";
 import { assistantRuntimeConfig } from "../../shared/assistantRuntimeConfig.js";
 
 function normalizeTargetSurfaceId(value = "") {

package/src/server/repositories/conversationsRepository.js

@@ -6,7 +6,7 @@ import {
   resolveInsertedId,
   stringifyJsonObject,
   toIso
-} from "@jskit-ai/assistant-core/server";
+} from "./repositoryPersistenceUtils.js";
 import { assistantRuntimeConfig } from "../../shared/assistantRuntimeConfig.js";
 
 function normalizeWorkspaceId(value) {

package/src/server/repositories/messagesRepository.js

@@ -5,7 +5,7 @@ import {
   resolveInsertedId,
   stringifyJsonObject,
   toIso
-} from "@jskit-ai/assistant-core/server";
+} from "./repositoryPersistenceUtils.js";
 import { assistantRuntimeConfig } from "../../shared/assistantRuntimeConfig.js";
 
 function normalizeWorkspaceId(value) {

package/src/server/repositories/repositoryPersistenceUtils.js

@@ -0,0 +1,29 @@
+import { resolveInsertedRecordId } from "@jskit-ai/database-runtime/shared";
+import { parseJsonObject } from "@jskit-ai/assistant-core/shared";
+
+function stringifyJsonObject(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return null;
+  }
+
+  return JSON.stringify(value);
+}
+
+function toIso(value) {
+  if (!value) {
+    return "";
+  }
+
+  const date = value instanceof Date ? value : new Date(value);
+  if (Number.isNaN(date.getTime())) {
+    return "";
+  }
+
+  return date.toISOString();
+}
+
+function resolveInsertedId(insertResult) {
+  return resolveInsertedRecordId(insertResult, { fallback: "" }) || "";
+}
+
+export { parseJsonObject, stringifyJsonObject, toIso, resolveInsertedId };

package/src/server/support/createSurfaceAwareToolCatalog.js

@@ -21,9 +21,9 @@ function requireContextSurfaceId(context = {}) {
   throw new Error("assistant surface-aware tool catalog requires context.surface.");
 }
 
-function createSurfaceAwareToolCatalog(scope, { appConfig = {}, resolveAppConfig = null, createCatalog = createServiceToolCatalog } = {}) {
-  if (!scope) {
-    throw new Error("createSurfaceAwareToolCatalog requires scope.");
+function createSurfaceAwareToolCatalog(actions, { appConfig = {}, resolveAppConfig = null, createCatalog = createServiceToolCatalog } = {}) {
+  if (!actions || typeof actions.listDefinitions !== "function") {
+    throw new Error("createSurfaceAwareToolCatalog requires runtime.actions.");
   }
 
   const resolveCurrentAppConfig =
@@ -36,7 +36,7 @@ function createSurfaceAwareToolCatalog(scope, { appConfig = {}, resolveAppConfig
       return cache.get(surfaceId);
     }
 
-    const nextCatalog = createCatalog(scope, buildCatalogOptions(resolveCurrentAppConfig(), surfaceId));
+    const nextCatalog = createCatalog(actions, buildCatalogOptions(resolveCurrentAppConfig(), surfaceId));
     cache.set(surfaceId, nextCatalog);
     return nextCatalog;
   }
@@ -48,7 +48,7 @@ function createSurfaceAwareToolCatalog(scope, { appConfig = {}, resolveAppConfig
     },
     toOpenAiToolSchema(tool) {
       if (!schemaCatalog) {
-        schemaCatalog = createCatalog(scope, buildCatalogOptions(resolveCurrentAppConfig(), ""));
+        schemaCatalog = createCatalog(actions, buildCatalogOptions(resolveCurrentAppConfig(), ""));
       }
 
       return schemaCatalog.toOpenAiToolSchema(tool);

package/test/actionDefinitions.test.js

@@ -1,192 +1,99 @@
 import assert from "node:assert/strict";
 import test from "node:test";
 
-import {
-  withActionDefaults
-} from "@jskit-ai/kernel/shared/actions";
-import { ActionRuntimeServiceProvider } from "@jskit-ai/kernel/server/actions";
-
-import { assistantActions } from "../src/server/actions.js";
+import { createAssistantActions } from "../src/server/actions.js";
 import { actionIds } from "../src/server/actionIds.js";
 
-function createSingletonApp() {
-  const singletons = new Map();
-  const instances = new Map();
-  const tags = new Map();
+const CONFIG = Object.freeze({
+  surfaceDefinitions: {
+    home: { enabled: true, requiresWorkspace: false },
+    admin: { enabled: true, requiresWorkspace: true },
+    console: { enabled: true, requiresWorkspace: false, accessPolicyId: "console_owner" }
+  },
+  assistantSurfaces: {
+    home: { settingsSurfaceId: "console", configScope: "global" },
+    admin: { settingsSurfaceId: "admin", configScope: "workspace" }
+  }
+});
 
-  return {
-    has(token) {
-      return singletons.has(token) || instances.has(token);
-    },
-    singleton(token, factory) {
-      singletons.set(token, {
-        factory,
-        resolved: false,
-        value: undefined
-      });
-    },
-    tag(token, tagName) {
-      if (!this.has(token)) {
-        throw new Error(`Cannot tag unresolved token "${String(token)}".`);
-      }
-      if (!tags.has(tagName)) {
-        tags.set(tagName, new Set());
-      }
-      tags.get(tagName).add(token);
-    },
-    resolveTag(tagName) {
-      const tagged = tags.get(tagName);
-      if (!tagged) {
-        return [];
-      }
-      return [...tagged].map((token) => this.make(token));
-    },
-    make(token) {
-      if (instances.has(token)) {
-        return instances.get(token);
+function createDefinitions() {
+  return createAssistantActions({
+    config: CONFIG,
+    chatService: {
+      streamChat() { return { ok: true }; },
+      listConversations(query, { input }) { return { query, input }; },
+      getConversationMessages(conversationId, query, { input }) {
+        return { conversationId, query, input };
       }
-      if (!singletons.has(token)) {
-        throw new Error(`Token "${String(token)}" is not registered.`);
-      }
-      const entry = singletons.get(token);
-      if (!entry.resolved) {
-        entry.value = entry.factory(this);
-        entry.resolved = true;
-        instances.set(token, entry.value);
-      }
-      return entry.value;
-    }
-  };
-}
-
-function createAssistantActionExecutor() {
-  const app = createSingletonApp();
-  const provider = new ActionRuntimeServiceProvider();
-  provider.register(app);
-
-  app.singleton("jskit.surface.runtime", () => ({
-    listEnabledSurfaceIds() {
-      return ["home", "console"];
-    }
-  }));
-
-  app.singleton("assistant.chat.service", () => ({
-    streamChat() {
-      return { ok: true };
-    },
-    listConversations(query, { input }) {
-      return { query, input };
     },
-    getConversationMessages(conversationId, query, { input }) {
-      return { conversationId, query, input };
+    assistantConfigService: {
+      getSettings(input) { return { input }; },
+      updateSettings(input, patch) { return { input, patch }; }
     }
-  }));
-
-  app.singleton("assistant.config.service", () => ({
-    getSettings(input) {
-      return { input };
-    },
-    updateSettings(input, patch) {
-      return { input, patch };
-    }
-  }));
-
-  app.actions(
-    withActionDefaults(assistantActions, {
-      domain: "assistant",
-      dependencies: {
-        chatService: "assistant.chat.service",
-        assistantConfigService: "assistant.config.service"
-      }
-    })
-  );
-
-  return app.make("actionExecutor");
+  });
 }
 
 function findDefinition(definitions, id) {
   return definitions.find((definition) => definition.id === id);
 }
 
-test("assistant-runtime actions materialize through the action runtime with single schema-definition inputs", () => {
-  const actionExecutor = createAssistantActionExecutor();
-  const definitions = actionExecutor.listDefinitions();
-
-  assert.equal(definitions.length, assistantActions.length);
-
-  for (const action of assistantActions) {
-    assert.equal(Array.isArray(action.input), false, `${action.id} input must not be an array`);
-  }
-
-  for (const definition of definitions) {
-    assert.equal(typeof definition.input?.schema?.patch, "function", `${definition.id} input schema must normalize`);
-    assert.equal(
-      typeof definition.input?.schema?.toJsonSchema,
-      "function",
-      `${definition.id} input schema must export`
-    );
-    assert.deepEqual(definition.surfaces, ["home", "console"]);
-  }
+test("assistant actions use configured runtime and settings surfaces without surface discovery", () => {
+  const definitions = createDefinitions();
+
+  assert.equal(definitions.length, 5);
+  assert.deepEqual(findDefinition(definitions, actionIds.chatStream).surfaces, ["home", "admin"]);
+  assert.deepEqual(findDefinition(definitions, actionIds.conversationsList).surfaces, ["home", "admin"]);
+  assert.deepEqual(findDefinition(definitions, actionIds.settingsRead).surfaces, ["console", "admin"]);
+  assert.ok(definitions.every((definition) => !Object.hasOwn(definition, "dependencies")));
+  assert.equal(createAssistantActions({
+    config: {},
+    chatService: {},
+    assistantConfigService: {}
+  }).length, 0);
 });
 
-test("assistant-runtime conversations list action keeps query nested under a schema definition", () => {
-  const definition = findDefinition(createAssistantActionExecutor().listDefinitions(), actionIds.conversationsList);
+test("assistant conversations list keeps query nested under one schema definition", () => {
+  const definition = findDefinition(createDefinitions(), actionIds.conversationsList);
   const result = definition.input.schema.patch({
     targetSurfaceId: "home",
     workspaceSlug: "example-workspace",
-    query: {
-      limit: 10,
-      status: "active"
-    }
+    query: { limit: 10, status: "active" }
   });
 
   assert.deepEqual(result.errors, {});
   assert.deepEqual(result.validatedObject, {
     targetSurfaceId: "home",
     workspaceSlug: "example-workspace",
-    query: {
-      limit: 10,
-      status: "active"
-    }
+    query: { limit: 10, status: "active" }
   });
 });
 
-test("assistant-runtime conversation messages list action composes params and nested query", () => {
-  const definition = findDefinition(createAssistantActionExecutor().listDefinitions(), actionIds.conversationMessagesList);
+test("assistant conversation messages composes params and nested query", () => {
+  const definition = findDefinition(createDefinitions(), actionIds.conversationMessagesList);
   const result = definition.input.schema.patch({
     targetSurfaceId: "home",
     conversationId: "123",
-    query: {
-      page: 2,
-      pageSize: 25
-    }
+    query: { page: 2, pageSize: 25 }
   });
 
   assert.deepEqual(result.errors, {});
   assert.deepEqual(result.validatedObject, {
     targetSurfaceId: "home",
     conversationId: 123,
-    query: {
-      page: 2,
-      pageSize: 25
-    }
+    query: { page: 2, pageSize: 25 }
   });
 });
 
-test("assistant-runtime settings update action keeps patch nested under a schema definition", () => {
-  const definition = findDefinition(createAssistantActionExecutor().listDefinitions(), actionIds.settingsUpdate);
+test("assistant settings update keeps patch nested under one schema definition", () => {
+  const definition = findDefinition(createDefinitions(), actionIds.settingsUpdate);
   const result = definition.input.schema.patch({
     targetSurfaceId: "home",
-    patch: {
-      systemPrompt: "Be concise."
-    }
+    patch: { systemPrompt: "Be concise." }
   });
 
   assert.deepEqual(result.errors, {});
   assert.deepEqual(result.validatedObject, {
     targetSurfaceId: "home",
-    patch: {
-      systemPrompt: "Be concise."
-    }
+    patch: { systemPrompt: "Be concise." }
   });
 });

package/test/assistantSurfacePattern.test.js

@@ -0,0 +1,30 @@
+import assert from "node:assert/strict";
+import { readFile } from "node:fs/promises";
+import test from "node:test";
+import { parse as parseSfc } from "@vue/compiler-sfc";
+
+const exampleRoot = new URL("../patterns/assistant-surface/example/", import.meta.url);
+
+test("assistant surface pattern keeps product config explicit and secrets external", async () => {
+  const publicConfig = (await import(new URL("config/public.js", exampleRoot))).default;
+  const serverConfig = (await import(new URL("config/server.js", exampleRoot))).default;
+  const placementSource = await readFile(new URL("src/placement.js", exampleRoot), "utf8");
+  const pagePaths = [
+    "src/pages/admin/assistant/index.vue",
+    "src/pages/admin/settings/assistant/index.vue"
+  ];
+
+  assert.deepEqual(publicConfig.assistantSurfaces.admin, {
+    settingsSurfaceId: "admin",
+    configScope: "global"
+  });
+  assert.equal(serverConfig.assistantServer.admin.aiConfigPrefix, "ADMIN_ASSISTANT");
+  assert.doesNotMatch(JSON.stringify({ publicConfig, serverConfig }), /api[_-]?key|secret/iu);
+  assert.doesNotMatch(placementSource, /generator|scaffold|receipt|provenance/u);
+
+  for (const pagePath of pagePaths) {
+    const source = await readFile(new URL(pagePath, exampleRoot), "utf8");
+    const parsed = parseSfc(source, { filename: pagePath });
+    assert.equal(parsed.errors.length, 0, `${pagePath}: ${parsed.errors.join("\n")}`);
+  }
+});

package/test/createSurfaceAwareToolCatalog.test.js

@@ -4,8 +4,9 @@ import { createSurfaceAwareToolCatalog } from "../src/server/support/createSurfa
 
 test("surface-aware tool catalog applies per-surface skip and barred configuration", async () => {
   const observed = [];
+  const actions = { listDefinitions: () => [], async execute() {} };
   const catalog = createSurfaceAwareToolCatalog(
-    {},
+    actions,
     {
       appConfig: {
         assistantServer: {
@@ -18,7 +19,8 @@ test("surface-aware tool catalog applies per-surface skip and barred configurati
           }
         }
       },
-      createCatalog(_scope, options = {}) {
+      createCatalog(receivedActions, options = {}) {
+        assert.equal(receivedActions, actions);
         observed.push(options);
         return {
           resolveToolSet(context = {}) {

package/test/featureRuntime.test.js

@@ -0,0 +1,76 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { createActionProvider } from "@jskit-ai/kernel/server/actions";
+import { createCapabilityRuntime, defineProvider } from "@jskit-ai/kernel/shared/capabilities";
+import { AssistantFeature } from "../src/server/AssistantProvider.js";
+
+function valueProvider(id, capability, value) {
+  return defineProvider({
+    id,
+    provides: { value: capability },
+    setup() { return { value }; }
+  });
+}
+
+test("AssistantFeature composes chat, transcripts, settings, routes, and action tools from capabilities", async () => {
+  const routes = [];
+  let actions;
+  let assistant;
+  const config = {
+    surfaceDefinitions: {
+      home: { enabled: true, requiresWorkspace: false },
+      console: { enabled: true, requiresWorkspace: false, accessPolicyId: "console_owner" }
+    },
+    assistantSurfaces: {
+      home: { settingsSurfaceId: "console", configScope: "global" }
+    },
+    assistantServer: {
+      home: { aiConfigPrefix: "HOME" }
+    }
+  };
+  const runtime = createCapabilityRuntime({
+    providers: [
+      createActionProvider(),
+      valueProvider("test.config", "runtime.config", config),
+      valueProvider("test.database", "runtime.database", { knex: Object.assign(() => {}, {}) }),
+      valueProvider("test.env", "runtime.env", {}),
+      valueProvider("test.http", "runtime.http", {
+        router: {
+          register(method, path, contract, handler) {
+            routes.push({ method, path, contract, handler });
+          }
+        }
+      }),
+      AssistantFeature,
+      defineProvider({
+        id: "test.observer",
+        requires: {
+          actionCatalogue: "runtime.actions",
+          assistantRuntime: "assistant.runtime"
+        },
+        setup(dependencies) {
+          actions = dependencies.actionCatalogue;
+          assistant = dependencies.assistantRuntime;
+          return {};
+        }
+      })
+    ]
+  });
+
+  await runtime.start();
+
+  assert.deepEqual(actions.listDefinitions().map((entry) => entry.id), [
+    "assistant.chat.stream",
+    "assistant.conversations.list",
+    "assistant.conversation.messages.list",
+    "assistant.settings.read",
+    "assistant.settings.update"
+  ]);
+  assert.equal(typeof assistant.services.chat.streamChat, "function");
+  assert.equal(typeof assistant.toolCatalog.resolveToolSet, "function");
+  assert.equal(routes.length, 5);
+  assert.ok(actions.listDefinitions().every((entry) => !Object.hasOwn(entry, "dependencies")));
+
+  await runtime.shutdown();
+});

package/test/lazyAppConfig.test.js

@@ -51,7 +51,6 @@ function createWorkspaceServerScopeSupport() {
 }
 
 function createAssistantTestApp({
-  resolveCurrentAppConfig = () => null,
   workspaceScopeSupport = null,
   router = null
 } = {}) {
@@ -59,29 +58,7 @@ function createAssistantTestApp({
 
   return {
     router: resolvedRouter,
-    app: {
-      make(token) {
-        if (token === "jskit.http.router") {
-          return resolvedRouter;
-        }
-        if (token === "appConfig") {
-          return resolveCurrentAppConfig();
-        }
-        if (token === "workspaces.server.scope-support" && workspaceScopeSupport) {
-          return workspaceScopeSupport;
-        }
-        throw new Error(`Unexpected token: ${token}`);
-      },
-      has(token) {
-        if (token === "jskit.http.router") {
-          return true;
-        }
-        if (token === "appConfig") {
-          return Boolean(resolveCurrentAppConfig());
-        }
-        return token === "workspaces.server.scope-support" && Boolean(workspaceScopeSupport);
-      }
-    }
+    workspaceScopeSupport
   };
 }
 
@@ -91,11 +68,13 @@ function findRoute(routes, { method, path }) {
 
 test("registerRoutes exposes JSON:API contracts for assistant settings and transcript endpoints", () => {
   const testApp = createAssistantTestApp({
-    workspaceScopeSupport: createWorkspaceServerScopeSupport(),
-    resolveCurrentAppConfig: () => createAssistantAppConfig()
+    workspaceScopeSupport: createWorkspaceServerScopeSupport()
   });
 
-  registerRoutes(testApp.app);
+  registerRoutes(testApp.router, {
+    config: createAssistantAppConfig(),
+    workspaceScopeSupport: testApp.workspaceScopeSupport
+  });
   const routes = testApp.router.list();
   const publicSettingsReadRoute = findRoute(routes, {
     method: "GET",
@@ -125,16 +104,13 @@ test("registerRoutes exposes JSON:API contracts for assistant settings and trans
   assert.equal(publicConversationMessagesRoute?.schema?.response?.[200]?.required?.[0], "data");
 });
 
-test("registerRoutes resolves appConfig lazily when handlers run", async () => {
-  let currentAppConfig = null;
+test("registerRoutes builds workspace action input from explicit config and scope support", async () => {
   const workspaceScopeSupport = createWorkspaceServerScopeSupport();
   const testApp = createAssistantTestApp({
-    workspaceScopeSupport,
-    resolveCurrentAppConfig: () => currentAppConfig
+    workspaceScopeSupport
   });
 
-  registerRoutes(testApp.app);
-  currentAppConfig = createAssistantAppConfig();
+  registerRoutes(testApp.router, { config: createAssistantAppConfig(), workspaceScopeSupport });
   const routes = testApp.router.list();
 
   const route = findRoute(routes, {
@@ -194,16 +170,13 @@ test("registerRoutes resolves appConfig lazily when handlers run", async () => {
 });
 
 test("registerRoutes returns clear AppError payload for pre-stream assistant failures", async () => {
-  let currentAppConfig = null;
   let capturedInput = null;
   const workspaceScopeSupport = createWorkspaceServerScopeSupport();
   const testApp = createAssistantTestApp({
-    workspaceScopeSupport,
-    resolveCurrentAppConfig: () => currentAppConfig
+    workspaceScopeSupport
   });
 
-  registerRoutes(testApp.app);
-  currentAppConfig = createAssistantAppConfig();
+  registerRoutes(testApp.router, { config: createAssistantAppConfig(), workspaceScopeSupport });
   const routes = testApp.router.list();
 
   const route = findRoute(routes, {
@@ -271,9 +244,7 @@ test("registerRoutes returns clear AppError payload for pre-stream assistant fai
   });
 });
 
-test("chat service resolves appConfig lazily when conversations are listed", async () => {
-  let currentAppConfig = {};
-
+test("chat service uses explicit app config when conversations are listed", async () => {
   const chatService = createChatService({
     aiClientFactory: {
       resolveClient() {
@@ -293,12 +264,10 @@ test("chat service resolves appConfig lazily when conversations are listed", asy
     },
     serviceToolCatalog: {},
     assistantConfigService: {},
-    resolveAppConfig: () => currentAppConfig,
+    appConfig: createAssistantAppConfig(),
     workspaceScopeSupport: createWorkspaceServerScopeSupport()
   });
 
-  currentAppConfig = createAssistantAppConfig();
-
   const response = await chatService.listConversations(
     {
       limit: 20
@@ -339,7 +308,7 @@ test("chat service rejects workspace-scoped assistant surfaces when workspace su
     },
     serviceToolCatalog: {},
     assistantConfigService: {},
-    resolveAppConfig: () => createAssistantAppConfig()
+    appConfig: createAssistantAppConfig()
   });
 
   await assert.rejects(
@@ -367,10 +336,10 @@ test("chat service rejects workspace-scoped assistant surfaces when workspace su
 
 test("registerRoutes omits workspace assistant routes when workspace scope support is unavailable", () => {
   const testApp = createAssistantTestApp({
-    resolveCurrentAppConfig: () => createAssistantAppConfig()
+    workspaceScopeSupport: null
   });
 
-  registerRoutes(testApp.app);
+  registerRoutes(testApp.router, { config: createAssistantAppConfig() });
   const routes = testApp.router.list();
 
   assert.equal(

package/test/packageMetadata.test.js

@@ -0,0 +1,38 @@
+import assert from "node:assert/strict";
+import { readdir, readFile } from "node:fs/promises";
+import path from "node:path";
+import test from "node:test";
+import { fileURLToPath } from "node:url";
+import packageJson from "../package.json" with { type: "json" };
+
+const PACKAGE_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const packageMetadata = packageJson.jskit;
+
+test("assistant-runtime registers providers without install-time authoring machinery", async () => {
+  assert.equal(packageMetadata.kind, "runtime");
+  assert.equal(packageMetadata.capabilities?.requires?.includes("workspaces.core"), false);
+  assert.equal(packageMetadata.runtime?.server?.providers?.[0]?.entrypoint, "src/server/AssistantProvider.js");
+  assert.equal(packageMetadata.runtime?.server?.providers?.[0]?.export, "AssistantFeature");
+  assert.equal(
+    packageMetadata.runtime?.client?.providers?.[0]?.entrypoint,
+    "src/client/providers/AssistantClientProvider.js"
+  );
+  assert.equal(Object.hasOwn(packageMetadata, "mutations"), false);
+  assert.equal(Object.hasOwn(packageMetadata.metadata.apiSummary, "containerTokens"), false);
+  assert.deepEqual(packageMetadata.migrations, { directories: ["migrations"] });
+  assert.deepEqual((await readdir(path.join(PACKAGE_ROOT, "migrations"))).sort(), [
+    "assistant_config_initial.cjs",
+    "assistant_transcripts_initial.cjs"
+  ]);
+
+  const publicConfig = await readFile(
+    path.join(PACKAGE_ROOT, "patterns/assistant-surface/example/config/public.js"),
+    "utf8"
+  );
+  const serverConfig = await readFile(
+    path.join(PACKAGE_ROOT, "patterns/assistant-surface/example/config/server.js"),
+    "utf8"
+  );
+  assert.match(publicConfig, /assistantSurfaces/u);
+  assert.match(serverConfig, /assistantServer/u);
+});