@nocobase/portal-template-default 1.0.0 → 1.0.2

package/registry/nocobase-ai/services/nocobase-ai-service.ts

@@ -0,0 +1,454 @@
+import { nocobaseClient, type NocoBaseClient } from "@/lib/nocobase/client";
+import type {
+  AIChatMessage,
+  AIConversation,
+  AIEmployee,
+  AIModel,
+} from "../providers/types";
+import type {
+  AIConversationActiveState,
+  AIService,
+  CreateAIConversationOptions,
+} from "./types";
+import type { UpdateToolCallDecisionOptions } from "./types";
+import {
+  getToolCallState,
+  getToolProviderMetadata,
+  type NocoBaseToolCall,
+} from "../providers/stream-event-utils";
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  !!value && typeof value === "object" && !Array.isArray(value);
+
+const parseToolInput = (value: unknown) => {
+  if (typeof value !== "string") return value;
+  try {
+    return JSON.parse(value) as unknown;
+  } catch {
+    return value;
+  }
+};
+
+const toAttachment = (
+  value: unknown,
+  index: number,
+  resolveUrl: (value: string) => string
+) => {
+  if (!isRecord(value)) return undefined;
+  const filename = value.filename ?? value.name ?? value.title;
+  if (typeof filename !== "string") return undefined;
+  return {
+    ...value,
+    uid: String(value.id ?? value.uid ?? `${filename}-${index}`),
+    filename,
+    status: "done" as const,
+    size: typeof value.size === "number" ? value.size : undefined,
+    mimetype:
+      typeof value.mimetype === "string"
+        ? value.mimetype
+        : typeof value.type === "string"
+        ? value.type
+        : undefined,
+    url: typeof value.url === "string" ? resolveUrl(value.url) : undefined,
+    preview:
+      typeof value.preview === "string" ? resolveUrl(value.preview) : undefined,
+  };
+};
+
+const toHistoryMessage = (
+  value: unknown,
+  index: number,
+  resolveUrl: (value: string) => string
+): AIChatMessage => {
+  const message = isRecord(value) ? value : {};
+  const content = isRecord(message.content) ? message.content : {};
+  const rawServerMessageId = content.messageId ?? message.messageId;
+  const serverMessageId =
+    typeof rawServerMessageId === "number" ||
+    (typeof rawServerMessageId === "string" && /^\d+$/.test(rawServerMessageId))
+      ? String(rawServerMessageId)
+      : undefined;
+  const messageId =
+    serverMessageId ?? String(message.key ?? `history-${index}`);
+  const text =
+    typeof content.content === "string"
+      ? content.content
+      : typeof message.content === "string"
+      ? message.content
+      : "";
+  const attachments = Array.isArray(content.attachments)
+    ? content.attachments
+        .map((attachment, attachmentIndex) =>
+          toAttachment(attachment, attachmentIndex, resolveUrl)
+        )
+        .filter((attachment) => attachment !== undefined)
+    : [];
+  const parts: AIChatMessage["parts"] = [];
+  const reasoning = isRecord(content.reasoning) ? content.reasoning : undefined;
+  if (typeof reasoning?.content === "string" && reasoning.content) {
+    parts.push({ type: "reasoning", text: reasoning.content, state: "done" });
+  }
+  if (text) parts.push({ type: "text", text, state: "done" });
+  const toolCalls = Array.isArray(content.tool_calls)
+    ? content.tool_calls
+    : Array.isArray(message.toolCalls)
+    ? message.toolCalls
+    : [];
+  for (const rawToolCall of toolCalls) {
+    if (!isRecord(rawToolCall)) continue;
+    const toolCallId = String(rawToolCall.id ?? `tool-${crypto.randomUUID()}`);
+    const toolName = String(rawToolCall.name ?? "tool");
+    const toolCall = rawToolCall as NocoBaseToolCall;
+    const { failed, completed } = getToolCallState(toolCall);
+    const callProviderMetadata = getToolProviderMetadata(toolCall);
+    parts.push(
+      failed
+        ? {
+            type: "dynamic-tool",
+            toolCallId,
+            toolName,
+            state: "output-error",
+            input: parseToolInput(rawToolCall.args ?? {}),
+            errorText: String(rawToolCall.content ?? "Tool call failed"),
+            callProviderMetadata,
+          }
+        : completed
+        ? {
+            type: "dynamic-tool",
+            toolCallId,
+            toolName,
+            state: "output-available",
+            input: parseToolInput(rawToolCall.args ?? {}),
+            output: rawToolCall.content,
+            callProviderMetadata,
+          }
+        : {
+            type: "dynamic-tool",
+            toolCallId,
+            toolName,
+            state: "input-available",
+            input: parseToolInput(rawToolCall.args ?? {}),
+            callProviderMetadata,
+          }
+    );
+  }
+  const subAgentConversations = Array.isArray(content.subAgentConversations)
+    ? content.subAgentConversations
+    : [];
+  for (const [
+    conversationIndex,
+    rawConversation,
+  ] of subAgentConversations.entries()) {
+    if (!isRecord(rawConversation)) continue;
+    const rawMessages = Array.isArray(rawConversation.messages)
+      ? rawConversation.messages
+      : [];
+    const messages = rawMessages.map((item, messageIndex) =>
+      toHistoryMessage(item, messageIndex, resolveUrl)
+    );
+    const username =
+      typeof rawConversation.username === "string"
+        ? rawConversation.username
+        : messages.find((item) => item.metadata?.employeeUsername)?.metadata
+            ?.employeeUsername ?? "sub-agent";
+    const sessionId = String(
+      rawConversation.sessionId ??
+        `sub-agent-history-${index}-${conversationIndex}`
+    );
+    parts.push({
+      type: "data-subAgent",
+      id: sessionId,
+      data: {
+        sessionId,
+        username,
+        status:
+          rawConversation.status === "completed" ? "completed" : "pending",
+        messages,
+      },
+    });
+  }
+  for (const attachment of attachments) {
+    if (!attachment.url && !attachment.preview) continue;
+    parts.push({
+      type: "file",
+      mediaType: attachment.mimetype ?? "application/octet-stream",
+      filename: attachment.filename,
+      url: attachment.url ?? attachment.preview ?? "",
+    });
+  }
+  const rawRole = String(message.role ?? "assistant");
+  const role =
+    rawRole === "user" || rawRole === "system" ? rawRole : "assistant";
+  return {
+    id: messageId,
+    role,
+    metadata: {
+      ...(serverMessageId ? { serverMessageId } : {}),
+      ...(rawRole !== "user" && rawRole !== "system"
+        ? { employeeUsername: rawRole }
+        : {}),
+      createdAt:
+        typeof message.createdAt === "string" ? message.createdAt : undefined,
+      attachments,
+      workContext: Array.isArray(content.workContext)
+        ? content.workContext
+        : undefined,
+    },
+    parts,
+  };
+};
+
+export class NocoBaseAIService implements AIService {
+  constructor(private readonly client: NocoBaseClient = nocobaseClient) {}
+
+  async listEmployees() {
+    const employees = await this.client.action<AIEmployee[]>(
+      "aiEmployees",
+      "listByUser"
+    );
+    return employees
+      .filter((employee) => employee?.username)
+      .map((employee) => ({
+        ...employee,
+        nickname: employee.nickname ?? employee.username,
+        description: employee.description ?? employee.bio,
+      }));
+  }
+
+  async listModels() {
+    const services = await this.client.action<
+      Array<{
+        llmService: string;
+        llmServiceTitle: string;
+        enabledModels?: Array<{ label: string; value: string }>;
+        supportWebSearch?: boolean;
+        isToolConflict?: boolean;
+      }>
+    >("ai", "listAllEnabledModels");
+    return services.flatMap((service) =>
+      (service.enabledModels ?? []).map<AIModel>((model) => ({
+        value: model.value,
+        label: model.label,
+        llmService: service.llmService,
+        llmServiceTitle: service.llmServiceTitle,
+        supportWebSearch: service.supportWebSearch,
+        isToolConflict: service.isToolConflict,
+      }))
+    );
+  }
+
+  async updateEmployeeUserPrompt(username: string, prompt: string) {
+    await this.client.action("aiEmployees", "updateUserPrompt", {
+      body: { aiEmployee: username, prompt },
+    });
+  }
+
+  async listConversations(keyword = "") {
+    const normalizedKeyword = keyword.trim();
+    const response = await this.client.action<
+      { data?: unknown[]; rows?: unknown[] } | unknown[]
+    >("aiConversations", "list", {
+      query: {
+        sort: "-createdAt",
+        appends: "aiEmployee",
+        page: 1,
+        pageSize: 50,
+        filter: normalizedKeyword
+          ? JSON.stringify({ title: { $includes: normalizedKeyword } })
+          : undefined,
+      },
+    });
+    const rows = Array.isArray(response)
+      ? response
+      : response.data ?? response.rows ?? [];
+    return rows.flatMap<AIConversation>((value) => {
+      if (!isRecord(value) || typeof value.sessionId !== "string") return [];
+      const employee = isRecord(value.aiEmployee)
+        ? value.aiEmployee
+        : undefined;
+      const options = isRecord(value.options) ? value.options : undefined;
+      const modelSettings = isRecord(options?.modelSettings)
+        ? options.modelSettings
+        : undefined;
+      return [
+        {
+          id: value.sessionId,
+          title:
+            typeof value.title === "string" && value.title
+              ? value.title
+              : "New conversation",
+          employeeUsername: String(
+            employee?.username ?? value.aiEmployeeUsername ?? ""
+          ),
+          updatedAt:
+            typeof value.updatedAt === "string"
+              ? value.updatedAt
+              : new Date().toISOString(),
+          unread: value.read === false,
+          model:
+            typeof modelSettings?.model === "string"
+              ? {
+                  llmService:
+                    typeof modelSettings.llmService === "string"
+                      ? modelSettings.llmService
+                      : undefined,
+                  model: modelSettings.model,
+                }
+              : undefined,
+        },
+      ];
+    });
+  }
+
+  async getConversationMessages(
+    sessionId: string,
+    options: { updateRead?: boolean } = {}
+  ) {
+    const response = await this.client.action<
+      { data?: unknown[]; rows?: unknown[] } | unknown[]
+    >("aiConversations", "getMessages", {
+      query: {
+        sessionId,
+        paginate: false,
+        updateRead: options.updateRead === true,
+      },
+      body: {},
+    });
+    const rows = Array.isArray(response)
+      ? response
+      : response.data ?? response.rows ?? [];
+    return [...rows]
+      .reverse()
+      .filter((value) => {
+        if (!isRecord(value)) return true;
+        return value.role !== "tool" && value.role !== "system";
+      })
+      .map((value, index) =>
+        toHistoryMessage(value, index, (url) => this.client.resolveUrl(url))
+      );
+  }
+
+  async getConversationActiveState(sessionId: string) {
+    const response = await this.client.action<{
+      llmActiveState?: unknown;
+    }>("aiConversations", "get", {
+      query: { filter: JSON.stringify({ sessionId }) },
+    });
+    const state = response?.llmActiveState;
+    return state === "idle" || state === "streaming" || state === "invoking"
+      ? (state as AIConversationActiveState)
+      : undefined;
+  }
+
+  async updateConversationTitle(sessionId: string, title: string) {
+    await this.client.action("aiConversations", "update", {
+      method: "PUT",
+      query: { filterByTk: sessionId },
+      body: { title },
+    });
+  }
+
+  async destroyConversation(sessionId: string) {
+    await this.client.action("aiConversations", "destroy", {
+      method: "DELETE",
+      query: { filterByTk: sessionId },
+    });
+  }
+
+  async uploadFile(file: File, signal?: AbortSignal) {
+    const formData = new FormData();
+    formData.append("file", file);
+    const response = await this.client.action<Record<string, unknown>>(
+      "aiFiles",
+      "create",
+      {
+        body: formData,
+        signal,
+        unwrap: "deep-data",
+      }
+    );
+    return {
+      ...response,
+      ...(typeof response.url === "string"
+        ? { url: this.client.resolveUrl(response.url) }
+        : {}),
+      ...(typeof response.preview === "string"
+        ? { preview: this.client.resolveUrl(response.preview) }
+        : {}),
+    };
+  }
+
+  async createConversation(options: CreateAIConversationOptions) {
+    const response = await this.client.action<{ sessionId: string }>(
+      "aiConversations",
+      "create",
+      {
+        body: {
+          aiEmployee: options.employee,
+          systemMessage: options.systemMessage,
+          skillSettings: options.skillSettings,
+          modelSettings: {
+            llmService: options.model.llmService,
+            model: options.model.value,
+          },
+        },
+      }
+    );
+    return response.sessionId;
+  }
+
+  sendMessagesStream(body: unknown, signal?: AbortSignal) {
+    return this.client.stream("aiConversations:sendMessages", {
+      body,
+      signal,
+    });
+  }
+
+  resendMessagesStream(body: unknown, signal?: AbortSignal) {
+    return this.client.stream("aiConversations:resendMessages", {
+      body,
+      signal,
+    });
+  }
+
+  async updateToolCallDecision(options: UpdateToolCallDecisionOptions) {
+    const result = await this.client.action<{
+      updated: number;
+      toolCalls: Array<{
+        id: string;
+        name: string;
+        invokeStatus?: string;
+        status?: string;
+        auto?: boolean;
+        execution?: string;
+        willInterrupt?: boolean;
+        args?: unknown;
+      }>;
+    }>("aiConversations", "updateUserDecision", {
+      body: options,
+    });
+    return {
+      ...result,
+      toolCalls: result.toolCalls.map((toolCall) => ({
+        ...toolCall,
+        args: parseToolInput(toolCall.args),
+      })),
+    };
+  }
+
+  resumeToolCallStream(body: unknown, signal?: AbortSignal) {
+    return this.client.stream("aiConversations:resumeToolCall", {
+      body,
+      signal,
+    });
+  }
+
+  resumeConversationStream(sessionId: string, signal?: AbortSignal) {
+    return this.client.stream("aiConversations:resumeStream", {
+      body: { sessionId },
+      signal,
+    });
+  }
+}
+
+export const nocobaseAIService = new NocoBaseAIService();

