@jskit-ai/assistant-runtime 0.1.25 → 0.1.27

package/package.descriptor.mjs

@@ -1,7 +1,7 @@
 export default Object.freeze({
   packageVersion: 1,
   packageId: "@jskit-ai/assistant-runtime",
-  version: "0.1.25",
+  version: "0.1.27",
   kind: "runtime",
   description: "Shared assistant runtime with per-surface assistant registration.",
   dependsOn: [
@@ -74,13 +74,13 @@ export default Object.freeze({
   mutations: {
     dependencies: {
       runtime: {
-        "@jskit-ai/assistant-core": "0.1.30",
-        "@jskit-ai/database-runtime": "0.1.54",
-        "@jskit-ai/http-runtime": "0.1.53",
-        "@jskit-ai/kernel": "0.1.54",
-        "@jskit-ai/shell-web": "0.1.53",
-        "@jskit-ai/users-core": "0.1.64",
-        "@jskit-ai/users-web": "0.1.69",
+        "@jskit-ai/assistant-core": "0.1.32",
+        "@jskit-ai/database-runtime": "0.1.56",
+        "@jskit-ai/http-runtime": "0.1.55",
+        "@jskit-ai/kernel": "0.1.56",
+        "@jskit-ai/shell-web": "0.1.55",
+        "@jskit-ai/users-core": "0.1.66",
+        "@jskit-ai/users-web": "0.1.71",
         "@tanstack/vue-query": "^5.90.5",
         "vuetify": "^4.0.0"
       },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/assistant-runtime",
-  "version": "0.1.25",
+  "version": "0.1.27",
   "type": "module",
   "exports": {
     "./client": "./src/client/index.js",
@@ -8,14 +8,18 @@
     "./server/actionIds": "./src/server/actionIds.js"
   },
   "dependencies": {
-    "@jskit-ai/assistant-core": "0.1.30",
-    "@jskit-ai/database-runtime": "0.1.54",
-    "@jskit-ai/http-runtime": "0.1.53",
-    "@jskit-ai/kernel": "0.1.54",
-    "@jskit-ai/shell-web": "0.1.53",
-    "@jskit-ai/users-core": "0.1.64",
-    "@jskit-ai/users-web": "0.1.69",
+    "@jskit-ai/assistant-core": "0.1.32",
+    "@jskit-ai/database-runtime": "0.1.56",
+    "@jskit-ai/http-runtime": "0.1.55",
+    "@jskit-ai/kernel": "0.1.56",
+    "@jskit-ai/shell-web": "0.1.55",
+    "@jskit-ai/users-core": "0.1.66",
+    "@jskit-ai/users-web": "0.1.71",
+    "json-rest-schema": "1.x.x",
     "@tanstack/vue-query": "^5.90.5",
     "vuetify": "^4.0.0"
+  },
+  "peerDependencies": {
+    "vue": "^3.5.13"
   }
 }

package/src/client/components/AssistantSettingsClientElement.vue

@@ -173,7 +173,7 @@ async function submit() {
 
   const validation = validateOperationSection({
     operation: assistantConfigResource.operations.patch,
-    section: "bodyValidator",
+    section: "body",
     value: {
       systemPrompt: form.systemPrompt
     }

package/src/client/composables/useAssistantRuntime.js

@@ -1,4 +1,4 @@
-import { computed, ref, watch } from "vue";
+import { computed, nextTick, ref, watch } from "vue";
 import { useQueryClient } from "@tanstack/vue-query";
 import { getClientAppConfig } from "@jskit-ai/kernel/client";
 import { normalizeObject, normalizeRecordId, normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
@@ -23,6 +23,7 @@ import { useShellWebErrorRuntime } from "@jskit-ai/shell-web/client/error";
 import { usePagedCollection } from "@jskit-ai/users-web/client/composables/usePagedCollection";
 import { useSurfaceRouteContext } from "@jskit-ai/users-web/client/composables/useSurfaceRouteContext";
 import { resolveAssistantSurfaceConfig } from "../../shared/assistantSurfaces.js";
+import { insertTextAtSelection } from "../support/composerInputSupport.js";
 import { useWorkspaceWebScopeSupport } from "../support/workspaceScopeSupport.js";
 
 const DEFAULT_STREAM_TIMEOUT_MS = 120_000;
@@ -523,6 +524,23 @@ function useAssistantRuntime({ api = null, surfaceId = "" } = {}) {
       return;
     }
 
+    if (event?.key === "Enter" && event?.altKey === true && event?.ctrlKey !== true && event?.metaKey !== true) {
+      event.preventDefault();
+
+      const target = event?.target;
+      const nextValue = insertTextAtSelection(input.value, target?.selectionStart, target?.selectionEnd, "\n");
+      input.value = nextValue.value;
+
+      void nextTick(() => {
+        if (!target || typeof target.setSelectionRange !== "function") {
+          return;
+        }
+
+        target.setSelectionRange(nextValue.selectionStart, nextValue.selectionEnd);
+      });
+      return;
+    }
+
     if (
       event?.key === "Enter" &&
       event?.shiftKey !== true &&

package/src/client/support/composerInputSupport.js

@@ -0,0 +1,29 @@
+function normalizeSelectionBoundary(value, fallback, max) {
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed < 0) {
+    return fallback;
+  }
+
+  if (parsed > max) {
+    return max;
+  }
+
+  return parsed;
+}
+
+function insertTextAtSelection(source = "", selectionStart, selectionEnd, text = "") {
+  const value = String(source || "");
+  const maxBoundary = value.length;
+  const normalizedStart = normalizeSelectionBoundary(selectionStart, maxBoundary, maxBoundary);
+  const normalizedEnd = normalizeSelectionBoundary(selectionEnd, normalizedStart, maxBoundary);
+  const insertedText = String(text ?? "");
+  const nextBoundary = normalizedStart + insertedText.length;
+
+  return {
+    value: `${value.slice(0, normalizedStart)}${insertedText}${value.slice(normalizedEnd)}`,
+    selectionStart: nextBoundary,
+    selectionEnd: nextBoundary
+  };
+}
+
+export { insertTextAtSelection };

package/src/server/actions.js

@@ -1,36 +1,90 @@
+import { createSchema } from "json-rest-schema";
+import {
+  composeSchemaDefinitions
+} from "@jskit-ai/kernel/shared/validators";
+import {
+  deepFreeze
+} from "@jskit-ai/kernel/shared/support/deepFreeze";
 import {
   assistantConfigResource,
   assistantResource
 } from "@jskit-ai/assistant-core/shared";
 import { actionIds } from "./actionIds.js";
-import { assistantTargetSurfaceInputValidator } from "./inputValidators.js";
+import { assistantTargetSurfaceInputValidator } from "./inputSchemas.js";
+
+const runtimeConversationsListQueryInputValidator = deepFreeze({
+  schema: createSchema({
+    query: {
+      type: "object",
+      required: false,
+      schema: assistantResource.operations.conversationsList.query.schema
+    }
+  }),
+  mode: "patch"
+});
+
+const runtimeConversationsListInputValidator = composeSchemaDefinitions(
+  [assistantTargetSurfaceInputValidator, runtimeConversationsListQueryInputValidator],
+  {
+    mode: "patch",
+    context: "assistant-runtime conversations list action input"
+  }
+);
 
-const runtimeQueryInputValidator = [
-  assistantTargetSurfaceInputValidator,
-  { query: assistantResource.operations.conversationsList.queryValidator }
-];
+const runtimeConversationMessagesListQueryInputValidator = deepFreeze({
+  schema: createSchema({
+    query: {
+      type: "object",
+      required: false,
+      schema: assistantResource.operations.conversationMessagesList.query.schema
+    }
+  }),
+  mode: "patch"
+});
 
-const runtimeMessagesInputValidator = [
-  assistantTargetSurfaceInputValidator,
-  assistantResource.operations.conversationMessagesList.paramsValidator,
+const runtimeConversationMessagesListInputValidator = composeSchemaDefinitions(
+  [
+    assistantTargetSurfaceInputValidator,
+    assistantResource.operations.conversationMessagesList.params,
+    runtimeConversationMessagesListQueryInputValidator
+  ],
   {
-    query: assistantResource.operations.conversationMessagesList.queryValidator
+    mode: "patch",
+    context: "assistant-runtime conversation messages action input"
   }
-];
+);
 
-const runtimeChatInputValidator = [
-  assistantTargetSurfaceInputValidator,
-  assistantResource.operations.chatStream.bodyValidator
-];
+const runtimeChatStreamInputValidator = composeSchemaDefinitions(
+  [
+    assistantTargetSurfaceInputValidator,
+    assistantResource.operations.chatStream.body
+  ],
+  {
+    mode: "patch",
+    context: "assistant-runtime chat stream action input"
+  }
+);
 
 const settingsReadInputValidator = assistantTargetSurfaceInputValidator;
 
-const settingsUpdateInputValidator = [
-  assistantTargetSurfaceInputValidator,
+const settingsUpdatePatchInputValidator = deepFreeze({
+  schema: createSchema({
+    patch: {
+      type: "object",
+      required: true,
+      schema: assistantConfigResource.operations.patch.body.schema
+    }
+  }),
+  mode: "patch"
+});
+
+const settingsUpdateInputValidator = composeSchemaDefinitions(
+  [assistantTargetSurfaceInputValidator, settingsUpdatePatchInputValidator],
   {
-    patch: assistantConfigResource.operations.patch.bodyValidator
+    mode: "patch",
+    context: "assistant-runtime settings update action input"
   }
-];
+);
 
 const assistantActions = Object.freeze([
   {
@@ -42,7 +96,7 @@ const assistantActions = Object.freeze([
     permission: {
       require: "authenticated"
     },
-    inputValidator: runtimeChatInputValidator,
+    input: runtimeChatStreamInputValidator,
     idempotency: "optional",
     audit: {
       actionName: actionIds.chatStream
@@ -65,8 +119,8 @@ const assistantActions = Object.freeze([
     permission: {
       require: "authenticated"
     },
-    inputValidator: runtimeQueryInputValidator,
-    outputValidator: assistantResource.operations.conversationsList.outputValidator,
+    input: runtimeConversationsListInputValidator,
+    output: assistantResource.operations.conversationsList.output,
     idempotency: "none",
     audit: {
       actionName: actionIds.conversationsList
@@ -88,8 +142,8 @@ const assistantActions = Object.freeze([
     permission: {
       require: "authenticated"
     },
-    inputValidator: runtimeMessagesInputValidator,
-    outputValidator: assistantResource.operations.conversationMessagesList.outputValidator,
+    input: runtimeConversationMessagesListInputValidator,
+    output: assistantResource.operations.conversationMessagesList.output,
     idempotency: "none",
     audit: {
       actionName: actionIds.conversationMessagesList
@@ -111,8 +165,8 @@ const assistantActions = Object.freeze([
     permission: {
       require: "authenticated"
     },
-    inputValidator: settingsReadInputValidator,
-    outputValidator: assistantConfigResource.operations.view.outputValidator,
+    input: settingsReadInputValidator,
+    output: assistantConfigResource.operations.view.output,
     idempotency: "none",
     audit: {
       actionName: actionIds.settingsRead
@@ -133,8 +187,8 @@ const assistantActions = Object.freeze([
     permission: {
       require: "authenticated"
     },
-    inputValidator: settingsUpdateInputValidator,
-    outputValidator: assistantConfigResource.operations.patch.outputValidator,
+    input: settingsUpdateInputValidator,
+    output: assistantConfigResource.operations.patch.output,
     idempotency: "optional",
     audit: {
       actionName: actionIds.settingsUpdate

package/src/server/inputSchemas.js

@@ -0,0 +1,44 @@
+import { createSchema } from "json-rest-schema";
+import { deepFreeze } from "@jskit-ai/kernel/shared/support/deepFreeze";
+
+const assistantSurfaceRouteParamsSchema = createSchema({
+  surfaceId: {
+    type: "string",
+    required: true,
+    lowercase: true,
+    minLength: 1,
+    maxLength: 64
+  }
+});
+
+const assistantTargetSurfaceInputSchema = createSchema({
+  targetSurfaceId: {
+    type: "string",
+    required: true,
+    lowercase: true,
+    minLength: 1,
+    maxLength: 64
+  },
+  workspaceSlug: {
+    type: "string",
+    required: false,
+    lowercase: true,
+    minLength: 1,
+    maxLength: 160
+  }
+});
+
+const assistantSurfaceRouteParamsValidator = deepFreeze({
+  schema: assistantSurfaceRouteParamsSchema,
+  mode: "patch"
+});
+
+const assistantTargetSurfaceInputValidator = deepFreeze({
+  schema: assistantTargetSurfaceInputSchema,
+  mode: "patch"
+});
+
+export {
+  assistantSurfaceRouteParamsValidator,
+  assistantTargetSurfaceInputValidator
+};

package/src/server/registerRoutes.js

@@ -1,5 +1,6 @@
 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 { withStandardErrorResponses } from "@jskit-ai/http-runtime/shared/validators/errorResponses";
 import {
@@ -15,28 +16,21 @@ import {
 } from "@jskit-ai/assistant-core/server";
 import { resolveAssistantSurfaceConfig } from "../shared/assistantSurfaces.js";
 import { actionIds } from "./actionIds.js";
-import { assistantSurfaceRouteParamsValidator } from "./inputValidators.js";
+import { assistantSurfaceRouteParamsValidator } from "./inputSchemas.js";
 import { resolveWorkspaceServerScopeSupport } from "./support/workspaceScopeSupport.js";
 
-function buildRouteParamsValidator(requiresWorkspace, workspaceScopeSupport = null) {
-  if (requiresWorkspace === true) {
-    if (!workspaceScopeSupport) {
-      throw new Error("Assistant workspace routes require workspace server scope support.");
-    }
-
-    return [workspaceScopeSupport.paramsValidator, assistantSurfaceRouteParamsValidator];
-  }
-
-  return assistantSurfaceRouteParamsValidator;
-}
-
-function buildConversationMessagesRouteParamsValidator(requiresWorkspace, workspaceScopeSupport = null) {
-  const validators = buildRouteParamsValidator(requiresWorkspace, workspaceScopeSupport);
-  if (Array.isArray(validators)) {
-    return validators.concat(assistantResource.operations.conversationMessagesList.paramsValidator);
+function requireWorkspaceAssistantRouteParams(workspaceScopeSupport = null) {
+  if (!workspaceScopeSupport) {
+    throw new Error("Assistant workspace routes require workspace server scope support.");
   }
 
-  return [validators, assistantResource.operations.conversationMessagesList.paramsValidator];
+  return composeSchemaDefinitions(
+    [workspaceScopeSupport.params, assistantSurfaceRouteParamsValidator],
+    {
+      mode: "patch",
+      context: "assistant-runtime workspace surface route params"
+    }
+  );
 }
 
 function readWorkspaceInput(request, requiresWorkspace, workspaceScopeSupport = null) {
@@ -146,6 +140,22 @@ function resolveRouteRequestState(
   });
 }
 
+function buildChatStreamActionInput(routeInput = {}, requestBody = {}) {
+  const actionInput = {
+    ...routeInput,
+    messageId: requestBody.messageId,
+    input: requestBody.input
+  };
+
+  for (const key of ["conversationId", "history", "clientContext"]) {
+    if (Object.prototype.hasOwnProperty.call(requestBody, key)) {
+      actionInput[key] = requestBody[key];
+    }
+  }
+
+  return actionInput;
+}
+
 function registerSettingsRoutes(
   router,
   resolveCurrentAppConfig,
@@ -156,7 +166,9 @@ function registerSettingsRoutes(
   });
   const visibility = requiresWorkspace ? "workspace" : "public";
   const routePath = `${routeBase}/:surfaceId/settings`;
-  const paramsValidator = buildRouteParamsValidator(requiresWorkspace, workspaceScopeSupport);
+  const params = requiresWorkspace === true
+    ? requireWorkspaceAssistantRouteParams(workspaceScopeSupport)
+    : assistantSurfaceRouteParamsValidator;
 
   router.register(
     "GET",
@@ -164,13 +176,13 @@ function registerSettingsRoutes(
     {
       auth: "required",
       visibility,
-      paramsValidator,
+      params,
       meta: {
         tags: ["assistant", "settings"],
         summary: "Get assistant settings."
       },
-      responseValidators: withStandardErrorResponses({
-        200: assistantConfigResource.operations.view.outputValidator
+      responses: withStandardErrorResponses({
+        200: assistantConfigResource.operations.view.output
       })
     },
     async function assistantSettingsReadRoute(request, reply) {
@@ -199,15 +211,15 @@ function registerSettingsRoutes(
     {
       auth: "required",
       visibility,
-      paramsValidator,
+      params,
       meta: {
         tags: ["assistant", "settings"],
         summary: "Update assistant settings."
       },
-      bodyValidator: assistantConfigResource.operations.patch.bodyValidator,
-      responseValidators: withStandardErrorResponses(
+      body: assistantConfigResource.operations.patch.body,
+      responses: withStandardErrorResponses(
         {
-          200: assistantConfigResource.operations.patch.outputValidator
+          200: assistantConfigResource.operations.patch.output
         },
         {
           includeValidation400: true
@@ -248,7 +260,18 @@ function registerRuntimeRoutes(
   });
   const visibility = requiresWorkspace ? "workspace" : "public";
   const surfaceRouteBase = `${routeBase}/:surfaceId`;
-  const paramsValidator = buildRouteParamsValidator(requiresWorkspace, workspaceScopeSupport);
+  const params = requiresWorkspace === true
+    ? requireWorkspaceAssistantRouteParams(workspaceScopeSupport)
+    : assistantSurfaceRouteParamsValidator;
+  const conversationMessagesParams = composeSchemaDefinitions(
+    [params, assistantResource.operations.conversationMessagesList.params],
+    {
+      mode: "patch",
+      context: requiresWorkspace === true
+        ? "assistant-runtime workspace conversation messages route params"
+        : "assistant-runtime conversation messages route params"
+    }
+  );
 
   router.register(
     "POST",
@@ -256,12 +279,12 @@ function registerRuntimeRoutes(
     {
       auth: "required",
       visibility,
-      paramsValidator,
+      params,
       meta: {
         tags: ["assistant"],
         summary: "Stream assistant response."
       },
-      bodyValidator: assistantResource.operations.chatStream.bodyValidator
+      body: assistantResource.operations.chatStream.body
     },
     async function assistantChatStreamRoute(request, reply) {
       const routeState = resolveRouteRequestState(request, {
@@ -331,14 +354,7 @@ function registerRuntimeRoutes(
           context: {
             surface: routeState.hostSurfaceId
           },
-          input: {
-            ...routeState.actionInput,
-            messageId: requestBody.messageId,
-            conversationId: requestBody.conversationId,
-            input: requestBody.input,
-            history: requestBody.history,
-            clientContext: requestBody.clientContext
-          },
+          input: buildChatStreamActionInput(routeState.actionInput, requestBody),
           deps: {
             streamWriter,
             abortSignal: abortController.signal
@@ -379,14 +395,14 @@ function registerRuntimeRoutes(
     {
       auth: "required",
       visibility,
-      paramsValidator,
+      params,
       meta: {
         tags: ["assistant"],
         summary: "List assistant conversations."
       },
-      queryValidator: assistantResource.operations.conversationsList.queryValidator,
-      responseValidators: withStandardErrorResponses({
-        200: assistantResource.operations.conversationsList.outputValidator
+      query: assistantResource.operations.conversationsList.query,
+      responses: withStandardErrorResponses({
+        200: assistantResource.operations.conversationsList.output
       })
     },
     async function assistantConversationsRoute(request, reply) {
@@ -418,14 +434,14 @@ function registerRuntimeRoutes(
     {
       auth: "required",
       visibility,
-      paramsValidator: buildConversationMessagesRouteParamsValidator(requiresWorkspace, workspaceScopeSupport),
+      params: conversationMessagesParams,
       meta: {
         tags: ["assistant"],
         summary: "List assistant conversation messages."
       },
-      queryValidator: assistantResource.operations.conversationMessagesList.queryValidator,
-      responseValidators: withStandardErrorResponses({
-        200: assistantResource.operations.conversationMessagesList.outputValidator
+      query: assistantResource.operations.conversationMessagesList.query,
+      responses: withStandardErrorResponses({
+        200: assistantResource.operations.conversationMessagesList.output
       })
     },
     async function assistantConversationMessagesRoute(request, reply) {

package/src/server/support/workspaceScopeSupport.js

@@ -1,11 +1,23 @@
+import { normalizeSchemaDefinition } from "@jskit-ai/kernel/shared/validators";
+
 const WORKSPACES_SERVER_SCOPE_SUPPORT_TOKEN = "workspaces.server.scope-support";
 
+function hasWorkspaceRouteParamsDefinition(value) {
+  try {
+    return Boolean(normalizeSchemaDefinition(value, {
+      context: "assistant-runtime workspace scope support.params",
+      defaultMode: "patch"
+    }));
+  } catch {
+    return false;
+  }
+}
+
 function isWorkspaceServerScopeSupport(value) {
   return Boolean(
     value &&
       value.available === true &&
-      value.paramsValidator &&
-      typeof value.paramsValidator.normalize === "function" &&
+      hasWorkspaceRouteParamsDefinition(value.params) &&
       typeof value.buildInputFromRouteParams === "function" &&
       typeof value.resolveWorkspace === "function"
   );

package/test/actionDefinitions.test.js

@@ -0,0 +1,192 @@
+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 { actionIds } from "../src/server/actionIds.js";
+
+function createSingletonApp() {
+  const singletons = new Map();
+  const instances = new Map();
+  const tags = new Map();
+
+  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);
+      }
+      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 };
+    }
+  }));
+
+  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-runtime conversations list action keeps query nested under a schema definition", () => {
+  const definition = findDefinition(createAssistantActionExecutor().listDefinitions(), actionIds.conversationsList);
+  const result = definition.input.schema.patch({
+    targetSurfaceId: "home",
+    workspaceSlug: "example-workspace",
+    query: {
+      limit: 10,
+      status: "active"
+    }
+  });
+
+  assert.deepEqual(result.errors, {});
+  assert.deepEqual(result.validatedObject, {
+    targetSurfaceId: "home",
+    workspaceSlug: "example-workspace",
+    query: {
+      limit: 10,
+      status: "active"
+    }
+  });
+});
+
+test("assistant-runtime conversation messages list action composes params and nested query", () => {
+  const definition = findDefinition(createAssistantActionExecutor().listDefinitions(), actionIds.conversationMessagesList);
+  const result = definition.input.schema.patch({
+    targetSurfaceId: "home",
+    conversationId: "123",
+    query: {
+      page: 2,
+      pageSize: 25
+    }
+  });
+
+  assert.deepEqual(result.errors, {});
+  assert.deepEqual(result.validatedObject, {
+    targetSurfaceId: "home",
+    conversationId: 123,
+    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);
+  const result = definition.input.schema.patch({
+    targetSurfaceId: "home",
+    patch: {
+      systemPrompt: "Be concise."
+    }
+  });
+
+  assert.deepEqual(result.errors, {});
+  assert.deepEqual(result.validatedObject, {
+    targetSurfaceId: "home",
+    patch: {
+      systemPrompt: "Be concise."
+    }
+  });
+});

package/test/assistantServerConfig.test.js

@@ -5,7 +5,7 @@ import {
   resolveAssistantServerConfig
 } from "../src/server/support/assistantServerConfig.js";
 
-test("assistant server config resolves per-surface AI config without legacy global fallback", () => {
+test("assistant server config resolves per-surface AI config without app-level global fallback", () => {
   const appConfig = {
     assistantServer: {
       admin: {
@@ -21,14 +21,14 @@ test("assistant server config resolves per-surface AI config without legacy glob
     },
     assistant: {
       provider: "openai",
-      apiKey: "legacy-key"
+      apiKey: "global-key"
     }
   };
   const env = {
     ADMIN_ASSISTANT_AI_PROVIDER: "deepseek",
     ADMIN_ASSISTANT_AI_API_KEY: "surface-key",
     AI_PROVIDER: "openai",
-    AI_API_KEY: "legacy-env-key"
+    AI_API_KEY: "global-env-key"
   };
 
   assert.deepEqual(resolveAssistantServerConfig(appConfig, "admin"), {
@@ -62,7 +62,7 @@ test("assistant server config requires explicit aiConfigPrefix for each surface"
           appConfig: {},
           env: {
             AI_PROVIDER: "anthropic",
-            AI_API_KEY: "legacy-env-key"
+            AI_API_KEY: "global-env-key"
           }
         },
         "admin"

package/test/composerInputSupport.test.js

@@ -0,0 +1,23 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { insertTextAtSelection } from "../src/client/support/composerInputSupport.js";
+
+test("insertTextAtSelection inserts a line break at the caret", () => {
+  const result = insertTextAtSelection("hello world", 5, 5, "\n");
+
+  assert.deepEqual(result, {
+    value: "hello\n world",
+    selectionStart: 6,
+    selectionEnd: 6
+  });
+});
+
+test("insertTextAtSelection replaces the active selection with a line break", () => {
+  const result = insertTextAtSelection("hello world", 5, 11, "\n");
+
+  assert.deepEqual(result, {
+    value: "hello\n",
+    selectionStart: 6,
+    selectionEnd: 6
+  });
+});

package/test/lazyAppConfig.test.js

@@ -1,6 +1,8 @@
 import assert from "node:assert/strict";
 import test from "node:test";
+import { createSchema } from "json-rest-schema";
 import { AppError } from "@jskit-ai/kernel/server/runtime";
+import { createRouter } from "../../kernel/server/http/lib/router.js";
 import { registerRoutes } from "../src/server/registerRoutes.js";
 import { createChatService } from "../src/server/services/chatService.js";
 
@@ -26,12 +28,17 @@ function createAssistantAppConfig() {
 function createWorkspaceServerScopeSupport() {
   return Object.freeze({
     available: true,
-    paramsValidator: Object.freeze({
-      normalize(value = {}) {
-        return {
-          workspaceSlug: String(value?.workspaceSlug || "").trim().toLowerCase()
-        };
-      }
+    params: Object.freeze({
+      schema: createSchema({
+        workspaceSlug: {
+          type: "string",
+          required: true,
+          lowercase: true,
+          minLength: 1,
+          maxLength: 160
+        }
+      }),
+      mode: "patch"
     }),
     buildInputFromRouteParams(params = {}) {
       const workspaceSlug = String(params?.workspaceSlug || "").trim().toLowerCase();
@@ -43,39 +50,52 @@ function createWorkspaceServerScopeSupport() {
   });
 }
 
-test("registerRoutes resolves appConfig lazily when handlers run", async () => {
-  const routes = [];
-  let currentAppConfig = null;
-
-  const router = {
-    register(method, path, options, handler) {
-      routes.push({ method, path, options, handler });
-    }
-  };
+function createAssistantTestApp({
+  resolveCurrentAppConfig = () => null,
+  workspaceScopeSupport = null,
+  router = null
+} = {}) {
+  const resolvedRouter = router || createRouter();
 
-  const app = {
-    make(token) {
-      if (token === "jskit.http.router") {
-        return router;
-      }
-      if (token === "appConfig") {
-        return currentAppConfig;
-      }
-      if (token === "workspaces.server.scope-support") {
-        return createWorkspaceServerScopeSupport();
+  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);
       }
-      throw new Error(`Unexpected token: ${token}`);
-    },
-    has(token) {
-      return (
-        (token === "appConfig" ? Boolean(currentAppConfig) : token === "jskit.http.router") ||
-        token === "workspaces.server.scope-support"
-      );
     }
   };
+}
+
+test("registerRoutes resolves appConfig lazily when handlers run", async () => {
+  let currentAppConfig = null;
+  const workspaceScopeSupport = createWorkspaceServerScopeSupport();
+  const testApp = createAssistantTestApp({
+    workspaceScopeSupport,
+    resolveCurrentAppConfig: () => currentAppConfig
+  });
 
-  registerRoutes(app);
+  registerRoutes(testApp.app);
   currentAppConfig = createAssistantAppConfig();
+  const routes = testApp.router.list();
 
   const route = routes.find(
     (entry) =>
@@ -135,38 +155,17 @@ test("registerRoutes resolves appConfig lazily when handlers run", async () => {
 });
 
 test("registerRoutes returns clear AppError payload for pre-stream assistant failures", async () => {
-  const routes = [];
   let currentAppConfig = null;
+  let capturedInput = null;
+  const workspaceScopeSupport = createWorkspaceServerScopeSupport();
+  const testApp = createAssistantTestApp({
+    workspaceScopeSupport,
+    resolveCurrentAppConfig: () => currentAppConfig
+  });
 
-  const router = {
-    register(method, path, options, handler) {
-      routes.push({ method, path, options, handler });
-    }
-  };
-
-  const app = {
-    make(token) {
-      if (token === "jskit.http.router") {
-        return router;
-      }
-      if (token === "appConfig") {
-        return currentAppConfig;
-      }
-      if (token === "workspaces.server.scope-support") {
-        return createWorkspaceServerScopeSupport();
-      }
-      throw new Error(`Unexpected token: ${token}`);
-    },
-    has(token) {
-      return (
-        (token === "appConfig" ? Boolean(currentAppConfig) : token === "jskit.http.router") ||
-        token === "workspaces.server.scope-support"
-      );
-    }
-  };
-
-  registerRoutes(app);
+  registerRoutes(testApp.app);
   currentAppConfig = createAssistantAppConfig();
+  const routes = testApp.router.list();
 
   const route = routes.find(
     (entry) =>
@@ -212,7 +211,8 @@ test("registerRoutes returns clear AppError payload for pre-stream assistant fai
           history: []
         }
       },
-      executeAction: async () => {
+      executeAction: async ({ input }) => {
+        capturedInput = input;
         throw new AppError(503, "Assistant provider is not configured.");
       }
     },
@@ -224,6 +224,13 @@ test("registerRoutes returns clear AppError payload for pre-stream assistant fai
     error: "Assistant provider is not configured.",
     code: "APP_ERROR"
   });
+  assert.deepEqual(capturedInput, {
+    targetSurfaceId: "admin",
+    workspaceSlug: "dogandgroom",
+    messageId: "msg_1",
+    input: "hello",
+    history: []
+  });
 });
 
 test("chat service resolves appConfig lazily when conversations are listed", async () => {
@@ -321,27 +328,12 @@ test("chat service rejects workspace-scoped assistant surfaces when workspace su
 });
 
 test("registerRoutes omits workspace assistant routes when workspace scope support is unavailable", () => {
-  const routes = [];
-  const app = {
-    make(token) {
-      if (token === "jskit.http.router") {
-        return {
-          register(method, path, options, handler) {
-            routes.push({ method, path, options, handler });
-          }
-        };
-      }
-      if (token === "appConfig") {
-        return createAssistantAppConfig();
-      }
-      throw new Error(`Unexpected token: ${token}`);
-    },
-    has(token) {
-      return token === "jskit.http.router" || token === "appConfig";
-    }
-  };
+  const testApp = createAssistantTestApp({
+    resolveCurrentAppConfig: () => createAssistantAppConfig()
+  });
 
-  registerRoutes(app);
+  registerRoutes(testApp.app);
+  const routes = testApp.router.list();
 
   assert.equal(
     routes.some((entry) => entry.path.startsWith("/api/w/:workspaceSlug/assistant/")),

package/src/server/inputValidators.js

@@ -1,41 +0,0 @@
-import { Type } from "typebox";
-import { normalizeSurfaceId } from "@jskit-ai/kernel/shared/surface/registry";
-import { normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
-
-const assistantSurfaceRouteParamsValidator = Object.freeze({
-  schema: Type.Object(
-    {
-      surfaceId: Type.String({ minLength: 1, maxLength: 64 })
-    },
-    { additionalProperties: false }
-  ),
-  normalize(value = {}) {
-    return {
-      surfaceId: normalizeSurfaceId(value?.surfaceId)
-    };
-  }
-});
-
-const assistantTargetSurfaceInputValidator = Object.freeze({
-  schema: Type.Object(
-    {
-      targetSurfaceId: Type.String({ minLength: 1, maxLength: 64 }),
-      workspaceSlug: Type.Optional(Type.String({ minLength: 1, maxLength: 160 }))
-    },
-    { additionalProperties: false }
-  ),
-  normalize(value = {}) {
-    const targetSurfaceId = normalizeSurfaceId(value?.targetSurfaceId);
-    const workspaceSlug = normalizeText(value?.workspaceSlug).toLowerCase();
-
-    return {
-      targetSurfaceId,
-      ...(workspaceSlug ? { workspaceSlug } : {})
-    };
-  }
-});
-
-export {
-  assistantSurfaceRouteParamsValidator,
-  assistantTargetSurfaceInputValidator
-};