@jskit-ai/assistant 0.1.4

package/src/client/index.js

@@ -0,0 +1,12 @@
+export { default as AssistantClientElement } from "./components/AssistantClientElement.vue";
+export { default as AssistantWorkspaceClientElement } from "./components/AssistantWorkspaceClientElement.vue";
+export { default as AssistantConsoleSettingsClientElement } from "./components/AssistantConsoleSettingsClientElement.vue";
+export { default as AssistantWorkspaceSettingsClientElement } from "./components/AssistantWorkspaceSettingsClientElement.vue";
+export { useAssistantWorkspaceRuntime } from "./composables/useAssistantWorkspaceRuntime.js";
+export { assistantHttpClient } from "./lib/assistantHttpClient.js";
+export { createAssistantWorkspaceApi, buildStreamEventError } from "./lib/assistantApi.js";
+export {
+  AssistantWebClientProvider,
+  ASSISTANT_CONSOLE_SETTINGS_ELEMENT_TOKEN,
+  ASSISTANT_WORKSPACE_SETTINGS_ELEMENT_TOKEN
+} from "./providers/AssistantWebClientProvider.js";

package/src/client/lib/assistantApi.js

@@ -0,0 +1,137 @@
+import {
+  ASSISTANT_STREAM_EVENT_TYPES,
+  buildAssistantWorkspaceApiPath,
+  normalizeAssistantStreamEventType
+} from "../../shared/index.js";
+import { appendQueryString } from "@jskit-ai/kernel/shared/support";
+
+function buildStreamEventError(event) {
+  const message = String(event?.message || "Assistant request failed.");
+  const error = new Error(message);
+  error.code = String(event?.code || "assistant_stream_error");
+  error.status = Number(event?.status || 500);
+  error.event = event && typeof event === "object" ? { ...event } : null;
+  return error;
+}
+
+function appendQueryParam(params, key, value) {
+  if (value == null) {
+    return;
+  }
+
+  const normalized = String(value).trim();
+  if (!normalized) {
+    return;
+  }
+
+  params.set(key, normalized);
+}
+
+function resolveWorkspaceBasePath(workspaceSlug = "") {
+  const path = buildAssistantWorkspaceApiPath(workspaceSlug, "/");
+  if (!path) {
+    throw new Error("Assistant workspace slug is required.");
+  }
+
+  return path;
+}
+
+function normalizeSurfaceHeaderValue(value) {
+  return String(value || "").trim().toLowerCase();
+}
+
+function resolveAssistantRequestHeaders(resolveSurfaceId) {
+  if (typeof resolveSurfaceId !== "function") {
+    return null;
+  }
+
+  const surfaceId = normalizeSurfaceHeaderValue(resolveSurfaceId());
+  if (!surfaceId) {
+    return null;
+  }
+
+  return {
+    "x-jskit-surface": surfaceId
+  };
+}
+
+function createAssistantWorkspaceApi({ request, requestStream, resolveSurfaceId = null }) {
+  if (typeof request !== "function" || typeof requestStream !== "function") {
+    throw new Error("createAssistantWorkspaceApi requires request() and requestStream().");
+  }
+
+  return Object.freeze({
+    async streamChat(workspaceSlug, payload, { signal, onEvent, onMalformedLine, rejectOnErrorEvent = true } = {}) {
+      const basePath = resolveWorkspaceBasePath(workspaceSlug);
+      let streamEventError = null;
+      const requestHeaders = resolveAssistantRequestHeaders(resolveSurfaceId);
+
+      const streamHandlers = {
+        onEvent(event) {
+          const eventType = normalizeAssistantStreamEventType(event?.type, "");
+          if (rejectOnErrorEvent && eventType === ASSISTANT_STREAM_EVENT_TYPES.ERROR && !streamEventError) {
+            streamEventError = buildStreamEventError(event);
+          }
+
+          if (typeof onEvent === "function") {
+            onEvent(event);
+          }
+        }
+      };
+
+      if (typeof onMalformedLine === "function") {
+        streamHandlers.onMalformedLine = (line, parseError) => {
+          onMalformedLine(line, parseError);
+        };
+      }
+
+      await requestStream(
+        `${basePath}/chat/stream`,
+        {
+          method: "POST",
+          ...(requestHeaders ? { headers: requestHeaders } : {}),
+          body: payload,
+          signal
+        },
+        streamHandlers
+      );
+
+      if (streamEventError) {
+        throw streamEventError;
+      }
+    },
+
+    listConversations(workspaceSlug, query = {}) {
+      const basePath = resolveWorkspaceBasePath(workspaceSlug);
+      const params = new URLSearchParams();
+      appendQueryParam(params, "cursor", query.cursor);
+      appendQueryParam(params, "limit", query.limit);
+      appendQueryParam(params, "status", query.status);
+      const requestHeaders = resolveAssistantRequestHeaders(resolveSurfaceId);
+
+      return request(
+        appendQueryString(`${basePath}/conversations`, params.toString()),
+        requestHeaders ? { headers: requestHeaders } : {}
+      );
+    },
+
+    getConversationMessages(workspaceSlug, conversationId, query = {}) {
+      const basePath = resolveWorkspaceBasePath(workspaceSlug);
+      const encodedConversationId = encodeURIComponent(String(conversationId || "").trim());
+      const params = new URLSearchParams();
+      appendQueryParam(params, "page", query.page);
+      appendQueryParam(params, "pageSize", query.pageSize);
+      const requestHeaders = resolveAssistantRequestHeaders(resolveSurfaceId);
+
+      return request(
+        appendQueryString(`${basePath}/conversations/${encodedConversationId}/messages`, params.toString()),
+        requestHeaders ? { headers: requestHeaders } : {}
+      );
+    }
+  });
+}
+
+export {
+  createAssistantWorkspaceApi,
+  buildStreamEventError
+};