package/registry/nocobase-ai/services/types.ts

@@ -0,0 +1,82 @@
+import type {
+  AIChatMessage,
+  AIConversation,
+  AIEmployee,
+  AIModel,
+} from "../providers/types";
+
+export type CreateAIConversationOptions = {
+  employee: AIEmployee;
+  model: AIModel;
+  systemMessage?: string;
+  skillSettings?: {
+    skills?: string[];
+    tools?: string[];
+  };
+};
+
+export type UpdateToolCallDecisionOptions = {
+  sessionId: string;
+  messageId: string;
+  toolCallId: string;
+  userDecision:
+    | { type: "approve" }
+    | { type: "reject"; message?: string }
+    | {
+        type: "edit";
+        editedAction: { name: string; args: unknown };
+      };
+};
+
+export type UpdatedToolCall = {
+  id: string;
+  name: string;
+  invokeStatus?: string;
+  status?: string;
+  auto?: boolean;
+  execution?: string;
+  willInterrupt?: boolean;
+  args?: unknown;
+};
+
+export type AIConversationActiveState = "idle" | "streaming" | "invoking";
+
+export interface AIService {
+  listEmployees(): Promise<AIEmployee[]>;
+  listModels(): Promise<AIModel[]>;
+  updateEmployeeUserPrompt(username: string, prompt: string): Promise<void>;
+  listConversations(keyword?: string): Promise<AIConversation[]>;
+  getConversationMessages(
+    sessionId: string,
+    options?: { updateRead?: boolean }
+  ): Promise<AIChatMessage[]>;
+  getConversationActiveState(
+    sessionId: string
+  ): Promise<AIConversationActiveState | undefined>;
+  updateConversationTitle(sessionId: string, title: string): Promise<void>;
+  destroyConversation(sessionId: string): Promise<void>;
+  uploadFile(
+    file: File,
+    signal?: AbortSignal
+  ): Promise<Record<string, unknown>>;
+  createConversation(options: CreateAIConversationOptions): Promise<string>;
+  sendMessagesStream(
+    body: unknown,
+    signal?: AbortSignal
+  ): Promise<ReadableStream<Uint8Array>>;
+  resendMessagesStream(
+    body: unknown,
+    signal?: AbortSignal
+  ): Promise<ReadableStream<Uint8Array>>;
+  updateToolCallDecision(
+    options: UpdateToolCallDecisionOptions
+  ): Promise<{ updated: number; toolCalls: UpdatedToolCall[] }>;
+  resumeToolCallStream(
+    body: unknown,
+    signal?: AbortSignal
+  ): Promise<ReadableStream<Uint8Array>>;
+  resumeConversationStream(
+    sessionId: string,
+    signal?: AbortSignal
+  ): Promise<ReadableStream<Uint8Array>>;
+}

