@xpert-ai/contracts 3.9.0-beta.1

package/src/ai/xpert.model.d.ts

@@ -0,0 +1,513 @@
+import { ToolCall as LToolCall } from '@langchain/core/messages/tool';
+import { RunnableToolLike } from '@langchain/core/runnables';
+import { StructuredToolInterface } from '@langchain/core/tools';
+import { ITag } from '../tag-entity.model';
+import { IUser, LanguagesEnum } from '../user.model';
+import { IUserGroup } from '../user-group.model';
+import { ICopilotModel, TCopilotModel } from './copilot-model.model';
+import { IKnowledgebase, TKBRecallParams } from './knowledgebase.model';
+import { ChecklistItem, I18nObject, IPoint, ISize, TAvatar } from '../types';
+import { IXpertAgent } from './xpert-agent.model';
+import { IXpertToolset } from './xpert-toolset.model';
+import { IBasePerWorkspaceEntityModel } from './xpert-workspace.model';
+import { IIntegration } from '../integration.model';
+import { TChatFrom } from './chat.model';
+import { IWorkflowNode, TVariableAssigner, TWFCase, VariableOperationEnum } from './xpert-workflow.model';
+import { IEnvironment } from './environment.model';
+export type ToolCall = LToolCall;
+export declare enum XpertTypeEnum {
+    /**
+     * Chat Agents
+     */
+    Agent = "agent",
+    /**
+     * @deprecated use Chatkit with agent instead.
+     */
+    Copilot = "copilot",
+    /**
+     * Knowledge Workflow
+     */
+    Knowledge = "knowledge"
+}
+export type TXpertSandboxFeature = {
+    enabled: boolean;
+    provider?: string;
+};
+export type TXpertFeatures = {
+    opener: {
+        enabled: boolean;
+        message: string;
+        questions: string[];
+    };
+    suggestion: {
+        enabled: boolean;
+        prompt: string;
+    };
+    textToSpeech: {
+        enabled: boolean;
+        copilotModel?: TCopilotModel;
+    };
+    speechToText: {
+        enabled: boolean;
+        copilotModel?: TCopilotModel;
+    };
+    /**
+     * File upload feature
+     */
+    attachment?: TXpertAttachment;
+    /**
+     * Reply with memory(Q&A)
+     */
+    memoryReply?: {
+        enabled: boolean;
+        scoreThreshold?: number;
+    };
+    /**
+     * Sandbox feature
+     */
+    sandbox?: TXpertSandboxFeature;
+};
+export type TXpertFeatureKey = keyof TXpertFeatures;
+export type TXpert = {
+    /**
+     * Unique slug identifier, generated from name
+     */
+    slug: string;
+    /**
+     * Expert name
+     */
+    name: string;
+    /**
+     * Expert type
+     */
+    type: XpertTypeEnum;
+    title?: string;
+    /**
+     * @deprecated use title
+     */
+    titleCN?: string;
+    /**
+     * Expert description
+     */
+    description?: string;
+    /**
+     * Is active
+     */
+    active?: boolean;
+    /**
+     * Avatar Object
+     */
+    avatar?: TAvatar;
+    /**
+     * Conversation starters
+     */
+    starters?: string[];
+    /**
+     * More configuration
+     */
+    options?: TXpertOptions;
+    /**
+     * Config for every agent
+     */
+    agentConfig?: TXpertAgentConfig;
+    /**
+     * Config of summarize past conversations
+     */
+    summarize?: TSummarize;
+    /**
+     * Long-term memory config
+     */
+    memory?: TLongTermMemory;
+    features?: TXpertFeatures;
+    /**
+     * Version of role: '1' '2' '2.1' '2.2'...
+     */
+    version?: string;
+    /**
+     * Is latest version
+     */
+    latest?: boolean;
+    /**
+     * Release notes
+     */
+    releaseNotes?: string;
+    /**
+     * Draft on current version
+     */
+    draft?: TXpertTeamDraft;
+    /**
+     * Published graph
+     */
+    graph?: TXpertGraph;
+    api?: TChatApi;
+    app?: TChatApp;
+    userId?: string;
+    user?: IUser;
+    /**
+     * Primary agent for this expert
+     */
+    agent?: IXpertAgent;
+    copilotModel?: ICopilotModel;
+    copilotModelId?: string;
+    agents?: IXpertAgent[];
+    /**
+     * Sub-experts, Digital experts who perform specific tasks, focus on completing the assigned work
+     */
+    executors?: IXpert[];
+    /**
+     * The task coordinator who called this expert
+     */
+    leaders?: IXpert[];
+    knowledgebases?: IKnowledgebase[];
+    toolsets?: IXpertToolset[];
+    /**
+     * User groups that are allowed to use this published digital expert.
+     */
+    userGroups?: IUserGroup[];
+    /**
+     * Integrations for this xpert
+     */
+    integrations?: IIntegration[];
+    tags?: ITag[];
+};
+/**
+ * Digital Expert
+ */
+export interface IXpert extends IBasePerWorkspaceEntityModel, TXpert {
+    environmentId?: string;
+    environment?: IEnvironment;
+    /**
+     * When type is 'knowledge', it must binding a knowledgebase
+     */
+    knowledgebase?: IKnowledgebase;
+}
+export type TXpertOptions = {
+    bootstrap?: {
+        source: 'template';
+        templateKey: string;
+        workspaceKind: 'org-default';
+    };
+    knowledge?: Record<string, {
+        position?: IPoint;
+        size?: ISize;
+    }>;
+    toolset?: Record<string, {
+        position?: IPoint;
+        size?: ISize;
+    }>;
+    agent?: Record<string, {
+        position?: IPoint;
+        size?: ISize;
+    }>;
+    xpert?: Record<string, {
+        position?: IPoint;
+        size?: ISize;
+    }>;
+    position?: IPoint;
+    scale?: number;
+};
+/**
+ * Config for Agent execution (Langgraph.js)
+ */
+export type TXpertAgentConfig = {
+    /**
+     * Maximum number of times a call can recurse. If not provided, defaults to 25.
+     */
+    recursionLimit?: number;
+    /** Maximum number of parallel calls to make. */
+    maxConcurrency?: number;
+    /**
+     * Timeout for this call in milliseconds.
+     */
+    timeout?: number;
+    /**
+     * Sensitive tools and agents
+     */
+    interruptBefore?: string[];
+    /**
+     * End nodes
+     */
+    endNodes?: string[];
+    /**
+     * Custom variables of graph state
+     */
+    stateVariables?: TStateVariable[];
+    /**
+     * Custom input parameters should be consistent with the start node or primary agent parameters.
+     */
+    parameters?: TXpertParameter[];
+    /**
+     * @deprecated use memories in tools
+     */
+    toolsMemory?: Record<string, TVariableAssigner[]>;
+    /**
+     * Disable agent's output
+     * @deprecated use `mute` instead
+     */
+    disableOutputs?: string[];
+    /**
+     * Mute nodes in the graph of agents: filter messages by tags of stream events
+     */
+    mute?: string[][];
+    /**
+     * Recall knowledge params
+     */
+    recalls?: Record<string, TKBRecallParams>;
+    /**
+     * Retrieval params for every knowledgebase
+     */
+    retrievals?: Record<string, TKBRetrievalSettings>;
+    /**
+     * Summarize the title of the conversation
+     */
+    summarizeTitle?: {
+        disable?: boolean;
+        instruction?: string;
+    };
+    tools?: Record<string, {
+        /**
+         * Memory assigner for tool's results. (save result of tool call into state variable)
+         */
+        memories?: TVariableAssigner[];
+        timeout?: number;
+        /**
+         * Custom description for the tool
+         */
+        description?: string;
+        parameters?: Record<string, any>;
+    }>;
+};
+export type TStateVariableType = XpertParameterTypeEnum | 'object' | 'array[string]' | 'array[number]' | 'array[object]';
+/**
+ */
+export type TStateVariable<ValueType = any, UpdateType = ValueType> = TXpertParameter & {
+    type: TStateVariableType;
+    default?: any;
+    reducer?: (a: ValueType, b: UpdateType) => ValueType;
+    operation?: VariableOperationEnum;
+};
+/**
+ * Config for summarizing past conversations
+ */
+export type TSummarize = {
+    enabled?: boolean;
+    /**
+     * The system prompt guide how to summarize the conversation
+     */
+    prompt?: string;
+    /**
+     * The maximum number of tolerated messages, otherwise it will be summarized.
+     * Should be greater than the number of retained messages
+     */
+    maxMessages?: number;
+    /**
+     * Number of retained messages
+     */
+    retainMessages?: number;
+};
+export declare enum LongTermMemoryTypeEnum {
+    PROFILE = "profile",
+    QA = "qa"
+}
+export type TLongTermMemoryConfig = {
+    enabled?: boolean;
+    /**
+     * System prompt guide how to remember the key points of the conversation
+     */
+    prompt?: string;
+};
+/**
+ * Config of long-term memory
+ */
+export type TLongTermMemory = {
+    enabled?: boolean;
+    copilotModel?: TCopilotModel;
+    profile?: TLongTermMemoryConfig & {
+        afterSeconds?: number;
+    };
+    qa?: TLongTermMemoryConfig;
+};
+export type TXpertAttachmentType = 'document' | 'image' | 'audio' | 'video' | 'others';
+export type TXpertAttachment = {
+    enabled?: boolean;
+    type?: 'upload' | 'url' | 'all';
+    maxNum?: number;
+    fileTypes?: Array<TXpertAttachmentType>;
+};
+export declare enum XpertParameterTypeEnum {
+    /**
+     * @deprecated use string
+     */
+    TEXT = "text",
+    /**
+     * @deprecated use string
+     */
+    PARAGRAPH = "paragraph",
+    STRING = "string",
+    NUMBER = "number",
+    OBJECT = "object",
+    SELECT = "select",
+    FILE = "file",
+    ARRAY_STRING = "array[string]",
+    ARRAY_NUMBER = "array[number]",
+    ARRAY = "array[object]",
+    ARRAY_FILE = "array[file]",
+    ARRAY_DOCUMENT = "array[document]",
+    BOOLEAN = "boolean",
+    SECRET = "secret"
+}
+export type TXpertParameter = {
+    type: XpertParameterTypeEnum;
+    name: string;
+    /**
+     * @deprecated use description and name only
+     */
+    title?: string;
+    description?: string | I18nObject;
+    optional?: boolean;
+    default?: any;
+    maximum?: number;
+    options?: string[];
+    item?: TXpertParameter[];
+};
+export type TChatApp = {
+    enabled?: boolean;
+    public?: boolean;
+};
+export type TChatApi = {
+    disabled?: boolean;
+};
+export type TXpertGraph = {
+    nodes: TXpertTeamNode[];
+    connections: TXpertTeamConnection[];
+};
+export type TXpertTeamDraft = TXpertGraph & {
+    team: Partial<IXpert>;
+    savedAt?: Date;
+    checklist?: ChecklistItem[];
+};
+export type TXpertTeamNodeType = 'agent' | 'knowledge' | 'toolset' | 'xpert' | 'workflow';
+export type TXpertTeamNodeBase = {
+    key: string;
+    position: IRect;
+    size?: ISize;
+    hash?: string;
+    parentId?: string;
+    readonly?: boolean;
+};
+/** type -> entity + extra props */
+export type TXpertTeamNodeSpec = {
+    agent: {
+        entity: IXpertAgent;
+    };
+    knowledge: {
+        entity: IKnowledgebase;
+    };
+    toolset: {
+        entity: IXpertToolset;
+    };
+    xpert: {
+        entity: IXpert;
+        nodes?: TXpertTeamNode[];
+        connections?: TXpertTeamConnection[];
+        expanded?: boolean;
+    };
+    workflow: {
+        entity: IWorkflowNode;
+    };
+};
+/** If you want TXpertTeamNodeType always match spec keys */
+export type TXpertTeamNodeType2 = keyof TXpertTeamNodeSpec;
+export type TXpertTeamNode<T extends TXpertTeamNodeType = TXpertTeamNodeType> = T extends TXpertTeamNodeType ? TXpertTeamNodeBase & {
+    type: T;
+} & TXpertTeamNodeSpec[T] : never;
+export type NodeOf<T extends keyof TXpertTeamNodeSpec> = TXpertTeamNode<T>;
+export type NodeEntity<T extends keyof TXpertTeamNodeSpec> = TXpertTeamNodeSpec[T]['entity'];
+export type AnyNodeEntity = NodeEntity<keyof TXpertTeamNodeSpec>;
+export interface IRect extends IPoint, Partial<ISize> {
+    gravityCenter?: IPoint;
+}
+export type TXpertTeamGroup = {
+    id: string;
+    title: string;
+    position: IPoint;
+    size?: ISize;
+    parentId?: string;
+    team: IXpert;
+    agent?: IXpertAgent;
+};
+export interface TXpertTeamConnection {
+    key: string;
+    from: string;
+    to: string;
+    /**
+     * - edge: Horizontal Process, workflow
+     * - others: Vertical Process, agent
+     */
+    type: 'edge' | TXpertTeamNodeType;
+    readonly?: boolean;
+}
+export type TChatOptions = {
+    xpertId?: string;
+    conversationId?: string;
+    messageId?: string;
+    thread_id?: string;
+    checkpointId?: string;
+    /**
+     * The language used by the current browser page
+     */
+    language?: LanguagesEnum;
+    /**
+     * The browser's time zone
+     */
+    timeZone?: string;
+    /**
+     * Call from
+     */
+    from?: TChatFrom;
+    /**
+     * Whether to summarize the conversation title
+     */
+    summarizeTitle?: boolean;
+    /**
+     * Project ID, identify the project where the xpert invoked
+     */
+    projectId?: string;
+    /**
+     * Schedule task ID
+     */
+    taskId?: string;
+    /**
+     * Specify environment with variables to run
+     */
+    environment?: IEnvironment;
+    /**
+     * Specify a sandbox environment container to run in
+     */
+    sandboxEnvironmentId?: string;
+    /**
+     * Specify additional tools
+     */
+    tools?: (StructuredToolInterface | RunnableToolLike)[];
+    /**
+     * Per-request runtime context forwarded to agent middleware/tools.
+     */
+    context?: Record<string, unknown>;
+};
+/**
+ * Knowledgebase retrieval settings
+ */
+export type TKBRetrievalSettings = {
+    metadata: {
+        filtering_mode: 'disabled' | 'automatic' | 'manual';
+        /**
+         * Conditions (filter) when mode is manual
+         */
+        filtering_conditions: TWFCase;
+        /**
+         * Parameter fields (tool call) when mode is automatic
+         */
+        fields: Record<string, object>;
+    };
+};
+export declare function isXpertNodeType<T extends TXpertTeamNodeType>(type: T): (node: TXpertTeamNode) => node is NodeOf<T>;

