@jskit-ai/assistant-core 0.1.31 → 0.1.32

package/test/serviceToolCatalog.test.js

@@ -1,6 +1,6 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { Type } from "typebox";
+import { createSchema } from "json-rest-schema";
 import { createContainer } from "@jskit-ai/kernel/_testable";
 import { ActionRuntimeServiceProvider } from "@jskit-ai/kernel/server/actions";
 import { installServiceRegistrationApi } from "@jskit-ai/kernel/server/runtime";
@@ -17,6 +17,32 @@ function createApp() {
   return app;
 }
 
+function createEmptyInputSchema() {
+  return createSchema({});
+}
+
+function createListOutputSchema() {
+  return createSchema({
+    items: {
+      type: "array",
+      required: true,
+      items: {
+        type: "object",
+        additionalProperties: true
+      }
+    }
+  });
+}
+
+function createOkOutputSchema() {
+  return createSchema({
+    ok: {
+      type: "boolean",
+      required: true
+    }
+  });
+}
+
 test("service tool catalog hides methods user cannot execute", () => {
   const app = createApp();
   const actionRuntimeProvider = new ActionRuntimeServiceProvider();
@@ -48,17 +74,11 @@ test("service tool catalog hides methods user cannot execute", () => {
       dependencies: {
         customersService: "demo.customers.service"
       },
-      inputValidator: {
-        schema: { type: "object", additionalProperties: true }
+      input: {
+        schema: createEmptyInputSchema()
       },
-      outputValidator: {
-        schema: {
-          type: "array",
-          items: {
-            type: "object",
-            additionalProperties: true
-          }
-        }
+      output: {
+        schema: createListOutputSchema()
       },
       idempotency: "none",
       audit: {
@@ -83,14 +103,11 @@ test("service tool catalog hides methods user cannot execute", () => {
       dependencies: {
         customersService: "demo.customers.service"
       },
-      inputValidator: {
-        schema: { type: "object", additionalProperties: true }
+      input: {
+        schema: createEmptyInputSchema()
       },
-      outputValidator: {
-        schema: {
-          type: "object",
-          additionalProperties: true
-        }
+      output: {
+        schema: createOkOutputSchema()
       },
       idempotency: "optional",
       audit: {
@@ -210,11 +227,11 @@ test("service tool catalog hides actions that are not automation-enabled", () =>
       dependencies: {
         nonAutomationService: "demo.non_automation.service"
       },
-      inputValidator: {
-        schema: Type.Object({}, { additionalProperties: false })
+      input: {
+        schema: createSchema({})
       },
-      outputValidator: {
-        schema: Type.Array(Type.Object({}, { additionalProperties: true }))
+      output: {
+        schema: createListOutputSchema()
       },
       idempotency: "none",
       audit: {
@@ -268,11 +285,11 @@ test("service tool catalog honors barred action ids", () => {
       dependencies: {
         auditService: "demo.audit.service"
       },
-      inputValidator: {
-        schema: Type.Object({}, { additionalProperties: false })
+      input: {
+        schema: createEmptyInputSchema()
       },
-      outputValidator: {
-        schema: Type.Array(Type.Object({}, { additionalProperties: true }))
+      output: {
+        schema: createListOutputSchema()
       },
       idempotency: "none",
       audit: {
@@ -326,8 +343,8 @@ test("service tool catalog materializes action tools once and filters per reques
       dependencies: {
         cachedService: "demo.cached.service"
       },
-      inputValidator: {
-        schema: { type: "object", additionalProperties: true }
+      input: {
+        schema: createEmptyInputSchema()
       },
       idempotency: "none",
       audit: {
@@ -374,43 +391,26 @@ test("service tool catalog uses action-backed schemas for tool contracts", () =>
   const actionRuntimeProvider = new ActionRuntimeServiceProvider();
   actionRuntimeProvider.register(app);
 
-  const inputSchema = Object.freeze({
-    type: "object",
-    properties: {
-      args: {
-        type: "array",
-        prefixItems: [
-          {
-            type: "object",
-            properties: {
-              displayName: {
-                type: "string"
-              }
-            },
-            required: ["displayName"],
-            additionalProperties: false
-          }
-        ],
-        minItems: 1,
-        maxItems: 1
-      },
-      options: {
-        type: "object",
-        additionalProperties: true
-      }
-    },
-    additionalProperties: false
-  });
-  const outputSchema = Object.freeze({
-    type: "object",
-    properties: {
-      ok: {
-        type: "boolean"
-      }
+  const inputSchema = createSchema({
+    args: {
+      type: "array",
+      required: true,
+      minItems: 1,
+      maxItems: 1,
+      items: createSchema({
+        displayName: {
+          type: "string",
+          required: true
+        }
+      })
     },
-    required: ["ok"],
-    additionalProperties: false
+    options: {
+      type: "object",
+      required: false,
+      additionalProperties: true
+    }
   });
+  const outputSchema = createOkOutputSchema();
 
   app.service(
     "demo.schemas.service",
@@ -437,10 +437,10 @@ test("service tool catalog uses action-backed schemas for tool contracts", () =>
       dependencies: {
         schemasService: "demo.schemas.service"
       },
-      inputValidator: {
+      input: {
         schema: inputSchema
       },
-      outputValidator: {
+      output: {
         schema: outputSchema
       },
       idempotency: "optional",
@@ -469,24 +469,24 @@ test("service tool catalog uses action-backed schemas for tool contracts", () =>
 
   assert.equal(toolSet.tools.length, 1);
   assert.equal(toolSet.tools[0].description, "Update profile display name.");
-  assert.equal(toolSet.tools[0].parameters, inputSchema);
-  assert.equal(toolSet.tools[0].outputSchema, outputSchema);
+  assert.deepEqual(toolSet.tools[0].parameters, inputSchema.toJsonSchema({ mode: "patch" }));
+  assert.deepEqual(toolSet.tools[0].outputSchema, outputSchema.toJsonSchema({ mode: "replace" }));
 });
 
-test("service tool catalog rejects legacy assistantTool field at assistant layer", () => {
+test("service tool catalog rejects unsupported assistantTool field at assistant layer", () => {
   const app = createApp();
   const actionRuntimeProvider = new ActionRuntimeServiceProvider();
   actionRuntimeProvider.register(app);
 
   app.service(
-    "demo.legacy_assistant.service",
+    "demo.assistant_tool_shape.service",
     () => ({
-      createLegacy(input = {}) {
+      createWithAssistantToolField(input = {}) {
         return {
           ok: Boolean(input)
         };
       },
-      createModern(input = {}) {
+      createWithAssistantExtension(input = {}) {
         return {
           ok: Boolean(input)
         };
@@ -494,24 +494,12 @@ test("service tool catalog rejects legacy assistantTool field at assistant layer
     })
   );
 
-  const schema = Object.freeze({
-    type: "object",
-    additionalProperties: false
-  });
-  const outputSchema = Object.freeze({
-    type: "object",
-    properties: {
-      ok: {
-        type: "boolean"
-      }
-    },
-    required: ["ok"],
-    additionalProperties: false
-  });
+  const schema = createEmptyInputSchema();
+  const outputSchema = createOkOutputSchema();
 
   app.actions([
     {
-      id: "demo.legacy_assistant.create",
+      id: "demo.assistant_tool_shape.create",
       domain: "demo",
       version: 1,
       kind: "command",
@@ -521,28 +509,28 @@ test("service tool catalog rejects legacy assistantTool field at assistant layer
         require: "authenticated"
       },
       dependencies: {
-        legacyAssistantService: "demo.legacy_assistant.service"
+        assistantToolShapeService: "demo.assistant_tool_shape.service"
       },
-      inputValidator: {
+      input: {
         schema
       },
-      outputValidator: {
+      output: {
         schema: outputSchema
       },
       idempotency: "optional",
       audit: {
-        actionName: "demo.legacy_assistant.create"
+        actionName: "demo.assistant_tool_shape.create"
       },
       observability: {},
       assistantTool: {
-        description: "Legacy assistant tool metadata."
+        description: "Unsupported assistant tool metadata."
       },
       async execute(input, _context, deps) {
-        return deps.legacyAssistantService.createLegacy(input);
+        return deps.assistantToolShapeService.createWithAssistantToolField(input);
       }
     },
     {
-      id: "demo.modern_assistant.create",
+      id: "demo.assistant_extension_shape.create",
       domain: "demo",
       version: 1,
       kind: "command",
@@ -552,26 +540,26 @@ test("service tool catalog rejects legacy assistantTool field at assistant layer
         require: "authenticated"
       },
       dependencies: {
-        legacyAssistantService: "demo.legacy_assistant.service"
+        assistantToolShapeService: "demo.assistant_tool_shape.service"
       },
-      inputValidator: {
+      input: {
         schema
       },
-      outputValidator: {
+      output: {
         schema: outputSchema
       },
       idempotency: "optional",
       audit: {
-        actionName: "demo.modern_assistant.create"
+        actionName: "demo.assistant_extension_shape.create"
       },
       observability: {},
       extensions: {
         assistant: {
-          description: "Modern assistant extension metadata."
+          description: "Assistant extension metadata."
         }
       },
       async execute(input, _context, deps) {
-        return deps.legacyAssistantService.createModern(input);
+        return deps.assistantToolShapeService.createWithAssistantExtension(input);
       }
     }
   ]);
@@ -585,7 +573,7 @@ test("service tool catalog rejects legacy assistantTool field at assistant layer
   });
   const actionIds = toolSet.tools.map((tool) => tool.actionId).sort();
 
-  assert.deepEqual(actionIds, ["demo.modern_assistant.create"]);
+  assert.deepEqual(actionIds, ["demo.assistant_extension_shape.create"]);
 });
 
 test("service tool catalog can require input/output schemas for tool exposure", () => {
@@ -623,23 +611,11 @@ test("service tool catalog can require input/output schemas for tool exposure",
       dependencies: {
         strictService: "demo.strict.service"
       },
-      inputValidator: {
-        schema: {
-          type: "object",
-          additionalProperties: false
-        }
+      input: {
+        schema: createEmptyInputSchema()
       },
-      outputValidator: {
-        schema: {
-          type: "object",
-          properties: {
-            ok: {
-              type: "boolean"
-            }
-          },
-          required: ["ok"],
-          additionalProperties: false
-        }
+      output: {
+        schema: createOkOutputSchema()
       },
       idempotency: "none",
       audit: {
@@ -669,30 +645,25 @@ test("service tool catalog derives tool schemas from action contributors", () =>
   const actionRuntimeProvider = new ActionRuntimeServiceProvider();
   actionRuntimeProvider.register(app);
 
-  const inputSchema = Object.freeze({
-    type: "object",
-    properties: {
-      workspaceSlug: {
-        type: "string"
-      },
-      name: {
-        type: "string"
-      },
-      surname: {
-        type: "string"
-      }
+  const inputSchema = createSchema({
+    workspaceSlug: {
+      type: "string",
+      required: false
     },
-    additionalProperties: false
-  });
-  const outputSchema = Object.freeze({
-    type: "object",
-    properties: {
-      id: {
-        type: "integer"
-      }
+    name: {
+      type: "string",
+      required: false
     },
-    required: ["id"],
-    additionalProperties: false
+    surname: {
+      type: "string",
+      required: false
+    }
+  });
+  const outputSchema = createSchema({
+    id: {
+      type: "integer",
+      required: true
+    }
   });
 
   app.service(
@@ -721,10 +692,10 @@ test("service tool catalog derives tool schemas from action contributors", () =>
       dependencies: {
         customersService: "demo.customers.service"
       },
-      inputValidator: {
+      input: {
         schema: inputSchema
       },
-      outputValidator: {
+      output: {
         schema: outputSchema
       },
       idempotency: "optional",
@@ -750,11 +721,11 @@ test("service tool catalog derives tool schemas from action contributors", () =>
   const createTool = toolSet.tools.find((tool) => tool.actionId === "demo.customers.create");
 
   assert.ok(createTool);
-  assert.equal(createTool.parameters, inputSchema);
-  assert.equal(createTool.outputSchema, outputSchema);
+  assert.deepEqual(createTool.parameters, inputSchema.toJsonSchema({ mode: "patch" }));
+  assert.deepEqual(createTool.outputSchema, outputSchema.toJsonSchema({ mode: "replace" }));
 });
 
-test("service tool catalog derives input schema from array action validators", () => {
+test("service tool catalog derives input schema from a composed action schema", () => {
   const app = createApp();
   const actionRuntimeProvider = new ActionRuntimeServiceProvider();
   actionRuntimeProvider.register(app);
@@ -785,32 +756,36 @@ test("service tool catalog derives input schema from array action validators", (
       dependencies: {
         arraySchemaService: "demo.array_schema.service"
       },
-      inputValidator: [
-        {
-          schema: Type.Object(
-            {
-              workspaceSlug: Type.String({ minLength: 1 })
-            },
-            { additionalProperties: false }
-          )
-        },
-        {
-          schema: Type.Object(
-            {
-              name: Type.String({ minLength: 1 }),
-              surname: Type.String({ minLength: 1 })
-            },
-            { additionalProperties: false }
-          )
-        }
-      ],
-      outputValidator: {
-        schema: Type.Object(
-          {
-            id: Type.Integer()
+      input: {
+        schema: createSchema({
+          workspaceSlug: {
+            type: "string",
+            required: true,
+            minLength: 1
+          },
+          name: {
+            type: "string",
+            required: true,
+            minLength: 1
+          },
+          surname: {
+            type: "string",
+            required: true,
+            minLength: 1
+          }
+        })
+      },
+      output: {
+        schema: createSchema({
+          id: {
+            type: "integer",
+            required: true
           },
-          { additionalProperties: true }
-        )
+          payload: {
+            type: "object",
+            required: true
+          }
+        })
       },
       idempotency: "optional",
       audit: {
@@ -843,7 +818,7 @@ test("service tool catalog derives input schema from array action validators", (
   assert.equal(typeof createTool.parameters?.properties?.surname, "object");
 });
 
-test("service tool catalog preserves section-map validators in tool schemas", () => {
+test("service tool catalog derives direct tool schemas from composed action inputs", () => {
   const app = createApp();
   const actionRuntimeProvider = new ActionRuntimeServiceProvider();
   actionRuntimeProvider.register(app);
@@ -857,15 +832,6 @@ test("service tool catalog preserves section-map validators in tool schemas", ()
     })
   );
 
-  const patchValidator = Object.freeze({
-    schema: Type.Object(
-      {
-        name: Type.String({ minLength: 1 })
-      },
-      { additionalProperties: false }
-    )
-  });
-
   app.actions([
     {
       id: "demo.workspace.settings.update",
@@ -880,26 +846,27 @@ test("service tool catalog preserves section-map validators in tool schemas", ()
       dependencies: {
         workspaceSettingsService: "demo.workspace_settings.service"
       },
-      inputValidator: [
-        {
-          schema: Type.Object(
-            {
-              workspaceSlug: Type.String({ minLength: 1 })
-            },
-            { additionalProperties: false }
-          )
-        },
-        {
-          patch: patchValidator
-        }
-      ],
-      outputValidator: {
-        schema: Type.Object(
-          {
-            ok: Type.Boolean()
+      input: {
+        schema: createSchema({
+          workspaceSlug: {
+            type: "string",
+            required: true,
+            minLength: 1
           },
-          { additionalProperties: false }
-        )
+          name: {
+            type: "string",
+            required: true,
+            minLength: 1
+          }
+        })
+      },
+      output: {
+        schema: createSchema({
+          ok: {
+            type: "boolean",
+            required: true
+          }
+        })
       },
       idempotency: "optional",
       audit: {
@@ -939,9 +906,7 @@ test("service tool catalog preserves section-map validators in tool schemas", ()
   assert.ok(updateTool);
   assert.equal(updateTool.parameters?.type, "object");
   assert.equal(Object.hasOwn(updateTool.parameters?.properties || {}, "workspaceSlug"), false);
-  assert.equal(typeof updateTool.parameters?.properties?.patch, "object");
-  assert.equal(updateTool.parameters?.properties?.patch.type, "object");
-  assert.equal(typeof updateTool.parameters?.properties?.patch.properties?.name, "object");
+  assert.equal(typeof updateTool.parameters?.properties?.name, "object");
 });
 
 test("service tool catalog hides workspaceSlug parameter when workspace context is already resolved", () => {
@@ -972,23 +937,33 @@ test("service tool catalog hides workspaceSlug parameter when workspace context
       dependencies: {
         workspaceScopeService: "demo.workspace_scope.service"
       },
-      inputValidator: {
-        schema: Type.Object(
-          {
-            workspaceSlug: Type.String({ minLength: 1 }),
-            name: Type.String({ minLength: 1 })
+      input: {
+        schema: createSchema({
+          workspaceSlug: {
+            type: "string",
+            required: true,
+            minLength: 1
           },
-          { additionalProperties: false }
-        )
-      },
-      outputValidator: {
-        schema: Type.Object(
-          {
-            workspaceSlug: Type.String({ minLength: 1 }),
-            name: Type.String({ minLength: 1 })
+          name: {
+            type: "string",
+            required: true,
+            minLength: 1
+          }
+        })
+      },
+      output: {
+        schema: createSchema({
+          workspaceSlug: {
+            type: "string",
+            required: true,
+            minLength: 1
           },
-          { additionalProperties: false }
-        )
+          name: {
+            type: "string",
+            required: true,
+            minLength: 1
+          }
+        })
       },
       idempotency: "optional",
       audit: {
@@ -1056,23 +1031,33 @@ test("service tool catalog injects workspaceSlug from requestMeta request params
       dependencies: {
         workspaceInjectionService: "demo.workspace_injection.service"
       },
-      inputValidator: {
-        schema: Type.Object(
-          {
-            workspaceSlug: Type.String({ minLength: 1 }),
-            name: Type.String({ minLength: 1 })
+      input: {
+        schema: createSchema({
+          workspaceSlug: {
+            type: "string",
+            required: true,
+            minLength: 1
           },
-          { additionalProperties: false }
-        )
-      },
-      outputValidator: {
-        schema: Type.Object(
-          {
-            workspaceSlug: Type.String({ minLength: 1 }),
-            name: Type.String({ minLength: 1 })
+          name: {
+            type: "string",
+            required: true,
+            minLength: 1
+          }
+        })
+      },
+      output: {
+        schema: createSchema({
+          workspaceSlug: {
+            type: "string",
+            required: true,
+            minLength: 1
           },
-          { additionalProperties: false }
-        )
+          name: {
+            type: "string",
+            required: true,
+            minLength: 1
+          }
+        })
       },
       idempotency: "optional",
       audit: {
@@ -1158,33 +1143,29 @@ test("service tool catalog executes action-backed tools with object payloads", a
       dependencies: {
         customersService: "demo.customers.service"
       },
-      inputValidator: {
-        schema: {
-          type: "object",
-          properties: {
-            recordId: {
-              type: "integer",
-              minimum: 1
-            },
-            name: {
-              type: "string"
-            }
+      input: {
+        schema: createSchema({
+          recordId: {
+            type: "integer",
+            required: true,
+            min: 1
           },
-          required: ["recordId"],
-          additionalProperties: false
-        }
+          name: {
+            type: "string"
+          }
+        })
       },
-      outputValidator: {
-        schema: {
-          type: "object",
-          properties: {
-            id: {
-              type: "integer"
-            }
+      output: {
+        schema: createSchema({
+          id: {
+            type: "integer",
+            required: true
           },
-          required: ["id"],
-          additionalProperties: true
-        }
+          payload: {
+            type: "object",
+            required: true
+          }
+        })
       },
       idempotency: "optional",
       audit: {
@@ -1250,11 +1231,11 @@ test("service tool catalog hides automation actions from other surfaces", () =>
       permission: {
         require: "authenticated"
       },
-      inputValidator: {
-        schema: Type.Object({}, { additionalProperties: false })
+      input: {
+        schema: createSchema({})
       },
-      outputValidator: {
-        schema: Type.Array(Type.Object({}, { additionalProperties: true }))
+      output: {
+        schema: createListOutputSchema()
       },
       idempotency: "none",
       audit: {
@@ -1275,11 +1256,11 @@ test("service tool catalog hides automation actions from other surfaces", () =>
       permission: {
         require: "authenticated"
       },
-      inputValidator: {
-        schema: Type.Object({}, { additionalProperties: false })
+      input: {
+        schema: createSchema({})
       },
-      outputValidator: {
-        schema: Type.Array(Type.Object({}, { additionalProperties: true }))
+      output: {
+        schema: createListOutputSchema()
       },
       idempotency: "none",
       audit: {