@nocobase/portal-template-default 1.0.1 → 1.0.3

package/src/extensions/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/src/extensions/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/src/index.tsx

@@ -1,6 +1,7 @@
 import React from "react";
 import { createRoot } from "react-dom/client";
 
+import "./locales";
 import App from "./App";
 
 const container = document.getElementById("root") as HTMLElement;
@@ -12,6 +13,4 @@ const root = createRoot(container);
 //   </React.StrictMode>
 // );
 
-root.render(
-  <App />
-);
+root.render(<App />);

package/src/lib/i18n.ts

@@ -0,0 +1,161 @@
+export type TranslationOptions = Record<string, unknown> & {
+  defaultValue?: string;
+  ns?: string | string[];
+};
+
+export type TranslationResolver = (
+  key: string,
+  options?: TranslationOptions,
+  defaultMessage?: string
+) => string;
+
+export type TranslationExpression = {
+  key: string;
+  options?: TranslationOptions;
+};
+
+export type TranslationResource = Record<string, string | number | boolean>;
+
+export type TranslationResourceBundle = Record<string, TranslationResource>;
+
+type TranslationResourceListener = (
+  namespace: string,
+  resources: TranslationResourceBundle
+) => void;
+
+let translationResolver: TranslationResolver | undefined;
+const translationResources = new Map<string, TranslationResourceBundle>();
+const translationResourceListeners = new Set<TranslationResourceListener>();
+
+const quotedValuePattern = `(?:"(?:\\\\.|[^"\\\\])*"|'(?:\\\\.|[^'\\\\])*')`;
+const translationExpressionPattern = new RegExp(
+  `^\\s*\\{\\{\\s*t\\(\\s*(${quotedValuePattern})\\s*(?:,\\s*(\\{[\\s\\S]*\\}))?\\s*\\)\\s*\\}\\}\\s*$`
+);
+
+function decodeQuotedValue(value: string) {
+  if (value.startsWith('"')) {
+    try {
+      return JSON.parse(value) as string;
+    } catch {
+      return value.slice(1, -1);
+    }
+  }
+
+  return value
+    .slice(1, -1)
+    .replace(/\\'/g, "'")
+    .replace(/\\"/g, '"')
+    .replace(/\\n/g, "\n")
+    .replace(/\\r/g, "\r")
+    .replace(/\\t/g, "\t")
+    .replace(/\\\\/g, "\\");
+}
+
+function parsePrimitive(value: string): unknown {
+  const normalized = value.trim();
+  if (normalized.startsWith('"') || normalized.startsWith("'")) {
+    return decodeQuotedValue(normalized);
+  }
+  if (normalized === "true") return true;
+  if (normalized === "false") return false;
+  if (normalized === "null") return null;
+  if (/^-?\d+(?:\.\d+)?$/.test(normalized)) return Number(normalized);
+  return undefined;
+}
+
+function parseOptions(source?: string): TranslationOptions | undefined {
+  if (!source) return undefined;
+
+  const options: TranslationOptions = {};
+  const propertyPattern = new RegExp(
+    `([A-Za-z_$][\\w$]*)\\s*:\\s*(${quotedValuePattern}|-?\\d+(?:\\.\\d+)?|true|false|null)`,
+    "g"
+  );
+
+  for (const match of source.matchAll(propertyPattern)) {
+    const value = parsePrimitive(match[2]);
+    if (typeof value !== "undefined") options[match[1]] = value;
+  }
+
+  const namespaceArray = source.match(/\bns\s*:\s*\[([^\]]*)\]/);
+  if (namespaceArray) {
+    const namespaces = [
+      ...namespaceArray[1].matchAll(new RegExp(quotedValuePattern, "g")),
+    ].map((match) => decodeQuotedValue(match[0]));
+    if (namespaces.length) options.ns = namespaces;
+  }
+
+  return Object.keys(options).length ? options : undefined;
+}
+
+export function parseTranslationExpression(
+  value: string
+): TranslationExpression | undefined {
+  const match = translationExpressionPattern.exec(value);
+  if (!match) return undefined;
+
+  return {
+    key: decodeQuotedValue(match[1]),
+    options: parseOptions(match[2]),
+  };
+}
+
+export function setTranslationResolver(resolver?: TranslationResolver) {
+  translationResolver = resolver;
+  return () => {
+    if (translationResolver === resolver) translationResolver = undefined;
+  };
+}
+
+export function registerTranslationResources(
+  namespace: string,
+  resources: TranslationResourceBundle
+) {
+  const current = translationResources.get(namespace) ?? {};
+  const merged = Object.fromEntries(
+    [...new Set([...Object.keys(current), ...Object.keys(resources)])].map(
+      (locale) => [
+        locale,
+        {
+          ...(current[locale] ?? {}),
+          ...(resources[locale] ?? {}),
+        },
+      ]
+    )
+  );
+
+  translationResources.set(namespace, merged);
+  translationResourceListeners.forEach((listener) =>
+    listener(namespace, resources)
+  );
+}
+
+export function getTranslationResources() {
+  return [...translationResources.entries()];
+}
+
+export function subscribeTranslationResources(
+  listener: TranslationResourceListener
+) {
+  translationResourceListeners.add(listener);
+  return () => translationResourceListeners.delete(listener);
+}
+
+export function resolveTranslatableText(
+  value: unknown,
+  options?: TranslationOptions
+): string {
+  if (typeof value !== "string") return value == null ? "" : String(value);
+
+  const expression = parseTranslationExpression(value);
+  if (!expression) {
+    return translationResolver && options
+      ? translationResolver(value, options, value)
+      : value;
+  }
+
+  const defaultMessage = expression.options?.defaultValue ?? expression.key;
+  return translationResolver
+    ? translationResolver(expression.key, expression.options, defaultMessage)
+    : defaultMessage;
+}