@jskit-ai/assistant 0.1.4

package/test/descriptorSurfaceOption.test.js

@@ -0,0 +1,35 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import descriptor from "../package.descriptor.mjs";
+
+function findFileMutation(id) {
+  const mutations = Array.isArray(descriptor?.mutations?.files) ? descriptor.mutations.files : [];
+  return mutations.find((entry) => String(entry?.id || "") === id) || null;
+}
+
+function findTextMutation(id) {
+  const mutations = Array.isArray(descriptor?.mutations?.text) ? descriptor.mutations.text : [];
+  return mutations.find((entry) => String(entry?.id || "") === id) || null;
+}
+
+test("assistant descriptor exposes configurable workspace surface option", () => {
+  const option = descriptor?.options?.surfaces;
+  assert.equal(option?.required, true);
+  assert.equal(option?.inputType, "text");
+  assert.equal(option?.defaultValue, "admin");
+});
+
+test("assistant descriptor routes workspace page + placements through surface option", () => {
+  const workspacePage = findFileMutation("assistant-page-admin-workspace-assistant-index");
+  const menuPlacement = findTextMutation("assistant-placement-menu");
+  const workspaceSettingsPlacement = findTextMutation("assistant-workspace-settings-form-placement");
+  const consoleSettingsPlacement = findTextMutation("assistant-console-settings-form-placement");
+
+  assert.equal(workspacePage?.toSurface, "${option:surfaces|lower}");
+  assert.match(String(menuPlacement?.value || ""), /"\$\{option:surfaces\|lower\}"/);
+  assert.match(String(menuPlacement?.value || ""), /\.split\(","\)/);
+  assert.match(String(menuPlacement?.value || ""), /surfaces: assistantWorkspaceSurfaceIds\.length > 0 \? assistantWorkspaceSurfaceIds : \["\*"\]/);
+  assert.doesNotMatch(String(menuPlacement?.value || ""), /surface:\s*"/);
+  assert.match(String(workspaceSettingsPlacement?.value || ""), /surfaces: \["\*"\]/);
+  assert.match(String(consoleSettingsPlacement?.value || ""), /surfaces: \["\*"\]/);
+});

package/test/queryKeys.test.js

@@ -0,0 +1,41 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import {
+  ASSISTANT_QUERY_KEY_PREFIX,
+  assistantRootQueryKey,
+  assistantWorkspaceScopeQueryKey,
+  assistantConversationsListQueryKey,
+  assistantConversationMessagesQueryKey
+} from "../src/shared/queryKeys.js";
+
+test("assistant query keys normalize workspace scope and paging", () => {
+  assert.deepEqual(ASSISTANT_QUERY_KEY_PREFIX, ["assistant"]);
+  assert.deepEqual(assistantRootQueryKey(), ["assistant"]);
+
+  assert.deepEqual(assistantWorkspaceScopeQueryKey({ workspaceSlug: "acme" }), ["assistant", "slug:acme"]);
+  assert.deepEqual(assistantWorkspaceScopeQueryKey({ workspaceId: "9" }), ["assistant", "id:9"]);
+
+  assert.deepEqual(assistantConversationsListQueryKey({ workspaceSlug: "acme" }), [
+    "assistant",
+    "slug:acme",
+    "conversations",
+    "list",
+    20,
+    "all"
+  ]);
+
+  assert.deepEqual(
+    assistantConversationsListQueryKey({ workspaceId: 9 }, { limit: 10, status: "ACTIVE" }),
+    ["assistant", "id:9", "conversations", "list", 10, "active"]
+  );
+
+  assert.deepEqual(assistantConversationMessagesQueryKey({ workspaceSlug: "acme" }, "22"), [
+    "assistant",
+    "slug:acme",
+    "conversations",
+    "22",
+    "messages",
+    1,
+    200
+  ]);
+});

package/test/resolveWorkspaceSlug.test.js

@@ -0,0 +1,83 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { resolveWorkspaceSlug } from "../src/server/lib/resolveWorkspaceSlug.js";
+
+test("resolveWorkspaceSlug follows fallback priority", () => {
+  const slug = resolveWorkspaceSlug(
+    {
+      workspace: {
+        slug: "workspace-primary"
+      },
+      requestMeta: {
+        resolvedWorkspaceContext: {
+          workspace: {
+            slug: "workspace-resolved"
+          }
+        },
+        request: {
+          input: {
+            params: {
+              workspaceSlug: "workspace-request"
+            }
+          }
+        }
+      }
+    },
+    {
+      workspaceSlug: "workspace-input"
+    }
+  );
+
+  assert.equal(slug, "workspace-primary");
+});
+
+test("resolveWorkspaceSlug resolves from requestMeta resolved workspace", () => {
+  const slug = resolveWorkspaceSlug({
+    requestMeta: {
+      resolvedWorkspaceContext: {
+        workspace: {
+          slug: "workspace-resolved"
+        }
+      }
+    }
+  });
+
+  assert.equal(slug, "workspace-resolved");
+});
+
+test("resolveWorkspaceSlug resolves from action input before request params", () => {
+  const slug = resolveWorkspaceSlug(
+    {
+      requestMeta: {
+        request: {
+          input: {
+            params: {
+              workspaceSlug: "workspace-request"
+            }
+          }
+        }
+      }
+    },
+    {
+      workspaceSlug: "workspace-input"
+    }
+  );
+
+  assert.equal(slug, "workspace-input");
+});
+
+test("resolveWorkspaceSlug resolves from request params when needed", () => {
+  const slug = resolveWorkspaceSlug({
+    requestMeta: {
+      request: {
+        input: {
+          params: {
+            workspaceSlug: "workspace-request"
+          }
+        }
+      }
+    }
+  });
+
+  assert.equal(slug, "workspace-request");
+});

package/test/routeInputContracts.test.js

@@ -0,0 +1,287 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { KERNEL_TOKENS } from "@jskit-ai/kernel/shared/support/tokens";
+import { registerRoutes } from "../src/server/registerRoutes.js";
+
+function createReplyDouble() {
+  return {
+    statusCode: 200,
+    payload: null,
+    code(statusCode) {
+      this.statusCode = statusCode;
+      return this;
+    },
+    send(payload) {
+      this.payload = payload;
+      return this;
+    }
+  };
+}
+
+function findRoute(routes, method, path) {
+  return routes.find((route) => route.method === method && route.path === path) || null;
+}
+
+test("assistant routes build list inputs with explicit query object", async () => {
+  const registeredRoutes = [];
+  const router = {
+    register(method, path, route, handler) {
+      registeredRoutes.push({
+        method,
+        path,
+        route,
+        handler
+      });
+    }
+  };
+  const app = {
+    make(token) {
+      if (token !== KERNEL_TOKENS.HttpRouter) {
+        throw new Error(`Unexpected token: ${String(token)}`);
+      }
+      return router;
+    }
+  };
+
+  registerRoutes(app);
+
+  const conversationsRoute = findRoute(registeredRoutes, "GET", "/api/w/:workspaceSlug/assistant/conversations");
+  const messagesRoute = findRoute(
+    registeredRoutes,
+    "GET",
+    "/api/w/:workspaceSlug/assistant/conversations/:conversationId/messages"
+  );
+  const consoleSettingsReadRoute = findRoute(registeredRoutes, "GET", "/api/console/settings/assistant");
+  const consoleSettingsPatchRoute = findRoute(registeredRoutes, "PATCH", "/api/console/settings/assistant");
+  const workspaceSettingsReadRoute = findRoute(
+    registeredRoutes,
+    "GET",
+    "/api/w/:workspaceSlug/workspace/settings/assistant"
+  );
+  const workspaceSettingsPatchRoute = findRoute(
+    registeredRoutes,
+    "PATCH",
+    "/api/w/:workspaceSlug/workspace/settings/assistant"
+  );
+  assert.ok(conversationsRoute);
+  assert.ok(messagesRoute);
+  assert.ok(consoleSettingsReadRoute);
+  assert.ok(consoleSettingsPatchRoute);
+  assert.ok(workspaceSettingsReadRoute);
+  assert.ok(workspaceSettingsPatchRoute);
+
+  const calls = [];
+  const executeAction = async (payload) => {
+    calls.push(payload);
+    return {};
+  };
+
+  await conversationsRoute.handler(
+    {
+      input: {
+        params: { workspaceSlug: "acme" },
+        query: { cursor: 30, limit: 50, status: "active" }
+      },
+      executeAction
+    },
+    createReplyDouble()
+  );
+  await messagesRoute.handler(
+    {
+      input: {
+        params: { workspaceSlug: "acme", conversationId: 10 },
+        query: { page: 3, pageSize: 100 }
+      },
+      executeAction
+    },
+    createReplyDouble()
+  );
+  await consoleSettingsReadRoute.handler(
+    {
+      input: {},
+      executeAction
+    },
+    createReplyDouble()
+  );
+  await consoleSettingsPatchRoute.handler(
+    {
+      input: {
+        body: { workspaceSurfacePrompt: "Console prompt" }
+      },
+      executeAction
+    },
+    createReplyDouble()
+  );
+  await workspaceSettingsReadRoute.handler(
+    {
+      input: {
+        params: { workspaceSlug: "acme" }
+      },
+      executeAction
+    },
+    createReplyDouble()
+  );
+  await workspaceSettingsPatchRoute.handler(
+    {
+      input: {
+        params: { workspaceSlug: "acme" },
+        body: { appSurfacePrompt: "Workspace prompt" }
+      },
+      executeAction
+    },
+    createReplyDouble()
+  );
+
+  assert.deepEqual(calls[0].input, {
+    workspaceSlug: "acme",
+    query: { cursor: 30, limit: 50, status: "active" }
+  });
+  assert.deepEqual(calls[0].context, {
+    surface: "app"
+  });
+  assert.deepEqual(calls[1].input, {
+    workspaceSlug: "acme",
+    conversationId: 10,
+    query: { page: 3, pageSize: 100 }
+  });
+  assert.deepEqual(calls[1].context, {
+    surface: "app"
+  });
+  assert.deepEqual(calls[2], {
+    actionId: "assistant.console.settings.read"
+  });
+  assert.deepEqual(calls[3], {
+    actionId: "assistant.console.settings.update",
+    input: {
+      payload: {
+        workspaceSurfacePrompt: "Console prompt"
+      }
+    }
+  });
+  assert.deepEqual(calls[4], {
+    actionId: "assistant.workspace.settings.read",
+    context: {
+      surface: "app"
+    },
+    input: {
+      workspaceSlug: "acme"
+    }
+  });
+  assert.deepEqual(calls[5], {
+    actionId: "assistant.workspace.settings.update",
+    context: {
+      surface: "app"
+    },
+    input: {
+      workspaceSlug: "acme",
+      patch: {
+        appSurfacePrompt: "Workspace prompt"
+      }
+    }
+  });
+});
+
+test("assistant workspace routes use workspace default surface and honor x-jskit-surface header", async () => {
+  const registeredRoutes = [];
+  const router = {
+    register(method, path, route, handler) {
+      registeredRoutes.push({
+        method,
+        path,
+        route,
+        handler
+      });
+    }
+  };
+  const app = {
+    has(token) {
+      return token === "appConfig";
+    },
+    make(token) {
+      if (token === KERNEL_TOKENS.HttpRouter) {
+        return router;
+      }
+      if (token === "appConfig") {
+        return {
+          surfaceDefaultId: "admin",
+          surfaceDefinitions: {
+            app: {
+              id: "app",
+              enabled: true,
+              requiresWorkspace: true
+            },
+            admin: {
+              id: "admin",
+              enabled: true,
+              requiresWorkspace: true
+            },
+            console: {
+              id: "console",
+              enabled: true,
+              requiresWorkspace: false
+            }
+          }
+        };
+      }
+      throw new Error(`Unexpected token: ${String(token)}`);
+    }
+  };
+
+  registerRoutes(app);
+
+  const expectedWorkspaceRoutes = [
+    ["GET", "/api/w/:workspaceSlug/workspace/settings/assistant"],
+    ["PATCH", "/api/w/:workspaceSlug/workspace/settings/assistant"],
+    ["POST", "/api/w/:workspaceSlug/assistant/chat/stream"],
+    ["GET", "/api/w/:workspaceSlug/assistant/conversations"],
+    ["GET", "/api/w/:workspaceSlug/assistant/conversations/:conversationId/messages"]
+  ];
+
+  for (const [method, path] of expectedWorkspaceRoutes) {
+    const route = findRoute(registeredRoutes, method, path);
+    assert.ok(route);
+    assert.equal(route.route.surface, "admin");
+  }
+
+  const conversationsRoute = findRoute(registeredRoutes, "GET", "/api/w/:workspaceSlug/assistant/conversations");
+  const actionCalls = [];
+  const executeAction = async (payload) => {
+    actionCalls.push(payload);
+    return {};
+  };
+
+  await conversationsRoute.handler(
+    {
+      headers: {
+        "x-jskit-surface": "app"
+      },
+      input: {
+        params: { workspaceSlug: "acme" },
+        query: {}
+      },
+      executeAction
+    },
+    createReplyDouble()
+  );
+  await conversationsRoute.handler(
+    {
+      headers: {
+        "x-jskit-surface": "missing"
+      },
+      input: {
+        params: { workspaceSlug: "acme" },
+        query: {}
+      },
+      executeAction
+    },
+    createReplyDouble()
+  );
+
+  assert.equal(actionCalls.length, 2);
+  assert.deepEqual(actionCalls[0].context, {
+    surface: "app"
+  });
+  assert.deepEqual(actionCalls[1].context, {
+    surface: "admin"
+  });
+});