package/src/ai/xpert.utils.d.ts

@@ -0,0 +1,87 @@
+import { IPoint } from '../types';
+import { IXpertAgent } from './xpert-agent.model';
+import { IXpert, TXpertTeamConnection, TXpertTeamDraft, TXpertTeamNode } from './xpert.model';
+export declare function omitXpertRelations(xpert: Partial<IXpert>): {
+    environmentId?: string;
+    workspaceId?: string;
+    workspace?: import("./xpert-workspace.model").IXpertWorkspace;
+    publishAt?: Date;
+    deletedAt?: Date;
+    organizationId?: string;
+    organization?: import("..").IOrganization;
+    tenantId?: string;
+    tenant?: import("..").ITenant;
+    id?: import("../types").ID;
+    createdById?: import("../types").ID;
+    createdBy?: import("..").IUser;
+    updatedById?: import("../types").ID;
+    updatedBy?: import("..").IUser;
+    createdAt?: Date;
+    updatedAt?: Date;
+    slug?: string;
+    name?: string;
+    type?: import("./xpert.model").XpertTypeEnum;
+    title?: string;
+    titleCN?: string;
+    description?: string;
+    active?: boolean;
+    avatar?: import("../types").TAvatar;
+    starters?: string[];
+    options?: import("./xpert.model").TXpertOptions;
+    agentConfig?: import("./xpert.model").TXpertAgentConfig;
+    summarize?: import("./xpert.model").TSummarize;
+    memory?: import("./xpert.model").TLongTermMemory;
+    features?: import("./xpert.model").TXpertFeatures;
+    version?: string;
+    latest?: boolean;
+    releaseNotes?: string;
+    graph?: import("./xpert.model").TXpertGraph;
+    api?: import("./xpert.model").TChatApi;
+    app?: import("./xpert.model").TChatApp;
+    userId?: string;
+    user?: import("..").IUser;
+    copilotModel?: import("./copilot-model.model").ICopilotModel;
+    copilotModelId?: string;
+    tags?: import("..").ITag[];
+};
+/**
+ * Figure out latest xpert or draft xpert.
+ *
+ * @param xpert
+ * @param isDraft Is draft
+ * @returns
+ */
+export declare function figureOutXpert(xpert: IXpert, isDraft: boolean): Partial<IXpert>;
+export declare function xpertLabel(agent: Partial<IXpert>): string;
+export declare function createXpertGraph(xpert: IXpert, position: IPoint): {
+    nodes: TXpertTeamNode[];
+    size: {
+        width: number;
+        height: number;
+    };
+    connections: TXpertTeamConnection[];
+};
+export declare function locateNodes(nodes: TXpertTeamNode[], position: IPoint): {
+    size: {
+        width: number;
+        height: number;
+    };
+    nodes: TXpertTeamNode[];
+};
+/**
+ * Create all nodes of xpert and it's area size
+ *
+ * @param xpert
+ * @returns
+ */
+export declare function createXpertNodes(xpert: IXpert, position: IPoint): {
+    nodes: TXpertTeamNode[];
+    size: {
+        width: number;
+        height: number;
+    };
+};
+export declare function createAgentConnections(agent: IXpertAgent, collaborators: IXpert[]): any[];
+export declare function replaceAgentInDraft(draft: TXpertTeamDraft, sourceKey: string, agent: Partial<IXpertAgent>, options?: {
+    requireNode?: boolean;
+}): TXpertTeamDraft;