package/registry/nocobase-ai/tests/business-report-regression.mjs

@@ -0,0 +1,70 @@
+import assert from "node:assert/strict";
+import { createServer } from "vite";
+
+const server = await createServer({
+  appType: "custom",
+  logLevel: "silent",
+  server: { middlewareMode: true },
+});
+
+try {
+  const {
+    buildBusinessReportMarkdown,
+    renderBusinessReportMarkdownToHtml,
+    splitBusinessReportMarkdown,
+  } = await server.ssrLoadModule(
+    "/registry/nocobase-ai/components/tools/business-report-utils.tsx"
+  );
+
+  const markdown = buildBusinessReportMarkdown({
+    title: "Quarterly report",
+    summary: "A complete report summary.",
+    markdown: `## KPI overview
+
+| Metric | Value |
+| --- | ---: |
+| Revenue | 1286 |
+
+{{chart:1}}
+
+## Trend analysis
+
+The trend continued after the first chart.
+
+{{chart:2}}
+
+## Recommendations
+
+Keep the final section in the exported HTML.`,
+    charts: [
+      { title: "Trend", options: { series: [{ type: "line", data: [1, 2] }] } },
+      { title: "Mix", options: { series: [{ type: "pie", data: [1, 2] }] } },
+    ],
+  });
+  const parts = splitBusinessReportMarkdown(markdown);
+
+  assert.equal(parts.length, 5);
+  assert.equal(parts[0].type, "markdown");
+  assert.match(parts[0].content, /Quarterly report/);
+  assert.match(parts[0].content, /KPI overview/);
+  assert.equal(parts[1].type, "chart");
+  assert.match(parts[2].content, /Trend analysis/);
+  assert.equal(parts[3].type, "chart");
+  assert.match(parts[4].content, /Recommendations/);
+
+  const firstSectionHtml = await renderBusinessReportMarkdownToHtml(
+    parts[0].content
+  );
+  assert.match(firstSectionHtml, /<h1>Quarterly report<\/h1>/);
+  assert.match(firstSectionHtml, /<h2>KPI overview<\/h2>/);
+  assert.match(firstSectionHtml, /<table>/);
+  assert.match(firstSectionHtml, /Revenue/);
+
+  console.log("AI business report regression tests passed");
+} finally {
+  await server.close();
+}
+
+// React's browser prerender runtime keeps an internal MessagePort alive in
+// Node even after the assertion and Vite server have completed.
+process.exit(0);