package/src/client/lib/assistantHttpClient.js

@@ -0,0 +1,10 @@
+import { createHttpClient } from "@jskit-ai/http-runtime/client";
+
+const assistantHttpClient = createHttpClient({
+  credentials: "include",
+  csrf: {
+    sessionPath: "/api/session"
+  }
+});
+
+export { assistantHttpClient };

package/src/client/lib/markdownRenderer.js

@@ -0,0 +1,31 @@
+import DOMPurify from "dompurify";
+import { marked } from "marked";
+
+marked.setOptions(
+  Object.freeze({
+    gfm: true,
+    breaks: true
+  })
+);
+
+function normalizeMarkdownText(value) {
+  return typeof value === "string" ? value : String(value || "");
+}
+
+function renderMarkdownToSafeHtml(value = "") {
+  const markdownText = normalizeMarkdownText(value);
+  if (!markdownText) {
+    return "";
+  }
+
+  const unsafeHtml = String(marked.parse(markdownText) || "");
+  return String(
+    DOMPurify.sanitize(unsafeHtml, {
+      USE_PROFILES: {
+        html: true
+      }
+    }) || ""
+  );
+}
+
+export { renderMarkdownToSafeHtml };

package/src/client/providers/AssistantWebClientProvider.js

@@ -0,0 +1,25 @@
+import AssistantConsoleSettingsClientElement from "../components/AssistantConsoleSettingsClientElement.vue";
+import AssistantWorkspaceSettingsClientElement from "../components/AssistantWorkspaceSettingsClientElement.vue";
+
+const ASSISTANT_CONSOLE_SETTINGS_ELEMENT_TOKEN = "assistant.web.console-settings.element";
+const ASSISTANT_WORKSPACE_SETTINGS_ELEMENT_TOKEN = "assistant.web.workspace-settings.element";
+
+class AssistantWebClientProvider {
+  static id = "assistant.web.client";
+  static dependsOn = ["users.web.client"];
+
+  register(app) {
+    if (!app || typeof app.singleton !== "function") {
+      throw new Error("AssistantWebClientProvider requires application singleton().");
+    }
+
+    app.singleton(ASSISTANT_CONSOLE_SETTINGS_ELEMENT_TOKEN, () => AssistantConsoleSettingsClientElement);
+    app.singleton(ASSISTANT_WORKSPACE_SETTINGS_ELEMENT_TOKEN, () => AssistantWorkspaceSettingsClientElement);
+  }
+}
+
+export {
+  AssistantWebClientProvider,
+  ASSISTANT_CONSOLE_SETTINGS_ELEMENT_TOKEN,
+  ASSISTANT_WORKSPACE_SETTINGS_ELEMENT_TOKEN
+};