package/src/analytics/ai.d.ts

@@ -0,0 +1,73 @@
+export declare enum ChatDashboardMessageType {
+    /**
+     * Display data preview using analytical card event
+     */
+    AnalyticalCard = "AnalyticalCard",
+    /**
+     * Create or edit a cube event
+     */
+    Cube = "Cube",
+    /**
+     * Edit a virtual cube event
+     */
+    VirtualCube = "VirtualCube",
+    /**
+     * Create or edit members (calculated members or dimension sets) event
+     */
+    Members = "Members",
+    /**
+     * List indicators event
+     */
+    ListIndicators = "ListIndicators",
+    /**
+     * Create or edit an indicator event
+     */
+    Indicator = "Indicator",
+    Indicators = "Indicators"
+}
+export declare enum BIInterruptMessageType {
+    SwitchProject = "switch_project",
+    SwitchSemanticModel = "switch_semantic_model",
+    DeleteArtifact = "delete_artifact"
+}
+export type TMessageContentCube = {
+    type: ChatDashboardMessageType.Cube;
+    data: {
+        modelId: string;
+        cubeName: string;
+    };
+};
+export type TMessageContentVirtualCube = {
+    type: ChatDashboardMessageType.VirtualCube;
+    data: {
+        modelId: string;
+        cubeName: string;
+    };
+};
+export type TMessageContentMembers = {
+    type: ChatDashboardMessageType.Members;
+    data: {
+        modelId: string;
+        cubeName: string;
+        members: {
+            __id__: string;
+            name: string;
+            label?: string;
+            caption?: string;
+            description?: string;
+            formula: string;
+            formatting?: {
+                unit?: string;
+                decimal?: number;
+            };
+        }[];
+    };
+};
+export type TMessageContentIndicator = {
+    type: ChatDashboardMessageType.Indicator;
+    data: {
+        modelId?: string;
+        cubeName?: string;
+        indicatorId: string;
+    };
+};

