@nocobase/plugin-ai 2.1.0-alpha.12 → 2.1.0-alpha.14

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,32 +18,58 @@ 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;
@@ -93,7 +119,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 +129,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 +152,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 +167,52 @@ 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, interruptAction, }: {
+            toolCall: {
+                messageId: string;
+                id: string;
+                name: string;
+                willInterrupt: boolean;
+            };
+            invokeStatus: string;
+            status?: string;
+            interruptAction?: {
+                order: number;
+                description: string;
+                allowedDecisions: string[];
+            };
+        }) => void;
+    };
+    get statistics(): {
+        sent: number;
+    };
+}
+export type StreamConsumer = {
+    write: (chunk: any) => void;
+};