package/src/server/AssistantServiceProvider.js

@@ -0,0 +1,179 @@
+import { KERNEL_TOKENS } from "@jskit-ai/kernel/shared/support/tokens";
+import { withActionDefaults } from "@jskit-ai/kernel/shared/actions";
+import { normalizeObject, normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
+import { createRepository as createConversationsRepository } from "./repositories/conversationsRepository.js";
+import { createRepository as createMessagesRepository } from "./repositories/messagesRepository.js";
+import { createRepository as createAssistantSettingsRepository } from "./repositories/assistantSettingsRepository.js";
+import { createChatService } from "./services/chatService.js";
+import {
+  createService as createAssistantSettingsService,
+  serviceEvents as assistantSettingsServiceEvents
+} from "./services/assistantSettingsService.js";
+import {
+  createTranscriptService,
+  serviceEvents as transcriptServiceEvents
+} from "./services/transcriptService.js";
+import { createAiClient } from "./lib/aiClient.js";
+import { createServiceToolCatalog } from "./lib/serviceToolCatalog.js";
+import { normalizeOptionalHttpUrl } from "./lib/providers/common.js";
+import { assistantActions } from "./actions.js";
+import { registerRoutes } from "./registerRoutes.js";
+import {
+  ASSISTANT_CONVERSATIONS_REPOSITORY_TOKEN,
+  ASSISTANT_MESSAGES_REPOSITORY_TOKEN,
+  ASSISTANT_SETTINGS_REPOSITORY_TOKEN,
+  ASSISTANT_TRANSCRIPT_SERVICE_TOKEN,
+  ASSISTANT_CHAT_SERVICE_TOKEN,
+  ASSISTANT_SETTINGS_SERVICE_TOKEN,
+  ASSISTANT_AI_CLIENT_TOKEN,
+  ASSISTANT_SERVICE_TOOL_CATALOG_TOKEN
+} from "./diTokens.js";
+
+const ASSISTANT_PROVIDER_ID = ASSISTANT_CHAT_SERVICE_TOKEN;
+const DEFAULT_AI_TIMEOUT_MS = 120_000;
+
+function normalizeInteger(value, fallback) {
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed < 1) {
+    return fallback;
+  }
+
+  return parsed;
+}
+
+function normalizeStringArray(value) {
+  const source = Array.isArray(value) ? value : [value];
+  return source.map((entry) => normalizeText(entry)).filter(Boolean);
+}
+
+function resolveAssistantConfig(scope) {
+  const appConfig = scope.has("appConfig") ? normalizeObject(scope.make("appConfig")) : {};
+  const env = scope.has(KERNEL_TOKENS.Env) ? normalizeObject(scope.make(KERNEL_TOKENS.Env)) : {};
+  const assistantConfig = normalizeObject(appConfig.assistant);
+
+  const provider = normalizeText(env.AI_PROVIDER || assistantConfig.provider).toLowerCase() || "openai";
+  const apiKey = normalizeText(env.AI_API_KEY || assistantConfig.apiKey);
+  const baseUrl = normalizeOptionalHttpUrl(env.AI_BASE_URL || assistantConfig.baseUrl, {
+    context: "assistant AI_BASE_URL"
+  });
+  const model = normalizeText(assistantConfig.model);
+  const timeoutMs = normalizeInteger(
+    env.AI_TIMEOUT_MS || assistantConfig.timeoutMs,
+    DEFAULT_AI_TIMEOUT_MS
+  );
+
+  return Object.freeze({
+    ai: Object.freeze({
+      enabled: Boolean(apiKey),
+      provider,
+      apiKey,
+      baseUrl,
+      model,
+      timeoutMs
+    }),
+    timeoutMs,
+    barredActionIds: normalizeStringArray(assistantConfig.barredActionIds),
+    toolSkipActionPrefixes: normalizeStringArray(assistantConfig.toolSkipActionPrefixes)
+  });
+}
+
+class AssistantServiceProvider {
+  static id = ASSISTANT_PROVIDER_ID;
+
+  static dependsOn = ["runtime.actions", "runtime.database", "auth.policy.fastify", "users.core", "runtime.realtime"];
+
+  register(app) {
+    if (
+      !app ||
+      typeof app.singleton !== "function" ||
+      typeof app.service !== "function" ||
+      typeof app.actions !== "function"
+    ) {
+      throw new Error("AssistantServiceProvider requires application singleton()/service()/actions().");
+    }
+
+    const config = resolveAssistantConfig(app);
+
+    app.singleton(ASSISTANT_CONVERSATIONS_REPOSITORY_TOKEN, (scope) => {
+      const knex = scope.make(KERNEL_TOKENS.Knex);
+      return createConversationsRepository(knex);
+    });
+
+    app.singleton(ASSISTANT_MESSAGES_REPOSITORY_TOKEN, (scope) => {
+      const knex = scope.make(KERNEL_TOKENS.Knex);
+      return createMessagesRepository(knex);
+    });
+
+    app.singleton(ASSISTANT_SETTINGS_REPOSITORY_TOKEN, (scope) => {
+      const knex = scope.make(KERNEL_TOKENS.Knex);
+      return createAssistantSettingsRepository(knex);
+    });
+
+    app.singleton(ASSISTANT_AI_CLIENT_TOKEN, () => {
+      return createAiClient(config.ai);
+    });
+
+    app.singleton(ASSISTANT_SERVICE_TOOL_CATALOG_TOKEN, (scope) => {
+      const skipPrefixes = ["assistant.", ...config.toolSkipActionPrefixes];
+
+      return createServiceToolCatalog(scope, {
+        barredActionIds: config.barredActionIds,
+        skipActionPrefixes: skipPrefixes
+      });
+    });
+
+    app.service(
+      ASSISTANT_TRANSCRIPT_SERVICE_TOKEN,
+      (scope) =>
+        createTranscriptService({
+          conversationsRepository: scope.make(ASSISTANT_CONVERSATIONS_REPOSITORY_TOKEN),
+          messagesRepository: scope.make(ASSISTANT_MESSAGES_REPOSITORY_TOKEN)
+        }),
+      {
+        events: transcriptServiceEvents
+      }
+    );
+
+    app.service(
+      ASSISTANT_SETTINGS_SERVICE_TOKEN,
+      (scope) =>
+        createAssistantSettingsService({
+          assistantSettingsRepository: scope.make(ASSISTANT_SETTINGS_REPOSITORY_TOKEN),
+          consoleService: scope.make("consoleService")
+        }),
+      {
+        events: assistantSettingsServiceEvents
+      }
+    );
+
+    app.service(
+      ASSISTANT_CHAT_SERVICE_TOKEN,
+      (scope) =>
+        createChatService({
+          aiClient: scope.make(ASSISTANT_AI_CLIENT_TOKEN),
+          transcriptService: scope.make(ASSISTANT_TRANSCRIPT_SERVICE_TOKEN),
+          serviceToolCatalog: scope.make(ASSISTANT_SERVICE_TOOL_CATALOG_TOKEN),
+          assistantSettingsService: scope.make(ASSISTANT_SETTINGS_SERVICE_TOKEN)
+        }),
+      {
+        events: {}
+      }
+    );
+
+    app.actions(
+      withActionDefaults(assistantActions, {
+        domain: "assistant",
+        dependencies: {
+          chatService: ASSISTANT_CHAT_SERVICE_TOKEN,
+          assistantSettingsService: ASSISTANT_SETTINGS_SERVICE_TOKEN
+        }
+      })
+    );
+  }
+
+  boot(app) {
+    registerRoutes(app);
+  }
+}
+
+export { AssistantServiceProvider };

