@jskit-ai/assistant-core 0.1.1

package/src/client/components/AssistantSettingsFormCard.vue

@@ -0,0 +1,76 @@
+<template>
+  <section :class="props.rootClass">
+    <v-card rounded="lg" elevation="1" border>
+      <v-card-item>
+        <v-card-title class="text-h6">{{ props.title }}</v-card-title>
+        <v-card-subtitle>{{ props.subtitle }}</v-card-subtitle>
+      </v-card-item>
+      <v-divider />
+      <v-card-text class="pt-4">
+        <template v-if="props.showFormSkeleton">
+          <v-skeleton-loader type="text@2, list-item-two-line@4, button" />
+        </template>
+
+        <p v-else-if="props.addEdit.loadError" class="text-body-2 text-medium-emphasis mb-4">
+          {{ props.addEdit.loadError }}
+        </p>
+
+        <p v-else-if="!props.addEdit.canView" class="text-body-2 text-medium-emphasis mb-4">
+          {{ props.noPermissionMessage }}
+        </p>
+
+        <template v-else>
+          <v-form @submit.prevent="props.addEdit.submit" novalidate>
+            <v-progress-linear v-if="props.addEdit.isRefetching" indeterminate class="mb-4" />
+            <slot />
+            <div class="d-flex align-center justify-end ga-3 mt-2">
+              <v-btn
+                v-if="props.addEdit.canSave"
+                type="submit"
+                color="primary"
+                :loading="props.addEdit.isSaving"
+                :disabled="props.addEdit.isInitialLoading || props.addEdit.isRefetching"
+              >
+                {{ props.saveLabel }}
+              </v-btn>
+              <v-chip v-else color="secondary" label>Read-only</v-chip>
+            </div>
+          </v-form>
+        </template>
+      </v-card-text>
+    </v-card>
+  </section>
+</template>
+
+<script setup>
+const props = defineProps({
+  rootClass: {
+    type: String,
+    required: true
+  },
+  title: {
+    type: String,
+    required: true
+  },
+  subtitle: {
+    type: String,
+    required: true
+  },
+  noPermissionMessage: {
+    type: String,
+    required: true
+  },
+  saveLabel: {
+    type: String,
+    required: true
+  },
+  addEdit: {
+    type: Object,
+    required: true
+  },
+  showFormSkeleton: {
+    type: Boolean,
+    default: false
+  }
+});
+</script>

package/src/client/index.js

@@ -0,0 +1,5 @@
+export { default as AssistantClientElement } from "./components/AssistantClientElement.vue";
+export { default as AssistantSettingsFormCard } from "./components/AssistantSettingsFormCard.vue";
+export { assistantHttpClient } from "./lib/assistantHttpClient.js";
+export { createAssistantApi, buildStreamEventError } from "./lib/assistantApi.js";
+export { renderMarkdownToSafeHtml } from "./lib/markdownRenderer.js";

package/src/client/lib/assistantApi.js

@@ -0,0 +1,140 @@
+import { appendQueryString } from "@jskit-ai/kernel/shared/support";
+import {
+  ASSISTANT_STREAM_EVENT_TYPES,
+  normalizeAssistantStreamEventType
+} from "../../shared/index.js";
+
+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 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 resolveRequiredBasePath(resolveBasePath) {
+  if (typeof resolveBasePath !== "function") {
+    throw new Error("createAssistantApi requires resolveBasePath().");
+  }
+
+  const resolved = String(resolveBasePath() || "").trim();
+  if (!resolved) {
+    throw new Error("Assistant API base path is required.");
+  }
+
+  return resolved;
+}
+
+function createAssistantApi({ request, requestStream, resolveBasePath, resolveSurfaceId = null } = {}) {
+  if (typeof request !== "function" || typeof requestStream !== "function") {
+    throw new Error("createAssistantApi requires request() and requestStream().");
+  }
+
+  return Object.freeze({
+    async streamChat(payload, { signal, onEvent, onMalformedLine, rejectOnErrorEvent = true } = {}) {
+      const basePath = resolveRequiredBasePath(resolveBasePath);
+      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(query = {}) {
+      const basePath = resolveRequiredBasePath(resolveBasePath);
+      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(conversationId, query = {}) {
+      const basePath = resolveRequiredBasePath(resolveBasePath);
+      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 {
+  createAssistantApi,
+  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/server/index.js

@@ -0,0 +1,21 @@
+export { createAiClient, SUPPORTED_AI_PROVIDERS, DEFAULT_AI_PROVIDER } from "./lib/aiClient.js";
+export {
+  DEFAULT_AI_TIMEOUT_MS,
+  normalizeOptionalHttpUrl,
+  normalizeTimeoutMs
+} from "./lib/providers/common.js";
+export {
+  NDJSON_CONTENT_TYPE,
+  endNdjson,
+  mapStreamError,
+  setNdjsonHeaders,
+  writeNdjson
+} from "./lib/ndjson.js";
+export { resolveWorkspaceSlug } from "./lib/resolveWorkspaceSlug.js";
+export { createServiceToolCatalog } from "./lib/serviceToolCatalog.js";
+export {
+  parseJsonObject,
+  resolveInsertedId,
+  stringifyJsonObject,
+  toIso
+} from "./repositories/repositoryPersistenceUtils.js";

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
+};

package/src/server/lib/ndjson.js

@@ -0,0 +1,47 @@
+const NDJSON_CONTENT_TYPE = "application/x-ndjson; charset=utf-8";
+
+function setNdjsonHeaders(reply) {
+  // Fastify reply.hijack bypasses part of reply serialization. Set headers on both
+  // Fastify reply and the underlying raw response to keep streaming content-type intact.
+  reply.header("Content-Type", NDJSON_CONTENT_TYPE);
+  reply.header("Cache-Control", "no-cache");
+  reply.header("X-Accel-Buffering", "no");
+
+  if (reply?.raw && typeof reply.raw.setHeader === "function") {
+    reply.raw.setHeader("Content-Type", NDJSON_CONTENT_TYPE);
+    reply.raw.setHeader("Cache-Control", "no-cache");
+    reply.raw.setHeader("X-Accel-Buffering", "no");
+  }
+}
+
+function writeNdjson(reply, payload = {}) {
+  const body = `${JSON.stringify(payload)}\n`;
+  reply.raw.write(body);
+}
+
+function endNdjson(reply) {
+  if (!reply || !reply.raw || reply.raw.writableEnded) {
+    return;
+  }
+
+  reply.raw.end();
+}
+
+function mapStreamError(error) {
+  const status = Number(error?.status || error?.statusCode || 500);
+  const safeStatus = Number.isInteger(status) && status >= 400 && status <= 599 ? status : 500;
+
+  return Object.freeze({
+    code: String(error?.code || "assistant_stream_failed").trim() || "assistant_stream_failed",
+    message: safeStatus >= 500 ? "Assistant stream failed." : String(error?.message || "Request failed."),
+    status: safeStatus
+  });
+}
+
+export {
+  NDJSON_CONTENT_TYPE,
+  setNdjsonHeaders,
+  writeNdjson,
+  endNdjson,
+  mapStreamError
+};