@nocobase/plugin-ai 2.3.0-alpha.1 → 3.0.0-alpha.2

package/dist/client-v2/ai-employees/chatbox/hooks/useChatMessageActions.d.ts

@@ -7,11 +7,13 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 import { AIEmployee, Attachment, ContextItem, ResendOptions, SendOptions } from '../../types';
-export declare const useChatMessageActions: () => {
+import { type ChatBoxRuntime } from '../stores/runtime';
+export declare const useChatMessageActions: (runtime?: ChatBoxRuntime) => {
     syncContextAttachments: (items: ContextItem | ContextItem[]) => Attachment[];
     loadMessages: (sessionId?: string, cursor?: string) => Promise<void>;
     loadMoreMessages: () => Promise<void>;
-    sendMessages: ({ sessionId, aiEmployee, systemMessage, messages: sendMsgs, attachments, workContext, editingMessageId, onConversationCreate, skillSettings, webSearch, model: inputModel, }: SendOptions & {
+    sendMessages: ({ sessionId, aiEmployee, systemMessage, messages: sendMsgs, attachments, workContext, editingMessageId, onConversationCreate, skillSettings, webSearch, scope, model: inputModel, onResponseLoadingChange, }: SendOptions & {
+        scope?: string;
         onConversationCreate?: (sessionId: string) => void;
     }) => Promise<void>;
     resendMessages: ({ sessionId, messageId, aiEmployee, important }: ResendOptions) => Promise<void>;

package/dist/client-v2/ai-employees/chatbox/hooks/useToolCallActions.d.ts

@@ -7,8 +7,10 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 import { DecisionActions, ToolCall } from '@nocobase/client-v2';
-export declare const useToolCallActions: ({ messageId }: {
+import { type ChatBoxRuntime } from '../stores/runtime';
+export declare const useToolCallActions: ({ messageId, runtime }: {
     messageId: string;
+    runtime?: ChatBoxRuntime;
 }) => {
     getDecisionActions: (toolCall: ToolCall) => DecisionActions;
 };

package/dist/client-v2/ai-employees/chatbox/hooks/useUploadFiles.d.ts

@@ -7,6 +7,7 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 import type { Attachment } from '../../types';
+import { type ChatBoxRuntime } from '../stores/runtime';
 type StorageBasicInfo = {
     rules?: Record<string, unknown>;
     [key: string]: unknown;
@@ -18,6 +19,9 @@ type UploadRequestOptions = {
     filename: string;
     headers?: Record<string, string>;
     onError: (error: Error) => void;
+    onProgress?: (event: {
+        percent: number;
+    }) => void;
     onSuccess: (body: unknown, file: Blob) => void;
     withCredentials?: boolean;
 };
@@ -35,12 +39,18 @@ export declare function useStorageUploadProps(props: Record<string, unknown>, st
     rules: Record<string, unknown>;
 };
 export declare function useUploadProps(props: Record<string, unknown>): {
-    customRequest({ action, data, file, filename, headers, onError, onSuccess, withCredentials, }: UploadRequestOptions): Promise<void>;
+    customRequest({ action, data, file, filename, headers, onError, onProgress, onSuccess, withCredentials, }: UploadRequestOptions): {
+        abort(): void;
+    };
 };
-export declare const useUploadFiles: () => {
+export declare const useUploadFiles: (runtime?: ChatBoxRuntime) => {
+    beforeUpload: (file: import("antd/es/upload").RcFile, fileList: import("antd/es/upload").RcFile[]) => (string | boolean | void | File | Blob) | Promise<string | boolean | void | File | Blob>;
+    validateFiles: (files: unknown[], showMessage?: boolean) => boolean;
     rules: Record<string, unknown>;
     action: string;
     onChange({ fileList }: UploadChangeInfo): void;
-    customRequest({ action, data, file, filename, headers, onError, onSuccess, withCredentials, }: UploadRequestOptions): Promise<void>;
+    customRequest({ action, data, file, filename, headers, onError, onProgress, onSuccess, withCredentials, }: UploadRequestOptions): {
+        abort(): void;
+    };
 };
 export {};

package/dist/client-v2/ai-employees/chatbox/hooks/useWorkflowTasks.d.ts

@@ -7,7 +7,8 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 import { WorkflowTask, WorkflowTaskDetail } from '../stores/workflow-tasks';
-export declare const useWorkflowTasks: () => {
+import { type ChatBoxRuntime } from '../stores/runtime';
+export declare const useWorkflowTasks: (runtime?: ChatBoxRuntime) => {
     loading: boolean;
     workflowTasks: WorkflowTask[];
     unreadCount: number;
@@ -22,6 +23,6 @@ export declare const useWorkflowTasks: () => {
     getWorkflowTaskBySession: (sessionId: string) => Promise<WorkflowTaskDetail>;
     updateReadonly: (sessionId: string) => Promise<void>;
     currentWorkflowTask: WorkflowTaskDetail;
-    setCurrentWorkflowTask: (workflowTask: WorkflowTaskDetail | ((prev?: WorkflowTaskDetail) => WorkflowTaskDetail)) => void;
+    setCurrentWorkflowTask: (currentWorkflowTask: WorkflowTaskDetail | ((prev?: WorkflowTaskDetail) => WorkflowTaskDetail)) => void;
     setSelectedJobStatus: (selectedJobStatus: number) => void;
 };

package/dist/client-v2/ai-employees/chatbox/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * 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.
+ */
+export { Conversations } from './components/Conversations';
+export { ChatBoxUnreadBadge } from './components/ChatBoxUnreadBadge';
+export { Messages } from './components/Messages';
+export { useChat } from './hooks/useChat';
+export { useChatBoxActions } from './hooks/useChatBoxActions';
+export { useChatConversationActions } from './hooks/useChatConversationActions';
+export { useChatMessageActions } from './hooks/useChatMessageActions';
+export { registerMountedChatBox } from './stores/mounted-chat-boxes';
+export { useChatBoxRuntime } from './stores/runtime';

package/dist/client-v2/ai-employees/chatbox/roles.d.ts

@@ -6,157 +6,6 @@
  * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
-/// <reference types="react" />
 import type { AIEmployee } from '../types';
-export declare const defaultRoles: Record<string, Omit<import("@ant-design/x").BubbleProps<import("@ant-design/x/es/bubble/interface").BubbleContentType> & {
-    ref?: import("react").Ref<import("@ant-design/x/es/bubble/Bubble").BubbleRef>;
-}, "content" | "messageRender" | "loadingRender"> & {
-    nickname?: string;
-    content?: {
-        content: unknown;
-        ref?: import("react").MutableRefObject<unknown>;
-        type?: import("../types").MessageType;
-        messageId?: string;
-        attachments?: import("../types").Attachment[];
-        workContext?: import("../types").ContextItem[];
-        tool_calls?: import("../types").ToolCall<unknown>[];
-        metadata?: {
-            model: string;
-            provider: string;
-            llmService?: string;
-            usage_metadata?: {
-                input_tokens: number;
-                output_tokens: number;
-                total_tokens: number;
-            };
-            autoCallTools?: string[];
-        };
-        reference?: {
-            title: string;
-            url: string;
-        }[];
-        reasoning?: {
-            status: string;
-            content: string;
-        };
-        subAgentConversations?: {
-            sessionId: string;
-            toolCallId?: string;
-            status?: "completed" | "pending";
-            messages: import("../types").Message[];
-        }[];
-        from?: "main-agent" | "sub-agent";
-    };
-    messageRender?: (content: {
-        content: unknown;
-        ref?: import("react").MutableRefObject<unknown>;
-        type?: import("../types").MessageType;
-        messageId?: string;
-        attachments?: import("../types").Attachment[];
-        workContext?: import("../types").ContextItem[];
-        tool_calls?: import("../types").ToolCall<unknown>[];
-        metadata?: {
-            model: string;
-            provider: string;
-            llmService?: string;
-            usage_metadata?: {
-                input_tokens: number;
-                output_tokens: number;
-                total_tokens: number;
-            };
-            autoCallTools?: string[];
-        };
-        reference?: {
-            title: string;
-            url: string;
-        }[];
-        reasoning?: {
-            status: string;
-            content: string;
-        };
-        subAgentConversations?: {
-            sessionId: string;
-            toolCallId?: string;
-            status?: "completed" | "pending";
-            messages: import("../types").Message[];
-        }[];
-        from?: "main-agent" | "sub-agent";
-    }) => import("react").ReactNode;
-    loadingRender?: () => import("react").ReactNode;
-}>;
-export declare const aiEmployeeRole: (aiEmployee: AIEmployee) => Omit<import("@ant-design/x").BubbleProps<import("@ant-design/x/es/bubble/interface").BubbleContentType> & {
-    ref?: import("react").Ref<import("@ant-design/x/es/bubble/Bubble").BubbleRef>;
-}, "content" | "messageRender" | "loadingRender"> & {
-    nickname?: string;
-    content?: {
-        content: unknown;
-        ref?: import("react").MutableRefObject<unknown>;
-        type?: import("../types").MessageType;
-        messageId?: string;
-        attachments?: import("../types").Attachment[];
-        workContext?: import("../types").ContextItem[];
-        tool_calls?: import("../types").ToolCall<unknown>[];
-        metadata?: {
-            model: string;
-            provider: string;
-            llmService?: string;
-            usage_metadata?: {
-                input_tokens: number;
-                output_tokens: number;
-                total_tokens: number;
-            };
-            autoCallTools?: string[];
-        };
-        reference?: {
-            title: string;
-            url: string;
-        }[];
-        reasoning?: {
-            status: string;
-            content: string;
-        };
-        subAgentConversations?: {
-            sessionId: string;
-            toolCallId?: string;
-            status?: "completed" | "pending";
-            messages: import("../types").Message[];
-        }[];
-        from?: "main-agent" | "sub-agent";
-    };
-    messageRender?: (content: {
-        content: unknown;
-        ref?: import("react").MutableRefObject<unknown>;
-        type?: import("../types").MessageType;
-        messageId?: string;
-        attachments?: import("../types").Attachment[];
-        workContext?: import("../types").ContextItem[];
-        tool_calls?: import("../types").ToolCall<unknown>[];
-        metadata?: {
-            model: string;
-            provider: string;
-            llmService?: string;
-            usage_metadata?: {
-                input_tokens: number;
-                output_tokens: number;
-                total_tokens: number;
-            };
-            autoCallTools?: string[];
-        };
-        reference?: {
-            title: string;
-            url: string;
-        }[];
-        reasoning?: {
-            status: string;
-            content: string;
-        };
-        subAgentConversations?: {
-            sessionId: string;
-            toolCallId?: string;
-            status?: "completed" | "pending";
-            messages: import("../types").Message[];
-        }[];
-        from?: "main-agent" | "sub-agent";
-    }) => import("react").ReactNode;
-    loadingRender?: () => import("react").ReactNode;
-};
+export declare const defaultRoles: Record<string, import("./components/MessageRenderers").ChatBubbleRole>;
+export declare const aiEmployeeRole: (aiEmployee: AIEmployee) => import("./components/MessageRenderers").ChatBubbleRole;

package/dist/client-v2/ai-employees/chatbox/stores/chat-box.d.ts

@@ -7,59 +7,74 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 /// <reference types="react" />
-import type { Bubble, Sender } from '@ant-design/x';
-import type { GetProp, GetRef } from 'antd';
+import type { Sender } from '@ant-design/x';
+import type { GetRef } from 'antd';
 import type { AIEmployee } from '../../types';
-type RolesType = GetProp<typeof Bubble.List, 'roles'>;
+import type { ChatBubbleRole } from '../components/MessageRenderers';
+import type { ChatSenderModel } from './chat-sender';
+type RoleMap = Record<string, ChatBubbleRole>;
+type ChatBoxTaskVariables = {
+    variables?: Record<string, unknown>;
+    localVariables?: Record<string, unknown>;
+};
 export interface ModelRef {
     llmService: string;
     model: string;
 }
-interface ChatBoxState {
+export declare class ChatBoxModel {
+    private senderModel?;
+    legacySenderValue: string;
+    legacySenderPlaceholder: string;
+    legacyIsEditingMessage: boolean;
+    legacyEditingMessageId: string | null | undefined;
+    legacySenderRef: React.MutableRefObject<GetRef<typeof Sender> | null> | null;
+    legacyIsShowSenderHint: boolean;
     open: boolean;
     expanded: boolean;
     collapsed: boolean;
     showConversations: boolean;
     minimize: boolean;
-    currentEmployee?: AIEmployee;
-    senderValue: string;
-    senderPlaceholder: string;
-    roles: GetProp<typeof Bubble.List, 'roles'>;
-    taskVariables: {
-        variables?: Record<string, unknown>;
-        localVariables?: Record<string, unknown>;
-    };
-    isEditingMessage: boolean;
-    editingMessageId?: string;
-    chatBoxRef: React.MutableRefObject<HTMLDivElement> | null;
-    senderRef: React.MutableRefObject<GetRef<typeof Sender>> | null;
+    currentEmployee: AIEmployee | null | undefined;
+    roles: RoleMap;
+    taskVariables: ChatBoxTaskVariables;
+    chatBoxRef: React.MutableRefObject<HTMLDivElement | null> | null;
     showCodeHistory: boolean;
-    model?: ModelRef | null;
+    model: ModelRef | null | undefined;
     showDebugPanel: boolean;
     readonly: boolean;
-    isShowSenderHint: boolean;
-}
-interface ChatBoxActions {
+    constructor();
+    get senderValue(): string;
+    set senderValue(value: string);
+    get senderPlaceholder(): string;
+    set senderPlaceholder(placeholder: string);
+    get isEditingMessage(): boolean;
+    set isEditingMessage(isEditing: boolean);
+    get editingMessageId(): string | null | undefined;
+    set editingMessageId(id: string | null | undefined);
+    get senderRef(): React.MutableRefObject<GetRef<typeof Sender> | null> | null;
+    set senderRef(ref: React.MutableRefObject<GetRef<typeof Sender> | null> | null);
+    get isShowSenderHint(): boolean;
+    set isShowSenderHint(isShowSenderHint: boolean);
+    attachSenderModel: (senderModel: ChatSenderModel) => void;
     setOpen: (open: boolean) => void;
     setExpanded: (expanded: boolean) => void;
     setCollapsed: (collapsed: boolean) => void;
     setShowConversations: (show: boolean) => void;
-    setMinimize: (minus: boolean) => void;
-    setCurrentEmployee: (aiEmployee?: AIEmployee | ((prev: AIEmployee) => AIEmployee)) => void;
+    setMinimize: (minimize: boolean) => void;
+    setCurrentEmployee: (employee?: AIEmployee | ((prev: AIEmployee | null | undefined) => AIEmployee | null | undefined)) => void;
     setSenderValue: (value: string) => void;
     setSenderPlaceholder: (placeholder: string) => void;
-    setTaskVariables: (variables: ChatBoxState['taskVariables']) => void;
-    setRoles: (roles: RolesType | ((prev: RolesType) => RolesType)) => void;
-    addRole: (name: string, role: unknown) => void;
+    setTaskVariables: (variables: ChatBoxTaskVariables) => void;
+    setRoles: (roles: RoleMap | ((prev: RoleMap) => RoleMap)) => void;
+    addRole: (name: string, role: RoleMap[string]) => void;
     setIsEditingMessage: (isEditing: boolean) => void;
-    setEditingMessageId: (id?: string) => void;
-    setChatBoxRef: (ref: React.MutableRefObject<HTMLDivElement> | null) => void;
-    setSenderRef: (ref: React.MutableRefObject<GetRef<typeof Sender>> | null) => void;
+    setEditingMessageId: (id?: string | null) => void;
+    setChatBoxRef: (ref: React.MutableRefObject<HTMLDivElement | null> | null) => void;
+    setSenderRef: (ref: React.MutableRefObject<GetRef<typeof Sender> | null> | null) => void;
     setShowCodeHistory: (show: boolean) => void;
-    setModel: (model: ModelRef | null) => void;
+    setModel: (model: ModelRef | null | undefined) => void;
     setShowDebugPanel: (show: boolean) => void;
     setReadonly: (readonly: boolean) => void;
-    setShowSenderHint: (show: boolean) => void;
+    setShowSenderHint: (isShowSenderHint: boolean) => void;
 }
-export declare const useChatBoxStore: import("./create-selectors").ObservableStore<ChatBoxState & ChatBoxActions>;
 export {};

package/dist/client-v2/ai-employees/chatbox/stores/chat-conversations.d.ts

@@ -7,22 +7,22 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 import type { Conversation } from '../../types';
-interface ChatConversationsState {
-    currentConversation?: string;
+type ChatConversationStateUpdater<T> = T | ((prev: T) => T);
+export declare class ChatConversationModel {
+    currentConversation: string | undefined;
     conversations: Conversation[];
     keyword: string;
     webSearch: boolean;
     conversationSegmented: string;
     unreadCount: number;
-}
-interface ChatConversationsActions {
+    constructor();
     setCurrentConversation: (id: string | undefined) => void;
     setKeyword: (keyword: string) => void;
-    setConversations: (conversations: Conversation[] | ((prev: Conversation[]) => Conversation[])) => void;
+    setConversations: (conversations: ChatConversationStateUpdater<Conversation[]>) => void;
+    setConversationRead: (sessionId: string, read: boolean) => void;
     markConversationRead: (sessionId: string) => void;
     setWebSearch: (webSearch: boolean) => void;
     setConversationSegmented: (conversationSegmented: string) => void;
-    setUnreadCount: (unreadCount: number | ((prev: number) => number)) => void;
+    setUnreadCount: (unreadCount: ChatConversationStateUpdater<number>) => void;
 }
-export declare const useChatConversationsStore: import("./create-selectors").ObservableStore<ChatConversationsState & ChatConversationsActions>;
 export {};

package/dist/client-v2/ai-employees/chatbox/stores/chat-messages.d.ts

@@ -21,38 +21,44 @@ export type ChatSessionState = {
     contextItems: ContextItem[];
     systemMessage: string;
     responseLoading: boolean;
-    abortController?: AbortController;
-    skillSettings?: SkillSettings;
-    webSearching?: WebSearching;
+    abortController?: AbortController | null;
+    skillSettings?: SkillSettings | null;
+    webSearching?: WebSearching | null;
     backgroundWorking: boolean;
     resumeStreamFailed: boolean;
 };
 export declare const CHAT_EMPTY_SESSION_STATE: ChatSessionState;
-type ChatMessagesState = {
-    sessions: Record<string, ChatSessionState>;
-    editorRef?: Record<string, ChatEditorRef | null>;
-    currentEditorRefUid?: string;
-    flowContext?: unknown;
-};
 type SessionStateUpdater<T> = T | ((prev: T) => T);
-export interface ChatMessagesActions {
+export declare class ChatMessageModel {
+    sessions: Record<string, ChatSessionState>;
+    editorRef: Record<string, ChatEditorRef | null>;
+    currentEditorRefUid: string | null | undefined;
+    flowContext: unknown;
+    constructor();
+    private resolveSessionState;
+    private ensureSessionState;
+    private updateSessionState;
     setEditorRef: (uid: string, editorRef: ChatEditorRef | null) => void;
-    setCurrentEditorRefUid: (uid: string) => void;
-    setFlowContext: (ctx: unknown) => void;
+    unregisterEditorRef: (uid: string, editorRef: ChatEditorRef) => void;
+    setCurrentEditorRefUid: (uid: string | null | undefined) => void;
+    setFlowContext: (flowContext: unknown) => void;
     getSessionState: (sessionId?: string) => ChatSessionState;
     resetSessionState: (sessionId?: string, patch?: Partial<ChatSessionState>) => void;
     migrateSessionState: (fromSessionId: string | undefined, toSessionId: string) => void;
     setSessionMessages: (sessionId: string | undefined, messages: SessionStateUpdater<Message[]>) => void;
     setSessionMessagesLoading: (sessionId: string | undefined, loading: boolean) => void;
     setSessionMessagesError: (sessionId: string | undefined, error: unknown) => void;
-    setSessionMessagesMeta: (sessionId: string | undefined, meta: ChatSessionState['messagesMeta'] | ((prev: ChatSessionState['messagesMeta']) => ChatSessionState['messagesMeta'])) => void;
+    setSessionMessagesMeta: (sessionId: string | undefined, meta: {
+        cursor?: string;
+        hasMore?: boolean;
+    } | ((prev: ChatSessionState['messagesMeta']) => ChatSessionState['messagesMeta'])) => void;
     setSessionAttachments: (sessionId: string | undefined, attachments: SessionStateUpdater<Attachment[]>) => void;
     setSessionContextItems: (sessionId: string | undefined, items: SessionStateUpdater<ContextItem[]>) => void;
     setSessionSystemMessage: (sessionId: string | undefined, msg: string | ((prev: string) => string)) => void;
     setSessionResponseLoading: (sessionId: string | undefined, loading: boolean) => void;
     setSessionBackgroundWorking: (sessionId: string | undefined, backgroundWorking: boolean) => void;
     setSessionResumeStreamFailed: (sessionId: string | undefined, resumeStreamFailed: boolean) => void;
-    addSessionMessage: (sessionId: string | undefined, msg: Message) => void;
+    addSessionMessage: (sessionId: string | undefined, message: Message) => void;
     addSessionMessages: (sessionId: string | undefined, msgs: Message[]) => void;
     updateSessionLastMessage: (sessionId: string | undefined, updater: (msg: Message) => Message) => void;
     removeSessionMessage: (sessionId: string | undefined, key: string) => void;
@@ -61,13 +67,12 @@ export interface ChatMessagesActions {
     addSessionContextItems: (sessionId: string | undefined, items: ContextItem | ContextItem[]) => void;
     addContextItems: (items: ContextItem | ContextItem[]) => void;
     removeSessionContextItem: (sessionId: string | undefined, type: string, uid: string) => void;
-    setSessionAbortController: (sessionId: string | undefined, controller: AbortController | undefined) => void;
-    setSessionSkillSettings: (sessionId: string | undefined, settings: SkillSettings | undefined) => void;
-    setSessionWebSearching: (sessionId: string | undefined, webSearching: WebSearching) => void;
+    setSessionAbortController: (sessionId: string | undefined, controller: AbortController | undefined | null) => void;
+    setSessionSkillSettings: (sessionId: string | undefined, settings: SkillSettings | undefined | null) => void;
+    setSessionWebSearching: (sessionId: string | undefined, webSearching: WebSearching | null | undefined) => void;
     addSessionSubAgentMessage: (sessionId: string | undefined, subSessionId: string, msg: Message) => void;
     addSessionSubAgentMessages: (sessionId: string | undefined, subSessionId: string, msgs: Message[]) => void;
     updateSessionLastSubAgentMessage: (sessionId: string | undefined, subSessionId: string, username: string, updater: (msg: Message) => Message) => void;
     updateSessionSubAgentConversationStatus: (sessionId: string | undefined, subSessionId: string, status: 'pending' | 'completed') => void;
 }
-export declare const useChatMessagesStore: import("./create-selectors").ObservableStore<ChatMessagesState & ChatMessagesActions>;
 export {};

package/dist/client-v2/ai-employees/chatbox/stores/chat-sender.d.ts

@@ -0,0 +1,43 @@
+/**
+ * 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.
+ */
+/// <reference types="react" />
+import type { Sender } from '@ant-design/x';
+import type { GetRef } from 'antd';
+import type { Attachment, ContextItem, SkillSettings } from '../../types';
+export type ChatSenderRef = React.MutableRefObject<GetRef<typeof Sender> | null>;
+type ChatSenderStateUpdater<T> = T | ((prev: T) => T);
+export declare class ChatSenderModel {
+    senderValue: string;
+    senderPlaceholder: string;
+    senderRef: ChatSenderRef | null;
+    isShowSenderHint: boolean;
+    isEditingMessage: boolean;
+    editingMessageId: string | null | undefined;
+    attachments: Attachment[];
+    contextItems: ContextItem[];
+    systemMessage: string;
+    skillSettings: SkillSettings | null | undefined;
+    constructor();
+    setSenderValue: (value: string) => void;
+    setSenderPlaceholder: (placeholder: string) => void;
+    setSenderRef: (ref: ChatSenderRef | null) => void;
+    setShowSenderHint: (isShowSenderHint: boolean) => void;
+    setIsEditingMessage: (isEditing: boolean) => void;
+    setEditingMessageId: (id?: string | null) => void;
+    setAttachments: (attachments: ChatSenderStateUpdater<Attachment[]>) => void;
+    addAttachments: (attachments: Attachment | Attachment[]) => void;
+    removeAttachment: (filename: string) => void;
+    setContextItems: (items: ChatSenderStateUpdater<ContextItem[]>) => void;
+    addContextItems: (items: ContextItem | ContextItem[]) => void;
+    removeContextItem: (type: string, uid: string) => void;
+    setSystemMessage: (msg: string | ((prev: string) => string)) => void;
+    setSkillSettings: (settings: SkillSettings | null | undefined) => void;
+    reset: () => void;
+}
+export {};

package/dist/client-v2/ai-employees/chatbox/stores/chat-tool-call.d.ts

@@ -14,17 +14,18 @@ export type ChatToolCallSessionState = {
     toolCalls: Record<string, ToolCallInvokeState[]>;
 };
 export declare const CHAT_EMPTY_TOOL_CALL_SESSION_STATE: ChatToolCallSessionState;
-type ChatToolCallState = {
+export declare class ChatToolCallModel {
     sessions: Record<string, ChatToolCallSessionState>;
-};
-export interface ChatToolCallActions {
+    constructor();
+    private resolveSessionState;
+    private ensureSessionState;
+    private updateSessionState;
     getSessionState: (sessionId: string) => ChatToolCallSessionState;
     resetSessionState: (sessionId: string) => void;
     migrateSessionState: (fromSessionId: string, toSessionId: string) => void;
     updateToolCallInvokeStatus: (sessionId: string, messageId: string, toolCallId: string, invokeStatus: string) => void;
     isAllWaiting: (sessionId: string, messageId: string) => boolean;
     isInterrupted: (sessionId: string, messageId: string, toolCallId: string) => boolean;
-    getInvokeStatus: (sessionId: string, messageId: string, toolCallId: string) => string | undefined;
+    getInvokeStatus: (sessionId: string, messageId: string, toolCallId: string) => string;
 }
-export declare const useChatToolCallStore: import("./create-selectors").ObservableStore<ChatToolCallState & ChatToolCallActions>;
 export {};

package/dist/client-v2/ai-employees/chatbox/stores/chat-tools.d.ts

@@ -7,7 +7,7 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 import type { Message, ToolCall } from '../../types';
-interface ChatToolsState {
+type ChatToolsState = {
     toolsByName: Record<string, (ToolCall<unknown> & {
         messageId?: string;
     })[]>;
@@ -18,13 +18,19 @@ interface ChatToolsState {
     activeTool?: ToolCall<unknown>;
     activeMessageId?: string;
     adjustArgs?: Record<string, unknown>;
-}
-interface ChatToolsActions {
+};
+export declare class ChatToolModel {
+    toolsByName: ChatToolsState['toolsByName'];
+    toolsByMessageId: ChatToolsState['toolsByMessageId'];
+    openToolModal: boolean;
+    activeTool: ToolCall<unknown> | null | undefined;
+    activeMessageId: string;
+    adjustArgs: Record<string, unknown>;
+    constructor();
     updateTools: (messages: Message[]) => void;
     setOpenToolModal: (open: boolean) => void;
-    setActiveTool: (tool: ToolCall<unknown>) => void;
+    setActiveTool: (tool: ToolCall<unknown> | null | undefined) => void;
     setActiveMessageId: (messageId: string) => void;
     setAdjustArgs: (args: Record<string, unknown>) => void;
 }
-export declare const useChatToolsStore: import("./create-selectors").ObservableStore<ChatToolsState & ChatToolsActions>;
 export {};

package/dist/client-v2/ai-employees/chatbox/stores/mounted-chat-boxes.d.ts

@@ -0,0 +1,20 @@
+/**
+ * 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.
+ */
+import type { ClearOptions, ContextItem, TriggerTaskOptions } from '../../types';
+import type { ChatBoxRuntime } from './runtime';
+export type MountedChatBoxEntry = {
+    uid: string;
+    runtime: ChatBoxRuntime;
+    triggerTask: (options: TriggerTaskOptions) => Promise<void>;
+    clear: (options?: ClearOptions, sessionId?: string | undefined) => void;
+    syncContextItems: (items: ContextItem[]) => void;
+};
+export declare const registerMountedChatBox: (entry: MountedChatBoxEntry) => () => void;
+export declare const getMountedChatBox: (uid: string) => MountedChatBoxEntry;
+export declare const clearMountedChatBoxes: () => void;

package/dist/client-v2/ai-employees/chatbox/stores/runtime.d.ts

@@ -0,0 +1,43 @@
+/**
+ * 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.
+ */
+import React from 'react';
+import { ChatBoxModel } from './chat-box';
+import { ChatConversationModel } from './chat-conversations';
+import { ChatMessageModel } from './chat-messages';
+import { ChatSenderModel } from './chat-sender';
+import { ChatToolCallModel } from './chat-tool-call';
+import { ChatToolModel } from './chat-tools';
+import { WorkflowTaskModel } from './workflow-tasks';
+export type ChatBoxRuntimeMode = 'global' | 'block';
+export type ChatBoxScopeOperation = 'list' | 'create';
+export type ChatBoxScopeResolverOptions = {
+    operation?: ChatBoxScopeOperation;
+};
+export type ChatBoxScopeResolver = (options?: ChatBoxScopeResolverOptions) => Promise<string | undefined>;
+export type ChatBoxRuntime = {
+    mode: ChatBoxRuntimeMode;
+    getScope?: ChatBoxScopeResolver;
+    chatBoxModel: ChatBoxModel;
+    chatSenderModel: ChatSenderModel;
+    chatConversationModel: ChatConversationModel;
+    chatMessageModel: ChatMessageModel;
+    chatToolCallModel: ChatToolCallModel;
+    chatToolModel: ChatToolModel;
+    workflowTaskModel: WorkflowTaskModel;
+};
+export declare const createChatBoxRuntime: (runtime?: Partial<ChatBoxRuntime>) => ChatBoxRuntime;
+export declare const getGlobalChatBoxRuntime: () => ChatBoxRuntime;
+export declare const ChatBoxContext: React.Context<ChatBoxRuntime>;
+export declare const ChatBoxRuntimeProvider: React.FC<{
+    runtime: ChatBoxRuntime;
+    children?: React.ReactNode;
+}>;
+export declare const useChatBoxRuntime: () => ChatBoxRuntime;
+export declare const useResolvedChatBoxRuntime: (runtime?: ChatBoxRuntime) => ChatBoxRuntime;
+export declare const resolveChatBoxScope: (runtime: ChatBoxRuntime, options?: ChatBoxScopeResolverOptions) => Promise<string>;