package/src/server/actionIds.js

@@ -0,0 +1,11 @@
+const actionIds = Object.freeze({
+  chatStream: "assistant.chat.stream",
+  conversationsList: "assistant.conversations.list",
+  conversationMessagesList: "assistant.conversation.messages.list",
+  consoleSettingsRead: "assistant.console.settings.read",
+  consoleSettingsUpdate: "assistant.console.settings.update",
+  workspaceSettingsRead: "assistant.workspace.settings.read",
+  workspaceSettingsUpdate: "assistant.workspace.settings.update"
+});
+
+export { actionIds };

package/src/server/actions.js

@@ -0,0 +1,191 @@
+import { workspaceSlugParamsValidator } from "@jskit-ai/users-core/server/validators/routeParamsValidator";
+import { resolveWorkspace } from "@jskit-ai/users-core/server/support/resolveWorkspace";
+import {
+  EMPTY_INPUT_VALIDATOR
+} from "@jskit-ai/kernel/shared/actions/actionContributorHelpers";
+import { assistantResource } from "../shared/assistantResource.js";
+import {
+  assistantConsoleSettingsResource,
+  assistantWorkspaceSettingsResource
+} from "../shared/assistantSettingsResource.js";
+import { actionIds } from "./actionIds.js";
+
+const assistantActions = Object.freeze([
+  {
+    id: actionIds.chatStream,
+    version: 1,
+    kind: "stream",
+    channels: ["api", "internal"],
+    surfacesFrom: "workspace",
+    permission: {
+      require: "authenticated"
+    },
+    inputValidator: [workspaceSlugParamsValidator, assistantResource.operations.chatStream.bodyValidator],
+    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: "workspace",
+    permission: {
+      require: "authenticated"
+    },
+    inputValidator: [
+      workspaceSlugParamsValidator,
+      {
+        query: assistantResource.operations.conversationsList.queryValidator
+      }
+    ],
+    outputValidator: assistantResource.operations.conversationsList.outputValidator,
+    idempotency: "none",
+    audit: {
+      actionName: actionIds.conversationsList
+    },
+    observability: {},
+    async execute(input, context, deps) {
+      return deps.chatService.listConversations(input.query, {
+        context
+      });
+    }
+  },
+  {
+    id: actionIds.conversationMessagesList,
+    version: 1,
+    kind: "query",
+    channels: ["api", "internal"],
+    surfacesFrom: "workspace",
+    permission: {
+      require: "authenticated"
+    },
+    inputValidator: [
+      workspaceSlugParamsValidator,
+      assistantResource.operations.conversationMessagesList.paramsValidator,
+      {
+        query: assistantResource.operations.conversationMessagesList.queryValidator
+      }
+    ],
+    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
+      });
+    }
+  },
+  {
+    id: actionIds.consoleSettingsRead,
+    version: 1,
+    kind: "query",
+    channels: ["api", "automation", "internal"],
+    surfacesFrom: "console",
+    permission: {
+      require: "authenticated"
+    },
+    inputValidator: EMPTY_INPUT_VALIDATOR,
+    outputValidator: assistantConsoleSettingsResource.operations.view.outputValidator,
+    idempotency: "none",
+    audit: {
+      actionName: actionIds.consoleSettingsRead
+    },
+    observability: {},
+    async execute(_input, context, deps) {
+      return deps.assistantSettingsService.getConsoleSettings({
+        context
+      });
+    }
+  },
+  {
+    id: actionIds.consoleSettingsUpdate,
+    version: 1,
+    kind: "command",
+    channels: ["api", "automation", "internal"],
+    surfacesFrom: "console",
+    permission: {
+      require: "authenticated"
+    },
+    inputValidator: {
+      payload: assistantConsoleSettingsResource.operations.patch.bodyValidator
+    },
+    outputValidator: assistantConsoleSettingsResource.operations.patch.outputValidator,
+    idempotency: "optional",
+    audit: {
+      actionName: actionIds.consoleSettingsUpdate
+    },
+    observability: {},
+    async execute(input, context, deps) {
+      return deps.assistantSettingsService.updateConsoleSettings(input.payload, {
+        context
+      });
+    }
+  },
+  {
+    id: actionIds.workspaceSettingsRead,
+    version: 1,
+    kind: "query",
+    channels: ["api", "automation", "internal"],
+    surfacesFrom: "workspace",
+    permission: {
+      require: "any",
+      permissions: ["workspace.settings.view", "workspace.settings.update"]
+    },
+    inputValidator: workspaceSlugParamsValidator,
+    outputValidator: assistantWorkspaceSettingsResource.operations.view.outputValidator,
+    idempotency: "none",
+    audit: {
+      actionName: actionIds.workspaceSettingsRead
+    },
+    observability: {},
+    async execute(input, context, deps) {
+      return deps.assistantSettingsService.getWorkspaceSettings(resolveWorkspace(context, input), {
+        context
+      });
+    }
+  },
+  {
+    id: actionIds.workspaceSettingsUpdate,
+    version: 1,
+    kind: "command",
+    channels: ["api", "automation", "internal"],
+    surfacesFrom: "workspace",
+    permission: {
+      require: "all",
+      permissions: ["workspace.settings.update"]
+    },
+    inputValidator: [
+      workspaceSlugParamsValidator,
+      {
+        patch: assistantWorkspaceSettingsResource.operations.patch.bodyValidator
+      }
+    ],
+    outputValidator: assistantWorkspaceSettingsResource.operations.patch.outputValidator,
+    idempotency: "optional",
+    audit: {
+      actionName: actionIds.workspaceSettingsUpdate
+    },
+    observability: {},
+    async execute(input, context, deps) {
+      return deps.assistantSettingsService.updateWorkspaceSettings(resolveWorkspace(context, input), input.patch, {
+        context
+      });
+    }
+  }
+]);
+
+export { assistantActions };

