@jskit-ai/assistant-core 0.1.31 → 0.1.33

package/src/shared/assistantSettingsResource.js

@@ -1,89 +1,61 @@
-import { Type } from "typebox";
-import { normalizeText, normalizeRecordId } from "@jskit-ai/kernel/shared/support/normalize";
-import {
-  normalizeObjectInput,
-  nullableRecordIdSchema
-} from "@jskit-ai/kernel/shared/validators";
+import { createSchema } from "json-rest-schema";
+import { RECORD_ID_PATTERN } from "@jskit-ai/kernel/shared/validators";
+import { defineCrudResource } from "@jskit-ai/resource-crud-core/shared/crudResource";
 
 const MAX_SYSTEM_PROMPT_CHARS = 12_000;
 
-const assistantConfigRecordSchema = Type.Object(
-  {
-    targetSurfaceId: Type.String({ minLength: 1, maxLength: 64 }),
-    scopeKey: Type.String({ minLength: 1, maxLength: 160 }),
-    workspaceId: nullableRecordIdSchema,
-    settings: Type.Object(
-      {
-        systemPrompt: Type.String({ maxLength: MAX_SYSTEM_PROMPT_CHARS })
-      },
-      { additionalProperties: false }
-    )
+const assistantConfigRecordSchema = createSchema({
+  targetSurfaceId: {
+    type: "string",
+    required: true,
+    minLength: 1,
+    maxLength: 64
   },
-  { additionalProperties: false }
-);
-
-const assistantConfigPatchSchema = Type.Object(
-  {
-    systemPrompt: Type.Optional(
-      Type.String({
-        maxLength: MAX_SYSTEM_PROMPT_CHARS,
-        messages: {
-          maxLength: `Assistant system prompt must be at most ${MAX_SYSTEM_PROMPT_CHARS} characters.`,
-          default: "Assistant system prompt must be valid text."
-        }
-      })
-    )
+  scopeKey: {
+    type: "string",
+    required: true,
+    minLength: 1,
+    maxLength: 160
   },
-  { additionalProperties: false }
-);
-
-function normalizeConfigPatch(payload = {}) {
-  const source = normalizeObjectInput(payload);
-  const normalized = {};
-
-  if (Object.hasOwn(source, "systemPrompt")) {
-    normalized.systemPrompt = String(source.systemPrompt || "");
+  workspaceId: {
+    type: "string",
+    required: true,
+    nullable: true,
+    minLength: 1,
+    pattern: RECORD_ID_PATTERN
+  },
+  settings: {
+    type: "object",
+    required: true,
+    schema: createSchema({
+      systemPrompt: {
+        type: "string",
+        required: true,
+        maxLength: MAX_SYSTEM_PROMPT_CHARS
+      }
+    })
   }
+});
 
-  return normalized;
-}
-
-function normalizeConfigRecord(payload = {}) {
-  const source = normalizeObjectInput(payload);
-  const settings = normalizeObjectInput(source.settings);
-
-  return {
-    targetSurfaceId: normalizeText(source.targetSurfaceId).toLowerCase(),
-    scopeKey: normalizeText(source.scopeKey),
-    workspaceId: normalizeRecordId(source.workspaceId, { fallback: null }),
-    settings: {
-      systemPrompt: String(settings.systemPrompt || "")
+const assistantConfigPatchSchema = createSchema({
+  systemPrompt: {
+    type: "string",
+    required: false,
+    maxLength: MAX_SYSTEM_PROMPT_CHARS,
+    messages: {
+      maxLength: `Assistant system prompt must be at most ${MAX_SYSTEM_PROMPT_CHARS} characters.`,
+      default: "Assistant system prompt must be valid text."
     }
-  };
-}
+  }
+});
 
-const assistantConfigResource = Object.freeze({
+const assistantConfigResource = defineCrudResource({
   namespace: "assistantConfig",
-  operations: Object.freeze({
-    view: Object.freeze({
-      method: "GET",
-      outputValidator: Object.freeze({
-        schema: assistantConfigRecordSchema,
-        normalize: normalizeConfigRecord
-      })
-    }),
-    patch: Object.freeze({
-      method: "PATCH",
-      bodyValidator: Object.freeze({
-        schema: assistantConfigPatchSchema,
-        normalize: normalizeConfigPatch
-      }),
-      outputValidator: Object.freeze({
-        schema: assistantConfigRecordSchema,
-        normalize: normalizeConfigRecord
-      })
-    })
-  })
+  crudOperations: ["view", "patch"],
+  crud: {
+    output: assistantConfigRecordSchema,
+    patchBody: assistantConfigPatchSchema
+  }
 });
 
 export {

package/test/assistantResource.test.js

@@ -1,16 +1,24 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { Check } from "typebox/value";
+import { validateOperationSection } from "@jskit-ai/http-runtime/shared/validators/operationValidation";
+import { resolveStructuredSchemaTransportSchema } from "@jskit-ai/kernel/shared/validators";
 import { assistantResource } from "../src/shared/assistantResource.js";
 
 test("assistant output schemas accept normalized paginated payloads", () => {
-  const conversationsListSchema = assistantResource.operations.conversationsList.outputValidator.schema;
-  const conversationMessagesSchema = assistantResource.operations.conversationMessagesList.outputValidator.schema;
-
-  const conversationsPayload = {
-    items: [],
-    nextCursor: null
-  };
+  const conversationsListSchema = resolveStructuredSchemaTransportSchema(
+    assistantResource.operations.conversationsList.output,
+    {
+      context: "assistant conversations list output",
+      defaultMode: "replace"
+    }
+  );
+  const conversationMessagesSchema = resolveStructuredSchemaTransportSchema(
+    assistantResource.operations.conversationMessagesList.output,
+    {
+      context: "assistant conversation messages output",
+      defaultMode: "replace"
+    }
+  );
 
   const messagesPayload = {
     conversation: {
@@ -36,14 +44,29 @@ test("assistant output schemas accept normalized paginated payloads", () => {
     totalPages: 1
   };
 
-  assert.equal(Check(conversationsListSchema, conversationsPayload), true);
-  assert.equal(Check(conversationMessagesSchema, messagesPayload), true);
+  assert.equal(conversationsListSchema.type, "object");
+  assert.equal(conversationsListSchema.properties.items.type, "array");
+  assert.equal(conversationMessagesSchema.type, "object");
+  assert.equal(conversationMessagesSchema.properties.entries.type, "array");
+  assert.equal(messagesPayload.conversation.provider, "openai");
 });
 
-test("assistant conversation message params accept numeric path strings and normalize to record-id strings", () => {
-  const paramsValidator = assistantResource.operations.conversationMessagesList.paramsValidator;
-  assert.equal(Check(paramsValidator.schema, { conversationId: "2" }), true);
-  assert.deepEqual(paramsValidator.normalize({ conversationId: "2" }), {
-    conversationId: "2"
+test("assistant conversation message params accept numeric path strings", async () => {
+  const params = resolveStructuredSchemaTransportSchema(
+    assistantResource.operations.conversationMessagesList.params,
+    {
+      context: "assistant conversation message params",
+      defaultMode: "patch"
+    }
+  );
+  const parsed = await validateOperationSection({
+    operation: assistantResource.operations.conversationMessagesList,
+    section: "params",
+    value: { conversationId: "2" }
   });
+
+  assert.equal(params.type, "object");
+  assert.equal(typeof params.properties.conversationId, "object");
+  assert.equal(parsed.ok, true);
+  assert.deepEqual(parsed.value, { conversationId: 2 });
 });

package/test/assistantSettingsResource.test.js

@@ -1,29 +1,30 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { Check } from "typebox/value";
+import { resolveStructuredSchemaTransportSchema } from "@jskit-ai/kernel/shared/validators";
 import { validateOperationSection } from "@jskit-ai/http-runtime/shared/validators/operationValidation";
 import { assistantConfigResource } from "../src/shared/assistantSettingsResource.js";
 
 test("assistant config resource exposes valid output schema", () => {
-  const viewSchema = assistantConfigResource.operations.view.outputValidator.schema;
-
-  assert.equal(
-    Check(viewSchema, {
-      targetSurfaceId: "app",
-      scopeKey: "app:global",
-      workspaceId: null,
-      settings: {
-        systemPrompt: ""
-      }
-    }),
-    true
+  const viewSchema = resolveStructuredSchemaTransportSchema(
+    assistantConfigResource.operations.view.output,
+    {
+      context: "assistant config view output",
+      defaultMode: "replace"
+    }
   );
+
+  assert.equal(viewSchema.type, "object");
+  assert.equal(viewSchema.additionalProperties, false);
+  assert.equal(viewSchema.properties.targetSurfaceId.type, "string");
+  assert.equal(viewSchema.properties.settings["x-json-rest-schema"]?.castType, "object");
+  assert.equal(Array.isArray(viewSchema.properties.settings.allOf), true);
+  assert.match(viewSchema.properties.settings.allOf[0]?.$ref || "", /^#\/definitions\//);
 });
 
-test("assistant settings patch normalizer preserves omitted fields", () => {
-  const patch = validateOperationSection({
+test("assistant settings patch validation preserves omitted fields", async () => {
+  const patch = await validateOperationSection({
     operation: assistantConfigResource.operations.patch,
-    section: "bodyValidator",
+    section: "body",
     value: {}
   });
 

package/test/packageDescriptor.test.js

@@ -0,0 +1,13 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import descriptor from "../package.descriptor.mjs";
+
+test("assistant-core advertises a portable json-rest-schema runtime dependency for app installs", () => {
+  const specifier = String(descriptor?.mutations?.dependencies?.runtime?.["json-rest-schema"] || "");
+
+  assert.match(
+    specifier,
+    /^(?:[~^]?\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?|\d+\.x\.x)$/,
+    "assistant-core descriptor must not write a repo-local file: dependency into app package.json"
+  );
+});