@nocobase/plugin-ai 2.1.0-alpha.13 → 2.1.0-alpha.15

package/dist/server/ai-employees/ai-conversations.js

@@ -0,0 +1,285 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ai_conversations_exports = {};
+__export(ai_conversations_exports, {
+  AIConversationsManager: () => AIConversationsManager
+});
+module.exports = __toCommonJS(ai_conversations_exports);
+var import_database = require("@nocobase/database");
+var import_utils = require("../utils");
+class AIConversationsManager {
+  constructor(plugin) {
+    this.plugin = plugin;
+  }
+  async create({ userId, aiEmployee, title, options = {}, from = "main-agent" }) {
+    return await this.aiConversationsRepo.create({
+      values: {
+        userId,
+        title,
+        aiEmployee,
+        options,
+        thread: 1,
+        from
+      }
+    });
+  }
+  async update({ userId, sessionId, title, options: inputOptions }) {
+    const conversation = await this.aiConversationsRepo.findOne({
+      filter: {
+        sessionId,
+        userId
+      }
+    });
+    if (!conversation) {
+      throw new Error("invalid sessionId");
+    }
+    const { systemMessage, skillSettings, conversationSettings } = inputOptions ?? {};
+    const options = conversation.options ?? {};
+    if (systemMessage) {
+      options["systemMessage"] = systemMessage;
+    }
+    if (skillSettings) {
+      options["skillSettings"] = skillSettings;
+    }
+    if (conversationSettings) {
+      options["conversationSettings"] = conversationSettings;
+    }
+    const values = { options };
+    if (title) {
+      values.title = title;
+    }
+    return await this.aiConversationsRepo.update({
+      filter: {
+        userId,
+        sessionId
+      },
+      values
+    });
+  }
+  async getMessages({
+    userId,
+    sessionId,
+    cursor,
+    paginate = true
+  }) {
+    const conversation = await this.aiConversationsRepo.findOne({
+      filter: {
+        sessionId,
+        userId
+      }
+    });
+    if (!conversation) {
+      throw new Error("invalid sessionId");
+    }
+    const pageSize = 10;
+    const maxLimit = 200;
+    const messageRepository = this.plugin.db.getRepository("aiConversations.messages", sessionId);
+    const filter = {
+      role: {
+        $notIn: ["tool"]
+      }
+    };
+    if (paginate && cursor) {
+      filter["messageId"] = {
+        $lt: cursor
+      };
+    }
+    const rows = await messageRepository.find({
+      sort: ["-messageId"],
+      limit: paginate ? pageSize + 1 : maxLimit,
+      filter
+    });
+    const hasMore = paginate && rows.length > pageSize;
+    const data = hasMore ? rows.slice(0, -1) : rows;
+    const newCursor = data.length ? data[data.length - 1].messageId : null;
+    const subAgentConversations = data.filter((row) => {
+      var _a, _b;
+      return ((_b = (_a = row.metadata) == null ? void 0 : _a.subAgentConversations) == null ? void 0 : _b.length) ?? 0 > 0;
+    }).flatMap((row) => row.metadata.subAgentConversations);
+    const subAgentConversationSessionIds = [...new Set(subAgentConversations.map((item) => item.sessionId))];
+    const subAgentConversationMessages = subAgentConversationSessionIds.length ? await this.aiMessagesRepo.find({
+      sort: ["messageId"],
+      filter: {
+        sessionId: {
+          $in: subAgentConversationSessionIds
+        },
+        role: {
+          $notIn: ["tool"]
+        }
+      }
+    }) : [];
+    const subAgentConversationMessageMap = /* @__PURE__ */ new Map();
+    const toolCallIds = [
+      ...data.filter((row) => {
+        var _a;
+        return ((_a = row == null ? void 0 : row.toolCalls) == null ? void 0 : _a.length) ?? 0 > 0;
+      }).flatMap((row) => row.toolCalls).map((toolCall) => toolCall.id),
+      ...subAgentConversationMessages.filter((row) => {
+        var _a;
+        return ((_a = row == null ? void 0 : row.toolCalls) == null ? void 0 : _a.length) ?? 0 > 0;
+      }).flatMap((row) => row.toolCalls).map((toolCall) => toolCall.id)
+    ];
+    const toolMessages = await this.aiToolMessagesRepo.find({
+      filter: {
+        toolCallId: {
+          $in: toolCallIds
+        }
+      }
+    });
+    const toolMessageKey = (messageId, toolCallId) => `${messageId}:${toolCallId}`;
+    const toolMessageMap = new Map(
+      toolMessages.map((toolMessage) => [
+        toolMessageKey(toolMessage.messageId, toolMessage.toolCallId),
+        toolMessage
+      ])
+    );
+    const toolsList = await this.plugin.aiManager.toolManager.listTools();
+    const toolsMap = new Map(
+      toolsList.map((group) => group.tools).flat().map((tool) => [tool.name, tool])
+    );
+    const parseMessageRow = (row) => {
+      var _a, _b;
+      if (((_a = row == null ? void 0 : row.toolCalls) == null ? void 0 : _a.length) ?? 0 > 0) {
+        for (const toolCall of row.toolCalls) {
+          const tool = toolsMap.get(toolCall.name);
+          const toolMessage = toolMessageMap.get(toolMessageKey(row.messageId, toolCall.id));
+          toolCall.invokeStatus = toolMessage == null ? void 0 : toolMessage.invokeStatus;
+          toolCall.auto = toolMessage == null ? void 0 : toolMessage.auto;
+          toolCall.status = toolMessage == null ? void 0 : toolMessage.status;
+          toolCall.content = toolMessage == null ? void 0 : toolMessage.content;
+          toolCall.execution = tool == null ? void 0 : tool.execution;
+          toolCall.willInterrupt = (tool == null ? void 0 : tool.execution) === "frontend" || (toolMessage == null ? void 0 : toolMessage.auto) === false;
+          toolCall.defaultPermission = tool == null ? void 0 : tool.defaultPermission;
+        }
+      }
+      const providerOptions = this.plugin.aiManager.llmProviders.get((_b = row.metadata) == null ? void 0 : _b.provider);
+      if (!providerOptions) {
+        return (0, import_utils.parseResponseMessage)(row);
+      }
+      const Provider = providerOptions.provider;
+      const provider = new Provider({
+        app: this.plugin.app
+      });
+      return provider.parseResponseMessage(row);
+    };
+    for (const row of subAgentConversationMessages) {
+      const sessionMessages = subAgentConversationMessageMap.get(row.sessionId) ?? [];
+      sessionMessages.push(parseMessageRow(row));
+      sessionMessages.forEach((it) => it.content.from = "sub-agent");
+      subAgentConversationMessageMap.set(row.sessionId, sessionMessages);
+    }
+    return {
+      rows: data.map((row) => {
+        var _a;
+        const parsedRow = parseMessageRow(row);
+        const subAgentConversationItems = ((_a = row.metadata) == null ? void 0 : _a.subAgentConversations) ?? [];
+        if (subAgentConversationItems.length) {
+          parsedRow.content.subAgentConversations = subAgentConversationItems.map((item) => ({
+            sessionId: item.sessionId,
+            toolCallId: item.toolCallId,
+            status: item.status,
+            messages: subAgentConversationMessageMap.get(item.sessionId) ?? []
+          }));
+        }
+        parsedRow.content.from = "main-agent";
+        return parsedRow;
+      }),
+      ...paginate && {
+        hasMore,
+        cursor: newCursor
+      }
+    };
+  }
+  async getUserDecisions(messageId) {
+    var _a;
+    const allInterruptedToolCall = await this.aiToolMessagesRepo.find({
+      filter: {
+        messageId,
+        interruptActionOrder: { [import_database.Op.not]: null }
+      },
+      order: [["interruptActionOrder", "ASC"]]
+    });
+    if (!allInterruptedToolCall.every((t) => t.invokeStatus === "waiting")) {
+      return null;
+    }
+    const message = await this.aiMessagesRepo.findOne({
+      filter: {
+        messageId
+      }
+    });
+    const interruptId = (_a = message == null ? void 0 : message.get("metadata")) == null ? void 0 : _a.interruptId;
+    return {
+      interruptId,
+      decisions: allInterruptedToolCall.map((item) => item.userDecision)
+    };
+  }
+  async resolveSubAgentConversation(sessionId, toolCallId) {
+    var _a, _b;
+    if (!sessionId || !toolCallId) {
+      return null;
+    }
+    const toolMessage = await this.aiToolMessagesRepo.findOne({
+      filter: {
+        sessionId,
+        toolCallId
+      }
+    });
+    if (!toolMessage) {
+      return null;
+    }
+    const aiMessage = await this.aiMessagesRepo.findOne({
+      filter: {
+        sessionId,
+        messageId: toolMessage.messageId
+      }
+    });
+    if (!aiMessage) {
+      return null;
+    }
+    if (!((_b = (_a = aiMessage.metadata) == null ? void 0 : _a.subAgentConversations) == null ? void 0 : _b.length)) {
+      return null;
+    }
+    const subAgentConversation = aiMessage.metadata.subAgentConversations.find((it) => it.toolCallId == toolCallId);
+    if (!subAgentConversation) {
+      return null;
+    }
+    return subAgentConversation;
+  }
+  get aiConversationsRepo() {
+    return this.plugin.db.getRepository("aiConversations");
+  }
+  get aiMessagesRepo() {
+    return this.plugin.db.getRepository("aiMessages");
+  }
+  get aiToolMessagesRepo() {
+    return this.plugin.db.getRepository("aiToolMessages");
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AIConversationsManager
+});