package/src/server/diTokens.js

@@ -0,0 +1,19 @@
+const ASSISTANT_CONVERSATIONS_REPOSITORY_TOKEN = "assistant.conversation.repository";
+const ASSISTANT_MESSAGES_REPOSITORY_TOKEN = "assistant.message.repository";
+const ASSISTANT_SETTINGS_REPOSITORY_TOKEN = "assistant.settings.repository";
+const ASSISTANT_TRANSCRIPT_SERVICE_TOKEN = "assistant.transcript.service";
+const ASSISTANT_CHAT_SERVICE_TOKEN = "assistant.chat.service";
+const ASSISTANT_SETTINGS_SERVICE_TOKEN = "assistant.settings.service";
+const ASSISTANT_AI_CLIENT_TOKEN = "assistant.ai.client";
+const ASSISTANT_SERVICE_TOOL_CATALOG_TOKEN = "assistant.service.tool-catalog";
+
+export {
+  ASSISTANT_CONVERSATIONS_REPOSITORY_TOKEN,
+  ASSISTANT_MESSAGES_REPOSITORY_TOKEN,
+  ASSISTANT_SETTINGS_REPOSITORY_TOKEN,
+  ASSISTANT_TRANSCRIPT_SERVICE_TOKEN,
+  ASSISTANT_CHAT_SERVICE_TOKEN,
+  ASSISTANT_SETTINGS_SERVICE_TOKEN,
+  ASSISTANT_AI_CLIENT_TOKEN,
+  ASSISTANT_SERVICE_TOOL_CATALOG_TOKEN
+};

