@jskit-ai/assistant-runtime 0.1.1

package/src/client/index.js

@@ -0,0 +1,4 @@
+export { default as AssistantSurfaceClientElement } from "./components/AssistantSurfaceClientElement.vue";
+export { default as AssistantSettingsClientElement } from "./components/AssistantSettingsClientElement.vue";
+export { AssistantClientProvider } from "./providers/AssistantClientProvider.js";
+export { useAssistantRuntime } from "./composables/useAssistantRuntime.js";

package/src/client/providers/AssistantClientProvider.js

@@ -0,0 +1,16 @@
+import AssistantSettingsClientElement from "../components/AssistantSettingsClientElement.vue";
+
+class AssistantClientProvider {
+  static id = "assistant.web.client";
+  static dependsOn = ["users.web.client"];
+
+  register(app) {
+    if (!app || typeof app.singleton !== "function") {
+      throw new Error("AssistantClientProvider requires application singleton().");
+    }
+
+    app.singleton("assistant.web.settings.element", () => AssistantSettingsClientElement);
+  }
+}
+
+export { AssistantClientProvider };

package/src/server/AssistantProvider.js

@@ -0,0 +1,152 @@
+import { resolveAppConfig } from "@jskit-ai/kernel/server/support";
+import { withActionDefaults } from "@jskit-ai/kernel/shared/actions";
+import { normalizeObject, normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
+import { createAiClient } from "@jskit-ai/assistant-core/server";
+import { assistantActions } from "./actions.js";
+import { registerRoutes } from "./registerRoutes.js";
+import { createRepository as createAssistantConfigRepository } from "./repositories/assistantConfigRepository.js";
+import { createRepository as createConversationsRepository } from "./repositories/conversationsRepository.js";
+import { createRepository as createMessagesRepository } from "./repositories/messagesRepository.js";
+import { createService as createAssistantConfigService } from "./services/assistantConfigService.js";
+import { createChatService } from "./services/chatService.js";
+import { createTranscriptService } from "./services/transcriptService.js";
+import { resolveAssistantAiConfig } from "./support/assistantServerConfig.js";
+import { createSurfaceAwareToolCatalog } from "./support/createSurfaceAwareToolCatalog.js";
+
+function resolveGlobalAssistantConfig(scope) {
+  const appConfig = resolveAppConfig(scope);
+  const env = scope.has("jskit.env") ? normalizeObject(scope.make("jskit.env")) : {};
+
+  return Object.freeze({
+    appConfig,
+    env
+  });
+}
+
+function createAssistantAiClientFactory(config = {}) {
+  const resolveCurrentAppConfig =
+    typeof config.resolveAppConfig === "function"
+      ? () => normalizeObject(config.resolveAppConfig())
+      : () => normalizeObject(config.appConfig);
+  const env = normalizeObject(config.env);
+  const cache = new Map();
+
+  return Object.freeze({
+    resolveClient(targetSurfaceId = "") {
+      const normalizedTargetSurfaceId = normalizeText(targetSurfaceId).toLowerCase();
+      if (!normalizedTargetSurfaceId) {
+        throw new Error("assistant.ai.client.factory.resolveClient requires targetSurfaceId.");
+      }
+
+      if (cache.has(normalizedTargetSurfaceId)) {
+        return cache.get(normalizedTargetSurfaceId);
+      }
+
+      const assistantAiConfig = resolveAssistantAiConfig(
+        {
+          appConfig: resolveCurrentAppConfig(),
+          env
+        },
+        normalizedTargetSurfaceId
+      );
+      const client = createAiClient(assistantAiConfig.ai);
+      cache.set(normalizedTargetSurfaceId, client);
+      return client;
+    }
+  });
+}
+
+class AssistantProvider {
+  static id = "assistant.chat.service";
+
+  static dependsOn = ["runtime.actions", "runtime.database", "auth.policy.fastify", "users.core"];
+
+  register(app) {
+    if (
+      !app ||
+      typeof app.singleton !== "function" ||
+      typeof app.service !== "function" ||
+      typeof app.actions !== "function"
+    ) {
+      throw new Error("AssistantProvider requires application singleton()/service()/actions().");
+    }
+
+    const config = resolveGlobalAssistantConfig(app);
+    const resolveCurrentAppConfig = () => resolveAppConfig(app);
+
+    app.singleton("assistant.config.repository", (scope) => {
+      const knex = scope.make("jskit.database.knex");
+      return createAssistantConfigRepository(knex);
+    });
+
+    app.singleton("assistant.conversation.repository", (scope) => {
+      const knex = scope.make("jskit.database.knex");
+      return createConversationsRepository(knex);
+    });
+
+    app.singleton("assistant.message.repository", (scope) => {
+      const knex = scope.make("jskit.database.knex");
+      return createMessagesRepository(knex);
+    });
+
+    app.singleton("assistant.ai.client.factory", () => {
+      return createAssistantAiClientFactory({
+        resolveAppConfig: resolveCurrentAppConfig,
+        env: config.env
+      });
+    });
+
+    app.singleton("assistant.service.tool-catalog", (scope) => {
+      return createSurfaceAwareToolCatalog(scope, {
+        resolveAppConfig: resolveCurrentAppConfig
+      });
+    });
+
+    app.service(
+      "assistant.config.service",
+      (scope) =>
+        createAssistantConfigService({
+          assistantConfigRepository: scope.make("assistant.config.repository"),
+          consoleService: scope.has("consoleService") ? scope.make("consoleService") : null,
+          resolveAppConfig: resolveCurrentAppConfig
+        })
+    );
+
+    app.service(
+      "assistant.transcript.service",
+      (scope) =>
+        createTranscriptService({
+          conversationsRepository: scope.make("assistant.conversation.repository"),
+          messagesRepository: scope.make("assistant.message.repository")
+        })
+    );
+
+    app.service(
+      "assistant.chat.service",
+      (scope) =>
+        createChatService({
+          aiClientFactory: scope.make("assistant.ai.client.factory"),
+          transcriptService: scope.make("assistant.transcript.service"),
+          serviceToolCatalog: scope.make("assistant.service.tool-catalog"),
+          assistantConfigService: scope.make("assistant.config.service"),
+          resolveAppConfig: resolveCurrentAppConfig
+        })
+    );
+
+    app.actions(
+      withActionDefaults(assistantActions, {
+        domain: "assistant",
+        dependencies: {
+          chatService: "assistant.chat.service",
+          assistantConfigService: "assistant.config.service"
+        }
+      })
+    );
+  }
+
+  boot(app) {
+    registerRoutes(app);
+  }
+}
+
+export { AssistantProvider };

package/src/server/actionIds.js

@@ -0,0 +1,9 @@
+const actionIds = Object.freeze({
+  chatStream: "assistant.chat.stream",
+  conversationsList: "assistant.conversations.list",
+  conversationMessagesList: "assistant.conversation.messages.list",
+  settingsRead: "assistant.settings.read",
+  settingsUpdate: "assistant.settings.update"
+});
+
+export { actionIds };

package/src/server/actions.js

@@ -0,0 +1,151 @@
+import {
+  assistantConfigResource,
+  assistantResource
+} from "@jskit-ai/assistant-core/shared";
+import { actionIds } from "./actionIds.js";
+import { assistantTargetSurfaceInputValidator } from "./inputValidators.js";
+
+const runtimeQueryInputValidator = [
+  assistantTargetSurfaceInputValidator,
+  { query: assistantResource.operations.conversationsList.queryValidator }
+];
+
+const runtimeMessagesInputValidator = [
+  assistantTargetSurfaceInputValidator,
+  assistantResource.operations.conversationMessagesList.paramsValidator,
+  {
+    query: assistantResource.operations.conversationMessagesList.queryValidator
+  }
+];
+
+const runtimeChatInputValidator = [
+  assistantTargetSurfaceInputValidator,
+  assistantResource.operations.chatStream.bodyValidator
+];
+
+const settingsReadInputValidator = assistantTargetSurfaceInputValidator;
+
+const settingsUpdateInputValidator = [
+  assistantTargetSurfaceInputValidator,
+  {
+    patch: assistantConfigResource.operations.patch.bodyValidator
+  }
+];
+
+const assistantActions = Object.freeze([
+  {
+    id: actionIds.chatStream,
+    version: 1,
+    kind: "stream",
+    channels: ["api", "internal"],
+    surfacesFrom: "enabled",
+    permission: {
+      require: "authenticated"
+    },
+    inputValidator: runtimeChatInputValidator,
+    idempotency: "optional",
+    audit: {
+      actionName: actionIds.chatStream
+    },
+    observability: {},
+    async execute(input, context, deps) {
+      return deps.chatService.streamChat(input, {
+        context,
+        streamWriter: deps.streamWriter,
+        abortSignal: deps.abortSignal
+      });
+    }
+  },
+  {
+    id: actionIds.conversationsList,
+    version: 1,
+    kind: "query",
+    channels: ["api", "internal"],
+    surfacesFrom: "enabled",
+    permission: {
+      require: "authenticated"
+    },
+    inputValidator: runtimeQueryInputValidator,
+    outputValidator: assistantResource.operations.conversationsList.outputValidator,
+    idempotency: "none",
+    audit: {
+      actionName: actionIds.conversationsList
+    },
+    observability: {},
+    async execute(input, context, deps) {
+      return deps.chatService.listConversations(input.query, {
+        context,
+        input
+      });
+    }
+  },
+  {
+    id: actionIds.conversationMessagesList,
+    version: 1,
+    kind: "query",
+    channels: ["api", "internal"],
+    surfacesFrom: "enabled",
+    permission: {
+      require: "authenticated"
+    },
+    inputValidator: runtimeMessagesInputValidator,
+    outputValidator: assistantResource.operations.conversationMessagesList.outputValidator,
+    idempotency: "none",
+    audit: {
+      actionName: actionIds.conversationMessagesList
+    },
+    observability: {},
+    async execute(input, context, deps) {
+      return deps.chatService.getConversationMessages(input.conversationId, input.query, {
+        context,
+        input
+      });
+    }
+  },
+  {
+    id: actionIds.settingsRead,
+    version: 1,
+    kind: "query",
+    channels: ["api", "automation", "internal"],
+    surfacesFrom: "enabled",
+    permission: {
+      require: "authenticated"
+    },
+    inputValidator: settingsReadInputValidator,
+    outputValidator: assistantConfigResource.operations.view.outputValidator,
+    idempotency: "none",
+    audit: {
+      actionName: actionIds.settingsRead
+    },
+    observability: {},
+    async execute(input, context, deps) {
+      return deps.assistantConfigService.getSettings(input, {
+        context
+      });
+    }
+  },
+  {
+    id: actionIds.settingsUpdate,
+    version: 1,
+    kind: "command",
+    channels: ["api", "automation", "internal"],
+    surfacesFrom: "enabled",
+    permission: {
+      require: "authenticated"
+    },
+    inputValidator: settingsUpdateInputValidator,
+    outputValidator: assistantConfigResource.operations.patch.outputValidator,
+    idempotency: "optional",
+    audit: {
+      actionName: actionIds.settingsUpdate
+    },
+    observability: {},
+    async execute(input, context, deps) {
+      return deps.assistantConfigService.updateSettings(input, input.patch, {
+        context
+      });
+    }
+  }
+]);
+
+export { assistantActions };

package/src/server/inputValidators.js

@@ -0,0 +1,41 @@
+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
+};