@jskit-ai/assistant 0.1.4

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

package/src/server/lib/providers/anthropicClient.js

@@ -0,0 +1,375 @@
+import { normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
+import {
+  createDisabledClient,
+  createProviderRequestError,
+  normalizeArray,
+  normalizeContentText,
+  normalizeModel,
+  normalizeObject,
+  normalizeOptionalHttpUrl,
+  normalizeTimeoutMs,
+  parseJsonObjectOrDefault
+} from "./common.js";
+
+const DEFAULT_ANTHROPIC_MODEL = "claude-3-5-sonnet-latest";
+const DEFAULT_ANTHROPIC_BASE_URL = "https://api.anthropic.com";
+const DEFAULT_ANTHROPIC_MAX_TOKENS = 4096;
+const DEFAULT_ANTHROPIC_VERSION = "2023-06-01";
+
+function normalizeTemperature(value, fallback = 0.2) {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed)) {
+    return fallback;
+  }
+
+  if (parsed < 0) {
+    return 0;
+  }
+
+  if (parsed > 1) {
+    return 1;
+  }
+
+  return parsed;
+}
+
+function normalizeToolDescriptor(tool) {
+  const toolObject = normalizeObject(tool);
+  const functionSpec = normalizeObject(toolObject.function);
+  const name = normalizeText(functionSpec.name);
+
+  if (!name) {
+    return null;
+  }
+
+  const inputSchema = normalizeObject(functionSpec.parameters);
+  return {
+    name,
+    description: normalizeText(functionSpec.description),
+    input_schema: Object.keys(inputSchema).length > 0
+      ? inputSchema
+      : {
+          type: "object",
+          properties: {},
+          additionalProperties: true
+        }
+  };
+}
+
+function toAnthropicTools(tools = []) {
+  return normalizeArray(tools)
+    .map((tool) => normalizeToolDescriptor(tool))
+    .filter(Boolean);
+}
+
+function toAnthropicSystemAndMessages(messages = []) {
+  const systemLines = [];
+  const anthropicMessages = [];
+
+  for (const entry of normalizeArray(messages)) {
+    const message = normalizeObject(entry);
+    const role = normalizeText(message.role).toLowerCase();
+
+    if (role === "system") {
+      const systemText = normalizeContentText(message.content);
+      if (systemText) {
+        systemLines.push(systemText);
+      }
+      continue;
+    }
+
+    if (role === "user") {
+      const text = normalizeContentText(message.content);
+      if (!text) {
+        continue;
+      }
+
+      anthropicMessages.push({
+        role: "user",
+        content: text
+      });
+      continue;
+    }
+
+    if (role === "assistant") {
+      const blocks = [];
+      const text = normalizeContentText(message.content);
+      if (text) {
+        blocks.push({
+          type: "text",
+          text
+        });
+      }
+
+      const toolCalls = normalizeArray(message.tool_calls);
+      for (const [index, toolCall] of toolCalls.entries()) {
+        const toolCallObject = normalizeObject(toolCall);
+        const functionSpec = normalizeObject(toolCallObject.function);
+        const name = normalizeText(functionSpec.name);
+        if (!name) {
+          continue;
+        }
+
+        blocks.push({
+          type: "tool_use",
+          id: normalizeText(toolCallObject.id) || `tool_call_${index + 1}`,
+          name,
+          input: parseJsonObjectOrDefault(functionSpec.arguments, {})
+        });
+      }
+
+      if (blocks.length < 1) {
+        continue;
+      }
+
+      anthropicMessages.push({
+        role: "assistant",
+        content: blocks.length === 1 && blocks[0].type === "text" ? blocks[0].text : blocks
+      });
+      continue;
+    }
+
+    if (role === "tool") {
+      const toolUseId = normalizeText(message.tool_call_id);
+      if (!toolUseId) {
+        continue;
+      }
+
+      const text = normalizeContentText(message.content) || "{}";
+      anthropicMessages.push({
+        role: "user",
+        content: [
+          {
+            type: "tool_result",
+            tool_use_id: toolUseId,
+            content: text
+          }
+        ]
+      });
+    }
+  }
+
+  return {
+    system: systemLines.join("\n\n"),
+    messages: anthropicMessages
+  };
+}
+
+function mapAnthropicContentToOpenAiDelta(content = []) {
+  const blocks = normalizeArray(content);
+  const textParts = [];
+  const toolCalls = [];
+
+  for (const block of blocks) {
+    const blockObject = normalizeObject(block);
+    const type = normalizeText(blockObject.type).toLowerCase();
+
+    if (type === "text") {
+      const text = String(blockObject.text || "");
+      if (text) {
+        textParts.push(text);
+      }
+      continue;
+    }
+
+    if (type === "tool_use") {
+      const name = normalizeText(blockObject.name);
+      if (!name) {
+        continue;
+      }
+
+      toolCalls.push({
+        id: normalizeText(blockObject.id) || `tool_call_${toolCalls.length + 1}`,
+        index: toolCalls.length,
+        type: "function",
+        function: {
+          name,
+          arguments: JSON.stringify(normalizeObject(blockObject.input))
+        }
+      });
+    }
+  }
+
+  const delta = {};
+  if (textParts.length > 0) {
+    delta.content = textParts.join("");
+  }
+  if (toolCalls.length > 0) {
+    delta.tool_calls = toolCalls;
+  }
+
+  return delta;
+}
+
+function createSingleChunkStream(chunk) {
+  return (async function* singleChunkGenerator() {
+    yield chunk;
+  })();
+}
+
+async function fetchAnthropicMessage({
+  apiKey,
+  baseUrl,
+  model,
+  timeoutMs,
+  system = "",
+  messages,
+  tools,
+  temperature = 0.2,
+  signal
+} = {}) {
+  const hasFetch = typeof fetch === "function";
+  if (!hasFetch) {
+    throw createProviderRequestError({
+      status: 500,
+      code: "assistant_provider_fetch_missing",
+      message: "Global fetch is not available for anthropic provider."
+    });
+  }
+
+  const timeout = normalizeTimeoutMs(timeoutMs);
+  const upstreamSignal = signal;
+  const controller = new AbortController();
+  const timeoutHandle = setTimeout(() => {
+    controller.abort();
+  }, timeout);
+
+  const handleAbort = () => {
+    controller.abort();
+  };
+
+  if (upstreamSignal) {
+    if (upstreamSignal.aborted) {
+      controller.abort();
+    } else {
+      upstreamSignal.addEventListener("abort", handleAbort, {
+        once: true
+      });
+    }
+  }
+
+  const requestPayload = {
+    model,
+    max_tokens: DEFAULT_ANTHROPIC_MAX_TOKENS,
+    messages,
+    temperature: normalizeTemperature(temperature)
+  };
+  if (normalizeText(system)) {
+    requestPayload.system = system;
+  }
+  if (tools.length > 0) {
+    requestPayload.tools = tools;
+  }
+
+  try {
+    const response = await fetch(`${baseUrl}/v1/messages`, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        "x-api-key": apiKey,
+        "anthropic-version": DEFAULT_ANTHROPIC_VERSION
+      },
+      body: JSON.stringify(requestPayload),
+      signal: controller.signal
+    });
+
+    let payload = {};
+    try {
+      payload = await response.json();
+    } catch {
+      throw createProviderRequestError({
+        status: response.status,
+        code: "assistant_provider_invalid_response",
+        message: "Assistant provider returned an invalid response payload."
+      });
+    }
+
+    if (response.ok !== true) {
+      const providerError = normalizeObject(payload.error);
+      throw createProviderRequestError({
+        status: response.status,
+        code: normalizeText(providerError.type) || "assistant_provider_failed",
+        message: normalizeText(providerError.message) || normalizeText(payload.message)
+      });
+    }
+
+    return payload;
+  } finally {
+    clearTimeout(timeoutHandle);
+    if (upstreamSignal) {
+      upstreamSignal.removeEventListener("abort", handleAbort);
+    }
+  }
+}
+
+function createAnthropicClient({
+  enabled = true,
+  apiKey = "",
+  baseUrl = "",
+  model = "",
+  timeoutMs = 120_000
+} = {}) {
+  const normalizedApiKey = normalizeText(apiKey);
+  const normalizedBaseUrl = normalizeOptionalHttpUrl(normalizeText(baseUrl) || DEFAULT_ANTHROPIC_BASE_URL, {
+    context: "assistant anthropic baseUrl"
+  });
+  const normalizedModel = normalizeModel(model, DEFAULT_ANTHROPIC_MODEL);
+
+  if (enabled !== true || !normalizedApiKey) {
+    return createDisabledClient({
+      provider: "anthropic",
+      model: normalizedModel
+    });
+  }
+
+  async function createCompletion({ messages = [], tools = [], temperature = 0, signal } = {}) {
+    const normalizedMessages = toAnthropicSystemAndMessages(messages);
+    const anthropicTools = toAnthropicTools(tools);
+
+    const payload = await fetchAnthropicMessage({
+      apiKey: normalizedApiKey,
+      baseUrl: normalizedBaseUrl,
+      model: normalizedModel,
+      timeoutMs,
+      system: normalizedMessages.system,
+      messages: normalizedMessages.messages,
+      tools: anthropicTools,
+      temperature,
+      signal
+    });
+
+    return {
+      ...payload,
+      __openAiLikeDelta: mapAnthropicContentToOpenAiDelta(payload.content)
+    };
+  }
+
+  return Object.freeze({
+    enabled: true,
+    provider: "anthropic",
+    defaultModel: normalizedModel,
+    createChatCompletion: createCompletion,
+    async createChatCompletionStream({ messages = [], tools = [], temperature = 0.2, signal } = {}) {
+      const completion = await createCompletion({
+        messages,
+        tools,
+        temperature,
+        signal
+      });
+
+      return createSingleChunkStream({
+        choices: [
+          {
+            delta: completion.__openAiLikeDelta || {}
+          }
+        ]
+      });
+    }
+  });
+}
+
+export {
+  createAnthropicClient,
+  DEFAULT_ANTHROPIC_MODEL,
+  DEFAULT_ANTHROPIC_BASE_URL
+};