package/src/server/lib/aiClient.js

@@ -0,0 +1,43 @@
+import { createOpenAiClient } from "./providers/openAiClient.js";
+import { createDeepSeekClient } from "./providers/deepSeekClient.js";
+import { createAnthropicClient } from "./providers/anthropicClient.js";
+import {
+  DEFAULT_AI_PROVIDER,
+  SUPPORTED_AI_PROVIDERS,
+  normalizeModel,
+  normalizeProvider,
+  normalizeTimeoutMs
+} from "./providers/common.js";
+
+function createAiClient(options = {}) {
+  const provider = normalizeProvider(options.provider || DEFAULT_AI_PROVIDER);
+  const timeoutMs = normalizeTimeoutMs(options.timeoutMs);
+  const commonOptions = {
+    ...options,
+    provider,
+    timeoutMs,
+    model: normalizeModel(options.model)
+  };
+
+  if (provider === "openai") {
+    return createOpenAiClient(commonOptions);
+  }
+
+  if (provider === "deepseek") {
+    return createDeepSeekClient(commonOptions);
+  }
+
+  if (provider === "anthropic") {
+    return createAnthropicClient(commonOptions);
+  }
+
+  throw new TypeError(
+    `Unsupported assistant provider: ${provider}. Supported providers: ${SUPPORTED_AI_PROVIDERS.join(", ")}.`
+  );
+}
+
+export {
+  createAiClient,
+  SUPPORTED_AI_PROVIDERS,
+  DEFAULT_AI_PROVIDER
+};