@jskit-ai/assistant-core 0.1.1

package/test/assistantPaths.test.js

@@ -0,0 +1,51 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import {
+  buildAssistantApiPath,
+  buildAssistantSettingsApiPath,
+  resolveAssistantApiBasePath,
+  resolveAssistantSettingsApiPath
+} from "../src/shared/assistantPaths.js";
+
+test("assistant path helpers derive workspace and non-workspace API bases from surface workspace requirements", () => {
+  assert.equal(resolveAssistantApiBasePath({ requiresWorkspace: false }), "/api/assistant");
+  assert.equal(resolveAssistantApiBasePath({ requiresWorkspace: true }), "/api/w/:workspaceSlug/assistant");
+
+  assert.equal(resolveAssistantSettingsApiPath({ requiresWorkspace: false }), "/api/assistant/settings");
+  assert.equal(resolveAssistantSettingsApiPath({ requiresWorkspace: true }), "/api/w/:workspaceSlug/assistant/settings");
+});
+
+test("assistant path builders materialize workspace-aware and public API paths", () => {
+  assert.equal(
+    buildAssistantApiPath({
+      requiresWorkspace: false,
+      suffix: "/conversations"
+    }),
+    "/api/assistant/conversations"
+  );
+
+  assert.equal(
+    buildAssistantApiPath({
+      requiresWorkspace: true,
+      workspaceSlug: "acme",
+      suffix: "/conversations"
+    }),
+    "/api/w/acme/assistant/conversations"
+  );
+
+  assert.equal(
+    buildAssistantSettingsApiPath({
+      requiresWorkspace: false,
+      suffix: "/"
+    }),
+    "/api/assistant/settings"
+  );
+
+  assert.equal(
+    buildAssistantSettingsApiPath({
+      requiresWorkspace: true,
+      workspaceSlug: "acme"
+    }),
+    "/api/w/acme/assistant/settings"
+  );
+});

package/test/assistantResource.test.js

@@ -0,0 +1,49 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { Check } from "typebox/value";
+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 messagesPayload = {
+    conversation: {
+      id: 1,
+      workspaceId: 10,
+      title: "Conversation",
+      createdByUserId: 7,
+      status: "active",
+      provider: "openai",
+      model: "gpt-4.1",
+      surfaceId: "admin",
+      startedAt: "2026-03-16T10:00:00.000Z",
+      endedAt: null,
+      messageCount: 2,
+      metadata: {},
+      createdAt: "2026-03-16T10:00:00.000Z",
+      updatedAt: "2026-03-16T10:01:00.000Z"
+    },
+    entries: [],
+    page: 1,
+    pageSize: 200,
+    total: 0,
+    totalPages: 1
+  };
+
+  assert.equal(Check(conversationsListSchema, conversationsPayload), true);
+  assert.equal(Check(conversationMessagesSchema, messagesPayload), true);
+});
+
+test("assistant conversation message params accept numeric path strings and normalize to integer", () => {
+  const paramsValidator = assistantResource.operations.conversationMessagesList.paramsValidator;
+  assert.equal(Check(paramsValidator.schema, { conversationId: "2" }), true);
+  assert.deepEqual(paramsValidator.normalize({ conversationId: "2" }), {
+    conversationId: 2
+  });
+});

package/test/assistantSettingsResource.test.js

@@ -0,0 +1,32 @@
+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 { 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
+  );
+});
+
+test("assistant settings patch normalizer preserves omitted fields", () => {
+  const patch = validateOperationSection({
+    operation: assistantConfigResource.operations.patch,
+    section: "bodyValidator",
+    value: {}
+  });
+
+  assert.equal(patch.ok, true);
+  assert.deepEqual(patch.value, {});
+});

package/test/queryKeys.test.js

@@ -0,0 +1,44 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import {
+  ASSISTANT_QUERY_KEY_PREFIX,
+  assistantRootQueryKey,
+  assistantScopeQueryKey,
+  assistantSettingsQueryKey,
+  assistantConversationsListQueryKey,
+  assistantConversationMessagesQueryKey
+} from "../src/shared/queryKeys.js";
+
+test("assistant query keys normalize scope and paging", () => {
+  assert.deepEqual(ASSISTANT_QUERY_KEY_PREFIX, ["assistant"]);
+  assert.deepEqual(assistantRootQueryKey(), ["assistant"]);
+
+  assert.deepEqual(assistantScopeQueryKey({ targetSurfaceId: "app" }), ["assistant", "app:global"]);
+  assert.deepEqual(assistantScopeQueryKey({ targetSurfaceId: "admin", workspaceSlug: "acme" }), ["assistant", "admin:slug:acme"]);
+  assert.deepEqual(assistantScopeQueryKey({ targetSurfaceId: "admin", workspaceId: "9" }), ["assistant", "admin:workspace:9"]);
+  assert.deepEqual(assistantSettingsQueryKey({ targetSurfaceId: "app" }), ["assistant", "app:global", "settings"]);
+
+  assert.deepEqual(assistantConversationsListQueryKey({ targetSurfaceId: "admin", workspaceSlug: "acme" }), [
+    "assistant",
+    "admin:slug:acme",
+    "conversations",
+    "list",
+    20,
+    "all"
+  ]);
+
+  assert.deepEqual(
+    assistantConversationsListQueryKey({ targetSurfaceId: "admin", workspaceId: 9 }, { limit: 10, status: "ACTIVE" }),
+    ["assistant", "admin:workspace:9", "conversations", "list", 10, "active"]
+  );
+
+  assert.deepEqual(assistantConversationMessagesQueryKey({ targetSurfaceId: "admin", workspaceSlug: "acme" }, "22"), [
+    "assistant",
+    "admin: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");
+});