package/dist/server/ai-employees/ai-employee.d.ts

@@ -8,7 +8,7 @@
  */
 import { Model, Transaction } from '@nocobase/database';
 import { LLMProvider } from '../llm-providers/provider';
-import { AIChatContext, AIChatConversation, AIMessageInput, UserDecision } from '../types';
+import { AIChatContext, AIChatConversation, AIMessageInput, AIToolCall, UserDecision } from '../types';
 import { DocumentSegmentedWithScore } from '../features';
 import { KnowledgeBaseGroup } from '../types';
 import { ToolsEntry } from '@nocobase/ai';
@@ -18,38 +18,59 @@ export interface ModelRef {
     llmService: string;
     model: string;
 }
+export interface AIEmployeeOptions {
+    ctx: Context;
+    employee: Model;
+    sessionId: string;
+    systemMessage?: string;
+    skillSettings?: Record<string, any>;
+    webSearch?: boolean;
+    model?: ModelRef;
+    legacy?: boolean;
+    from?: 'main-agent' | 'sub-agent';
+}
 export declare class AIEmployee {
+    sessionId: string;
+    from: string;
     employee: Model;
     aiChatConversation: AIChatConversation;
     skillSettings?: Record<string, any>;
     private plugin;
     private db;
-    private sessionId;
     private ctx;
     private systemMessage;
+    private protocol;
     private webSearch?;
     private model?;
     private legacy?;
-    private protocol;
-    constructor(ctx: Context, employee: Model, sessionId: string, systemMessage?: string, skillSettings?: Record<string, any>, webSearch?: boolean, model?: ModelRef, legacy?: boolean);
+    constructor({ ctx, employee, sessionId, systemMessage, skillSettings, webSearch, model, legacy, from, }: AIEmployeeOptions);
+    getFormatMessages(userMessages: AIMessageInput[]): Promise<{
+        role: "user" | "assistant" | "tool" | "system";
+        content: any;
+        tool_call_id?: string;
+        tool_calls?: AIToolCall[];
+    }[]>;
     private buildState;
     private initSession;
     private buildChatContext;
     stream({ messageId, userMessages, userDecisions, }: {
         messageId?: string;
         userMessages?: AIMessageInput[];
-        userDecisions?: UserDecision[];
+        userDecisions?: {
+            interruptId?: string;
+            decisions: UserDecision[];
+        };
     }): Promise<boolean>;
-    invoke({ messageId, userMessages, userDecisions, }: {
+    invoke({ messageId, userMessages, userDecisions, writer, context, }: {
         messageId?: string;
         userMessages?: AIMessageInput[];
-        userDecisions?: UserDecision[];
+        userDecisions?: {
+            interruptId?: string;
+            decisions: UserDecision[];
+        };
+        writer?: (chunk: any) => void;
+        context?: any;
     }): Promise<any>;
-    getLLMService(): Promise<{
-        provider: LLMProvider;
-        model: string;
-        service: any;
-    }>;
     createAgent({ provider, systemPrompt, tools, middleware, }: {
         provider: LLMProvider;
         systemPrompt?: string;
@@ -93,7 +114,7 @@ export declare class AIEmployee {
         name: string;
         args: any;
     }[]): Promise<Model<AIToolMessage>[]>;
-    updateToolCallInterrupted(messageId: string, toolCallId: string, interruptAction: {
+    updateToolCallInterrupted(sessionId: string, messageId: string, toolCallId: string, interruptId: string, interruptAction: {
         order: number;
         description?: string;
         allowed_decisions?: string[];
@@ -103,7 +124,6 @@ export declare class AIEmployee {
     confirmToolCall(transaction: Transaction, messageId: string, toolCallIds: string[]): Promise<number>;
     getToolCallResult(messageId: string, toolCallId: string): Promise<AIToolMessage>;
     getToolCallResultMap(messageId: string, toolCallIds: string[]): Promise<Map<string, AIToolMessage>>;
-    getUserDecisions(messageId: string): Promise<UserDecision[]>;
     cancelToolCall(): Promise<any>;
     get logger(): any;
     sendErrorResponse(errorMessage: string): void;
@@ -127,11 +147,13 @@ export declare class AIEmployee {
     private getAgentTools;
     getLoadedSkillNames(): Promise<string[]>;
     getActivatedSkillToolNames(): Promise<Set<string>>;
+    private getAvailableAIEmployees;
     private getMiddleware;
     private getCurrentThread;
     private forkCurrentThread;
     getToolsMap(): Promise<Map<string, import("@nocobase/ai").ToolsOptions>>;
     private listTools;
+    private withRunMetadata;
     private get toolsManager();
     private get aiConversationsRepo();
     private get aiMessagesRepo();
@@ -140,3 +162,55 @@ export declare class AIEmployee {
     private get aiToolMessagesModel();
     private get aiFilesModel();
 }
+export declare class ChatStreamProtocol {
+    private readonly streamConsumer;
+    private _statistics;
+    constructor(streamConsumer: StreamConsumer);
+    static fromContext(ctx: Context): ChatStreamProtocol;
+    with(conversation: {
+        sessionId: string;
+        from: string;
+        username: string;
+    }): {
+        startStream: () => void;
+        endStream: () => void;
+        subAgentCompleted: () => void;
+        newMessage: (content?: unknown) => void;
+        content: (content: string) => void;
+        webSearch: (content: {
+            type: string;
+            query: string;
+        }[]) => void;
+        reasoning: (content: {
+            status: string;
+            content: string;
+        }) => void;
+        stopReasoning: () => void;
+        toolCallChunks: (content: unknown) => void;
+        toolCalls: (content: unknown) => void;
+        toolCallStatus: ({ toolCall, invokeStatus, status, invokeStartTime, invokeEndTime, content, interruptAction, }: {
+            toolCall: {
+                messageId: string;
+                id: string;
+                name: string;
+                willInterrupt: boolean;
+            };
+            invokeStatus: string;
+            status?: string;
+            invokeStartTime?: string | Date | null;
+            invokeEndTime?: string | Date | null;
+            content?: unknown;
+            interruptAction?: {
+                order: number;
+                description: string;
+                allowedDecisions: string[];
+            };
+        }) => void;
+    };
+    get statistics(): {
+        sent: number;
+    };
+}
+export type StreamConsumer = {
+    write: (chunk: any) => void;
+};