@nocobase/plugin-ai 2.2.0-alpha.7 → 2.2.0-beta.10

package/dist/{client-v2 → client}/workflow/triggers/ai-employee/Parameters.d.ts

@@ -7,5 +7,7 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 import React from 'react';
-export declare function Parameters(): React.JSX.Element;
-export default Parameters;
+export declare const Parameter: React.FC;
+export declare const ParameterAddition: React.FC;
+export declare const EditParameter: React.FC;
+export declare const ParameterDesc: React.FC;

package/dist/client/workflow/triggers/ai-employee/index.d.ts

@@ -6,6 +6,87 @@
  * 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 V2AIEmployeeTrigger from '../../../../client-v2/workflow/triggers/ai-employee';
-export declare class AIEmployeeTrigger extends V2AIEmployeeTrigger {
+/// <reference types="react" />
+import { Trigger } from '@nocobase/plugin-workflow/client';
+export declare class AIEmployeeTrigger extends Trigger {
+    sync: boolean;
+    title: any;
+    description: any;
+    components: {
+        ArrayItems: import("@formily/reactive-react").ReactFC<import("react").HTMLAttributes<HTMLDivElement>> & import("@formily/antd-v5").ArrayBaseMixins & {
+            Item: import("@formily/reactive-react").ReactFC<import("react").HTMLAttributes<HTMLDivElement> & {
+                type?: "card" | "divide";
+            }>;
+        };
+        Parameter: import("react").FC<{}>;
+        ParameterAddition: import("react").FC<{}>;
+        EditParameter: import("react").FC<{}>;
+        ParameterDesc: import("react").FC<{}>;
+    };
+    fieldset: {
+        parameters: {
+            type: string;
+            'x-decorator': string;
+            'x-component': string;
+            title: any;
+            description: any;
+            required: boolean;
+            items: {
+                type: string;
+                'x-decorator': string;
+                properties: {
+                    left: {
+                        type: string;
+                        'x-component': string;
+                        properties: {
+                            sort: {
+                                type: string;
+                                'x-decorator': string;
+                                'x-component': string;
+                            };
+                            parameters: {
+                                type: string;
+                                'x-component': string;
+                                'x-component-props': {
+                                    style: {
+                                        width: string;
+                                    };
+                                };
+                            };
+                        };
+                    };
+                    right: {
+                        type: string;
+                        'x-component': string;
+                        properties: {
+                            desc: {
+                                type: string;
+                                'x-component': string;
+                            };
+                            edit: {
+                                type: string;
+                                'x-component': string;
+                            };
+                            remove: {
+                                type: string;
+                                'x-component': string;
+                                'x-component-props': {
+                                    style: {
+                                        padding: string;
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+            properties: {
+                add: {
+                    type: string;
+                    'x-component': string;
+                };
+            };
+        };
+    };
+    useVariables(config: any, options: any): any;
 }

package/dist/client-v2/ai-employees/AIEmployeeShortcut.d.ts

@@ -7,22 +7,15 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 import React from 'react';
-import type { AIEmployee, ContextItem, Task } from './types';
-type ShortcutAIEmployee = Pick<AIEmployee, 'username'> & Partial<AIEmployee>;
-type ShortcutContext = {
-    workContext?: ContextItem[];
-};
+import type { AIEmployee, Task } from './types';
 export declare const AIEmployeeShortcut: React.FC<{
-    aiEmployee: ShortcutAIEmployee;
+    aiEmployee: AIEmployee;
     tasks?: Task[];
     size?: number;
     mask?: boolean;
     showNotice?: boolean;
-    context?: ShortcutContext;
-    auto?: boolean;
     onClick?: () => void;
     onTaskClick?: (task: Task) => void;
     taskLoadingTitle?: string;
     loadingTaskTitle?: string;
 }>;
-export {};

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

@@ -6,10 +6,9 @@
  * 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 { AIEmployee, ClearOptions, SendOptions, TriggerTaskOptions } from '../../types';
+import type { AIEmployee, ClearOptions, TriggerTaskOptions } from '../../types';
 export declare const useChatBoxActions: () => {
-    clear: (options?: ClearOptions, sessionId?: string | undefined) => void;
-    send: (options: SendOptions) => void;
+    clear: (options?: ClearOptions) => void;
     startNewConversation: () => void;
     switchAIEmployee: (aiEmployee: AIEmployee, options?: {
         clear?: ClearOptions;

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

@@ -61,5 +61,53 @@ interface ChatBoxActions {
     setReadonly: (readonly: boolean) => void;
     setShowSenderHint: (show: boolean) => void;
 }
-export declare const useChatBoxStore: import("./create-selectors").ObservableStore<ChatBoxState & ChatBoxActions>;
+export declare const useChatBoxStore: {
+    (): ChatBoxState & ChatBoxActions;
+    <U>(selector: (state: ChatBoxState & ChatBoxActions) => U): U;
+} & import("zustand").StoreApi<ChatBoxState & ChatBoxActions> & {
+    use: {
+        open: () => boolean;
+        expanded: () => boolean;
+        collapsed: () => boolean;
+        showConversations: () => boolean;
+        minimize: () => boolean;
+        currentEmployee?: () => AIEmployee;
+        senderValue: () => string;
+        senderPlaceholder: () => string;
+        roles: () => GetProp<import("react").ForwardRefExoticComponent<import("@ant-design/x/es/bubble/BubbleList").BubbleListProps & import("react").RefAttributes<import("@ant-design/x/es/bubble/BubbleList").BubbleListRef>>, "roles">;
+        taskVariables: () => {
+            variables?: Record<string, unknown>;
+            localVariables?: Record<string, unknown>;
+        };
+        isEditingMessage: () => boolean;
+        editingMessageId?: () => string;
+        chatBoxRef: () => import("react").MutableRefObject<HTMLDivElement>;
+        senderRef: () => import("react").MutableRefObject<import("@ant-design/x/es/sender").SenderRef>;
+        showCodeHistory: () => boolean;
+        model?: () => ModelRef;
+        showDebugPanel: () => boolean;
+        readonly: () => boolean;
+        isShowSenderHint: () => boolean;
+        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;
+        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;
+        setIsEditingMessage: () => (isEditing: boolean) => void;
+        setEditingMessageId: () => (id?: string) => void;
+        setChatBoxRef: () => (ref: React.MutableRefObject<HTMLDivElement> | null) => void;
+        setSenderRef: () => (ref: React.MutableRefObject<GetRef<typeof Sender>> | null) => void;
+        setShowCodeHistory: () => (show: boolean) => void;
+        setModel: () => (model: ModelRef | null) => void;
+        setShowDebugPanel: () => (show: boolean) => void;
+        setReadonly: () => (readonly: boolean) => void;
+        setShowSenderHint: () => (show: boolean) => void;
+    };
+};
 export {};

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

@@ -19,10 +19,27 @@ interface ChatConversationsActions {
     setCurrentConversation: (id: string | undefined) => void;
     setKeyword: (keyword: string) => void;
     setConversations: (conversations: Conversation[] | ((prev: Conversation[]) => Conversation[])) => void;
-    markConversationRead: (sessionId: string) => void;
     setWebSearch: (webSearch: boolean) => void;
     setConversationSegmented: (conversationSegmented: string) => void;
     setUnreadCount: (unreadCount: number | ((prev: number) => number)) => void;
 }
-export declare const useChatConversationsStore: import("./create-selectors").ObservableStore<ChatConversationsState & ChatConversationsActions>;
+export declare const useChatConversationsStore: {
+    (): ChatConversationsState & ChatConversationsActions;
+    <U>(selector: (state: ChatConversationsState & ChatConversationsActions) => U): U;
+} & import("zustand").StoreApi<ChatConversationsState & ChatConversationsActions> & {
+    use: {
+        currentConversation?: () => string;
+        conversations: () => Conversation[];
+        keyword: () => string;
+        webSearch: () => boolean;
+        conversationSegmented: () => string;
+        unreadCount: () => number;
+        setCurrentConversation: () => (id: string | undefined) => void;
+        setKeyword: () => (keyword: string) => void;
+        setConversations: () => (conversations: Conversation[] | ((prev: Conversation[]) => Conversation[])) => void;
+        setWebSearch: () => (webSearch: boolean) => void;
+        setConversationSegmented: () => (conversationSegmented: string) => void;
+        setUnreadCount: () => (unreadCount: number | ((prev: number) => number)) => void;
+    };
+};
 export {};

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

@@ -69,5 +69,50 @@ export interface ChatMessagesActions {
     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 declare const useChatMessagesStore: {
+    (): ChatMessagesState & ChatMessagesActions;
+    <U>(selector: (state: ChatMessagesState & ChatMessagesActions) => U): U;
+} & import("zustand").StoreApi<ChatMessagesState & ChatMessagesActions> & {
+    use: {
+        sessions: () => Record<string, ChatSessionState>;
+        editorRef?: () => Record<string, ChatEditorRef>;
+        currentEditorRefUid?: () => string;
+        flowContext?: () => unknown;
+        setEditorRef: () => (uid: string, editorRef: ChatEditorRef | null) => void;
+        setCurrentEditorRefUid: () => (uid: string) => void;
+        setFlowContext: () => (ctx: 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: {
+            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;
+        addSessionMessages: () => (sessionId: string | undefined, msgs: Message[]) => void;
+        updateSessionLastMessage: () => (sessionId: string | undefined, updater: (msg: Message) => Message) => void;
+        removeSessionMessage: () => (sessionId: string | undefined, key: string) => void;
+        addSessionAttachments: () => (sessionId: string | undefined, attachments: Attachment | Attachment[]) => void;
+        removeSessionAttachment: () => (sessionId: string | undefined, filename: string) => void;
+        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;
+        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 {};

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

@@ -6,41 +6,13 @@
  * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
-type StateListener<TState extends object> = (state: TState, previousState: TState) => void;
-type SelectorListener<TSelected> = (selectedState: TSelected, previousSelectedState: TSelected) => void;
-type StoreUpdater<TState extends object> = Partial<TState> | TState | ((state: TState) => Partial<TState> | TState);
-type StoreSetState<TState extends object> = (partial: StoreUpdater<TState>, replace?: boolean) => void;
-type StoreGetState<TState extends object> = () => TState;
-type StoreSubscribe<TState extends object> = {
-    (listener: StateListener<TState>): () => void;
-    <TSelected>(selector: (state: TState) => TSelected, listener: SelectorListener<TSelected>, options?: {
-        equalityFn?: (left: TSelected, right: TSelected) => boolean;
-        fireImmediately?: boolean;
-    }): () => void;
-};
-export type ObservableStoreInitializer<TState extends object> = (set: StoreSetState<TState>, get: StoreGetState<TState>) => TState;
-export type ObservableStore<TState extends object> = {
-    <TSelected = TState>(selector?: (state: TState) => TSelected): TSelected;
-    getState: StoreGetState<TState>;
-    setState: StoreSetState<TState>;
-    subscribe: StoreSubscribe<TState>;
-    destroy: () => void;
-    use: {
-        [K in keyof TState]: () => TState[K];
-    };
-};
+import type { StoreApi, UseBoundStore } from 'zustand';
 type WithSelectors<S> = S extends {
-    getState: () => infer T extends object;
+    getState: () => infer T;
 } ? S & {
     use: {
         [K in keyof T]: () => T[K];
     };
 } : never;
-type SelectableStore<TState extends object> = {
-    <TSelected>(selector: (state: TState) => TSelected): TSelected;
-    getState: () => TState;
-    use?: Record<string, () => unknown>;
-};
-export declare const createObservableStore: <TState extends object>(initializer: ObservableStoreInitializer<TState>) => ObservableStore<TState>;
-export declare const createSelectors: <TState extends object, S extends SelectableStore<TState>>(_store: S) => WithSelectors<S>;
+export declare const createSelectors: <S extends UseBoundStore<StoreApi<object>>>(_store: S) => WithSelectors<S>;
 export {};

package/dist/client-v2/ai-employees/types.d.ts

@@ -6,15 +6,8 @@
  * 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 { BubbleProps } from '@ant-design/x';
-import type { ComponentType } from 'react';
-import type { Application } from '@nocobase/client-v2';
-import type { FlowEngineContext } from '@nocobase/flow-engine';
-export type Selector = {
-    onSelect: (options: {
-        uid: string;
-    }) => void;
-};
 export type AIEmployee = {
     username: string;
     nickname?: string;
@@ -70,7 +63,7 @@ export type Conversation = {
             llmService?: string;
             model?: string;
         };
-        [key: string]: unknown;
+        [key: string]: any;
     };
 };
 export type ContextItem = {
@@ -79,47 +72,6 @@ export type ContextItem = {
     title?: string;
     content?: unknown;
 };
-type ActionParams = {
-    item: ContextItem;
-    message: Message;
-    value?: string;
-};
-export type ActionOptions = {
-    icon?: React.ReactNode;
-    title?: React.ReactNode;
-    Component?: ComponentType<ActionParams>;
-    onClick?: (params: ActionParams) => void;
-    responseType: 'text' | string;
-};
-export type WorkContextOptions = {
-    name?: string;
-    menu?: {
-        icon?: React.ReactNode;
-        label?: React.ReactNode;
-        Component?: ComponentType<{
-            onAdd?: (item: Omit<ContextItem, 'type'>) => void;
-        }>;
-        onClick?: (props: {
-            ctx: FlowEngineContext;
-            contextItems?: ContextItem[];
-            onAdd: (item: Omit<ContextItem, 'type'>) => void;
-            onRemove: (uid: string) => void;
-        }) => void;
-    };
-    tag?: {
-        Component: ComponentType<{
-            item: ContextItem;
-        }>;
-    };
-    chatbox?: {
-        Component: ComponentType<{
-            item: ContextItem;
-        }>;
-    };
-    actions?: ActionOptions[];
-    children?: Record<string, Omit<WorkContextOptions, 'children'>>;
-    getContent?: (app: Application, item: ContextItem) => Promise<unknown>;
-};
 export type ToolCall<T = unknown> = {
     id: string;
     type: string;
@@ -128,29 +80,17 @@ export type ToolCall<T = unknown> = {
     invokeStatus: 'init' | 'interrupted' | 'waiting' | 'pending' | 'done' | 'confirmed';
     auto: boolean;
     args: T;
-    willInterrupt?: boolean;
-    messageId?: string;
-    content?: unknown;
-    invokeStartTime?: unknown;
-    invokeEndTime?: unknown;
-    [key: string]: unknown;
-};
-export type Attachment = {
-    filename?: string;
-    status?: string;
-    response?: {
-        data?: Attachment;
-    };
-    [key: string]: unknown;
+    [key: string]: any;
 };
+export type Attachment = any;
 export type MessageType = 'text' | 'greeting';
 export type Message = Omit<BubbleProps, 'content'> & {
     key?: string | number;
     role?: string;
     createdAt?: string | Date;
     content: {
-        content: unknown;
-        ref?: React.MutableRefObject<unknown>;
+        content: any;
+        ref?: React.MutableRefObject<any>;
         type?: MessageType;
         messageId?: string;
         attachments?: Attachment[];
@@ -187,7 +127,7 @@ export type Message = Omit<BubbleProps, 'content'> & {
 export type TaskMessage = {
     user?: string;
     system?: string;
-    attachments?: (Attachment | Attachment[])[];
+    attachments?: Attachment[];
     workContext?: ContextItem[];
 };
 export type Task = {
@@ -205,31 +145,6 @@ export type TriggerTaskOptions = {
     aiEmployee?: AIEmployee;
     tasks?: Task[];
     auto?: boolean;
-    open?: boolean;
-};
-export type SendOptions = {
-    sessionId?: string;
-    aiEmployee?: AIEmployee;
-    systemMessage?: string;
-    messages: {
-        type: MessageType;
-        content: string;
-    }[];
-    attachments?: Attachment[];
-    workContext: ContextItem[];
-    editingMessageId?: string;
-    skillSettings?: SkillSettings;
-    webSearch?: boolean;
-    model?: {
-        llmService: string;
-        model: string;
-    } | null;
-};
-export type ResendOptions = {
-    sessionId: string;
-    messageId?: string;
-    aiEmployee: AIEmployee;
-    important?: string;
 };
 export type ClearOptions = {
     sender?: boolean;
@@ -246,14 +161,6 @@ export type WebSearching = {
     type: string;
     query: string;
 };
-export type UserDecision = {
-    type: 'approve' | 'edit' | 'reject';
-    message?: string;
-    editedAction?: {
-        name: string;
-        args: unknown;
-    };
-};
 export interface ChatEditorRef {
     write(document: string): void;
     read(): string;
@@ -262,4 +169,3 @@ export interface ChatEditorRef {
     snippetEntries: unknown[];
     logs: unknown[];
 }
-export {};

package/dist/client-v2/index.d.ts

@@ -6,20 +6,20 @@
  * 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 { default, PluginAIClientV2 } from './plugin';
+import { Plugin } from '@nocobase/client-v2';
+import { AIPluginFeatureManagerImpl } from './manager/ai-feature-manager';
+export declare class PluginAIClientV2 extends Plugin {
+    features: AIPluginFeatureManagerImpl;
+    load(): Promise<void>;
+}
+export default PluginAIClientV2;
 export { AIEmployeeProfileCard } from './ai-employees/ProfileCard';
 export { AIEmployeeShortcut } from './ai-employees/AIEmployeeShortcut';
-export { AddContextButton } from './ai-employees/AddContextButton';
-export { AISelection } from './ai-employees/AISelection';
-export { AISelectionControl } from './ai-employees/AISelectionControl';
 export { avatars, avatarsMap } from './ai-employees/avatars';
 export type { AIEmployee, Attachment, ChatEditorRef, ContextItem, Conversation, Message, SkillSettings, Task, TriggerTaskOptions, WebSearching, } from './ai-employees/types';
 export { formatModelLabel } from './llm-services/model-label';
-export { createModelSettingsForm, ModelSelect, OptionsFields, type OptionField } from './llm-providers/forms';
-export { AIConfigRepository, type LLMServiceItem } from './repositories/AIConfigRepository';
+export { AIConfigRepository } from './repositories/AIConfigRepository';
 export { AIPluginFeatureManagerImpl } from './manager/ai-feature-manager';
-export { AIManager } from './manager/ai-manager';
-export type { LLMProviderOptions, ToolModalProps, ToolOptions } from './manager/ai-manager';
 export * from './features';
 export { defaultVectorStorePropForm } from './features/components';
 export { useAIConfigRepository } from './repositories/hooks/useAIConfigRepository';
@@ -27,4 +27,3 @@ export { useChatMessagesStore } from './ai-employees/chatbox/stores/chat-message
 export { useChatBoxStore } from './ai-employees/chatbox/stores/chat-box';
 export { useChatConversationsStore } from './ai-employees/chatbox/stores/chat-conversations';
 export { useChatBoxActions } from './ai-employees/chatbox/hooks/useChatBoxActions';
-export { ChatBox, ChatBoxLayout, ChatButton, AIEmployeeSwitcher, ModelSwitcher, } from './ai-employees/chatbox/components';