package/src/server/lib/providers/common.js

@@ -0,0 +1,158 @@
+import { AppError } from "@jskit-ai/kernel/server/runtime/errors";
+import { normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
+
+const SUPPORTED_AI_PROVIDERS = Object.freeze(["openai", "deepseek", "anthropic"]);
+const SUPPORTED_AI_PROVIDER_SET = new Set(SUPPORTED_AI_PROVIDERS);
+const DEFAULT_AI_PROVIDER = "openai";
+const DEFAULT_AI_TIMEOUT_MS = 120_000;
+
+function normalizeProvider(provider) {
+  const normalizedProvider = normalizeText(provider).toLowerCase() || DEFAULT_AI_PROVIDER;
+  if (SUPPORTED_AI_PROVIDER_SET.has(normalizedProvider)) {
+    return normalizedProvider;
+  }
+
+  throw new TypeError(
+    `Unsupported assistant provider: ${normalizedProvider}. Supported providers: ${SUPPORTED_AI_PROVIDERS.join(", ")}.`
+  );
+}
+
+function normalizeTimeoutMs(value, fallback = DEFAULT_AI_TIMEOUT_MS) {
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed < 1) {
+    return fallback;
+  }
+
+  return parsed;
+}
+
+function normalizeModel(value, fallback = "") {
+  return normalizeText(value) || fallback;
+}
+
+function normalizeOptionalHttpUrl(value, { context = "assistant baseUrl" } = {}) {
+  const normalized = normalizeText(value);
+  if (!normalized) {
+    return "";
+  }
+
+  let parsed;
+  try {
+    parsed = new URL(normalized);
+  } catch {
+    throw new TypeError(`${context} must be an absolute http(s) URL.`);
+  }
+
+  const protocol = String(parsed.protocol || "").toLowerCase();
+  if (protocol !== "http:" && protocol !== "https:") {
+    throw new TypeError(`${context} must be an absolute http(s) URL.`);
+  }
+
+  const serialized = parsed.toString();
+  return serialized.replace(/\/+$/g, "") || serialized;
+}
+
+function createDisabledClient({ provider = DEFAULT_AI_PROVIDER, model = "" } = {}) {
+  const disabledError = () => {
+    throw new AppError(503, "Assistant provider is not configured.");
+  };
+
+  return Object.freeze({
+    enabled: false,
+    provider,
+    defaultModel: model,
+    async createChatCompletion() {
+      disabledError();
+    },
+    async createChatCompletionStream() {
+      disabledError();
+    }
+  });
+}
+
+function createProviderRequestError({ status = 500, code = "assistant_provider_failed", message = "" } = {}) {
+  const normalizedStatus = Number.isInteger(Number(status)) ? Number(status) : 500;
+  const safeStatus = normalizedStatus >= 400 && normalizedStatus <= 599 ? normalizedStatus : 500;
+  const normalizedCode = normalizeText(code) || "assistant_provider_failed";
+  const normalizedMessage =
+    normalizeText(message) || (safeStatus >= 500 ? "Assistant provider request failed." : "Request failed.");
+
+  return new AppError(safeStatus, normalizedMessage, {
+    code: normalizedCode
+  });
+}
+
+function normalizeObject(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return {};
+  }
+
+  return value;
+}
+
+function normalizeArray(value) {
+  return Array.isArray(value) ? value : [];
+}
+
+function normalizeContentText(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+
+  if (!Array.isArray(content)) {
+    return "";
+  }
+
+  return content
+    .map((entry) => {
+      if (typeof entry === "string") {
+        return entry;
+      }
+
+      const block = normalizeObject(entry);
+      if (block.type === "text") {
+        return String(block.text || "");
+      }
+
+      return String(block.text || "");
+    })
+    .join("");
+}
+
+function parseJsonObjectOrDefault(value, fallback = {}) {
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    return value;
+  }
+
+  const source = normalizeText(value);
+  if (!source) {
+    return fallback;
+  }
+
+  try {
+    const parsed = JSON.parse(source);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      return parsed;
+    }
+  } catch {
+    // Ignore malformed JSON and fallback to empty object.
+  }
+
+  return fallback;
+}
+
+export {
+  SUPPORTED_AI_PROVIDERS,
+  DEFAULT_AI_PROVIDER,
+  DEFAULT_AI_TIMEOUT_MS,
+  normalizeProvider,
+  normalizeTimeoutMs,
+  normalizeModel,
+  normalizeOptionalHttpUrl,
+  createDisabledClient,
+  createProviderRequestError,
+  normalizeObject,
+  normalizeArray,
+  normalizeContentText,
+  parseJsonObjectOrDefault
+};