package/src/analytics/approval-policy.model.d.ts

@@ -0,0 +1,30 @@
+import { IBasePerTenantAndOrganizationEntityModel } from "../base-entity.model";
+export interface IApprovalPolicy extends IBasePerTenantAndOrganizationEntityModel {
+    name: string;
+    description: string;
+    approvalType: string;
+}
+export interface IApprovalPolicyFindInput extends IBasePerTenantAndOrganizationEntityModel {
+    name?: string;
+    description?: string;
+    approvalType?: string;
+}
+export interface IApprovalPolicyCreateInput extends IApprovalPolicyFindInput {
+    name?: string;
+}
+export interface IApprovalPolicyUpdateInput extends IApprovalPolicyCreateInput {
+    id?: string;
+}
+export declare enum ApprovalPolicyTypesEnum {
+    TIME_OFF = 1,
+    EQUIPMENT_SHARING = 2,
+    BUSINESS_TRIP = 3
+}
+export declare enum ApprovalPolicyTypesStringEnum {
+    TIME_OFF = "TIME_OFF",
+    EQUIPMENT_SHARING = "EQUIPMENT_SHARING",
+    BUSINESS_TRIP = "BUSINESS_TRIP",
+    INDICATOR = "INDICATOR",
+    STORY = "STORY",
+    BUSINESS_AREA = "BUSINESS_AREA"
+}