package/src/server/lib/providers/deepSeekClient.js

@@ -0,0 +1,22 @@
+import { normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
+import { createOpenAiCompatibleClient } from "./openAiCompatibleClient.js";
+
+const DEFAULT_DEEPSEEK_MODEL = "deepseek-chat";
+const DEFAULT_DEEPSEEK_BASE_URL = "https://api.deepseek.com";
+
+function createDeepSeekClient(options = {}) {
+  const normalizedBaseUrl = normalizeText(options.baseUrl) || DEFAULT_DEEPSEEK_BASE_URL;
+
+  return createOpenAiCompatibleClient({
+    ...options,
+    provider: "deepseek",
+    baseUrl: normalizedBaseUrl,
+    defaultModel: DEFAULT_DEEPSEEK_MODEL
+  });
+}
+
+export {
+  createDeepSeekClient,
+  DEFAULT_DEEPSEEK_MODEL,
+  DEFAULT_DEEPSEEK_BASE_URL
+};

package/src/server/lib/providers/openAiClient.js

@@ -0,0 +1,13 @@
+import { createOpenAiCompatibleClient } from "./openAiCompatibleClient.js";
+
+const DEFAULT_OPENAI_MODEL = "gpt-4.1-mini";
+
+function createOpenAiClient(options = {}) {
+  return createOpenAiCompatibleClient({
+    ...options,
+    provider: "openai",
+    defaultModel: DEFAULT_OPENAI_MODEL
+  });
+}
+
+export { createOpenAiClient, DEFAULT_OPENAI_MODEL };

package/src/server/lib/providers/openAiCompatibleClient.js

@@ -0,0 +1,69 @@
+import OpenAI from "openai";
+import { normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
+import {
+  createDisabledClient,
+  normalizeModel,
+  normalizeOptionalHttpUrl,
+  normalizeTimeoutMs
+} from "./common.js";
+
+function createOpenAiCompatibleClient({
+  enabled = true,
+  apiKey = "",
+  baseUrl = "",
+  model = "",
+  defaultModel = "",
+  provider = "openai",
+  timeoutMs = 120_000
+} = {}) {
+  const normalizedApiKey = normalizeText(apiKey);
+  const normalizedProvider = normalizeText(provider).toLowerCase() || "openai";
+  const normalizedModel = normalizeModel(model, defaultModel);
+
+  if (enabled !== true || !normalizedApiKey) {
+    return createDisabledClient({
+      provider: normalizedProvider,
+      model: normalizedModel
+    });
+  }
+
+  const normalizedBaseUrl = normalizeOptionalHttpUrl(baseUrl, {
+    context: `assistant ${normalizedProvider} baseUrl`
+  });
+  const client = new OpenAI({
+    apiKey: normalizedApiKey,
+    ...(normalizedBaseUrl ? { baseURL: normalizedBaseUrl } : {}),
+    timeout: normalizeTimeoutMs(timeoutMs)
+  });
+
+  return Object.freeze({
+    enabled: true,
+    provider: normalizedProvider,
+    defaultModel: normalizedModel,
+    async createChatCompletion({ messages = [], tools = [], temperature = 0, signal } = {}) {
+      const requestPayload = {
+        model: normalizedModel,
+        messages,
+        ...(Array.isArray(tools) && tools.length > 0 ? { tools } : {}),
+        temperature,
+        stream: false
+      };
+
+      return client.chat.completions.create(requestPayload, signal ? { signal } : undefined);
+    },
+    async createChatCompletionStream({ messages = [], tools = [], signal, temperature = 0.2 } = {}) {
+      return client.chat.completions.create(
+        {
+          model: normalizedModel,
+          messages,
+          tools,
+          temperature,
+          stream: true
+        },
+        signal ? { signal } : undefined
+      );
+    }
+  });
+}
+
+export { createOpenAiCompatibleClient };

package/src/server/lib/resolveWorkspaceSlug.js

@@ -0,0 +1,24 @@
+import { normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
+
+function resolveWorkspaceSlug(context = {}, actionInput = null) {
+  const sourceContext = context && typeof context === "object" ? context : {};
+  const sourceInput = actionInput && typeof actionInput === "object" && !Array.isArray(actionInput) ? actionInput : {};
+
+  const candidates = [
+    sourceContext?.workspace?.slug,
+    sourceContext?.requestMeta?.resolvedWorkspaceContext?.workspace?.slug,
+    sourceInput.workspaceSlug,
+    sourceContext?.requestMeta?.request?.input?.params?.workspaceSlug
+  ];
+
+  for (const candidate of candidates) {
+    const normalized = normalizeText(candidate).toLowerCase();
+    if (normalized) {
+      return normalized;
+    }
+  }
+
+  return "";
+}
+
+export { resolveWorkspaceSlug };