@metad/contracts 3.6.0-beta.1 → 3.6.0-beta.2

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

@@ -0,0 +1,200 @@
+import { AiProviderRole } from './copilot.model';
+import { TAvatar } from '../types';
+import { IXpertTool, XpertToolType } from './xpert-tool.model';
+import { IBasePerWorkspaceEntityModel } from './xpert-workspace.model';
+import { ITag } from '../tag-entity.model';
+import { TCopilotModel } from './copilot-model.model';
+import { Subscriber } from 'rxjs';
+import { I18nObject } from '../types';
+export declare enum XpertToolsetCategoryEnum {
+    BUILTIN = "builtin",
+    API = "api",
+    /**
+     * [Anthropic Model Context Protocol (MCP)](https://modelcontextprotocol.io/introduction)
+     */
+    MCP = "mcp",
+    /**
+     * @deprecated
+     */
+    WORKFLOW = "workflow"
+}
+export type XpertToolsetType = string;
+export type TXpertToolset = {
+    key?: string;
+    /**
+     * toolset name
+     */
+    name: string;
+    type?: XpertToolsetType;
+    category?: 'command' | XpertToolsetCategoryEnum;
+    description?: string;
+    /**
+     * avatar object
+     */
+    avatar?: TAvatar;
+    /**
+     * Priority role of AI provider
+     * @default `AiProviderRole.Secondary`
+     */
+    aiProviderRole?: AiProviderRole;
+    /**
+     * Privacy policy of this toolset
+     */
+    privacyPolicy?: string;
+    /**
+     * Custom disclaimer for the toolset
+     */
+    customDisclaimer?: string;
+    options?: TXpertToolsetOptions;
+    credentials?: TToolCredentials;
+    schema?: string;
+    schemaType?: 'openapi_json' | 'openapi_yaml';
+    tools?: IXpertTool[];
+    tags?: ITag[];
+};
+/**
+ * Toolset for Xpert
+ */
+export interface IXpertToolset extends IBasePerWorkspaceEntityModel, TXpertToolset {
+}
+export type TXpertToolsetOptions = {
+    provider?: IToolProvider;
+    baseUrl?: string;
+    toolPositions?: Record<string, number>;
+    disableToolDefault?: boolean;
+    needSandbox?: boolean;
+    [key: string]: any;
+};
+/**
+ * Context env when tool call in langchain.js
+ */
+export type XpertToolContext = {
+    tenantId: string;
+    organizationId?: string;
+    userId: string;
+    copilotModel: TCopilotModel;
+    chatModel: unknown;
+    tool_call_id: string;
+    subscriber: Subscriber<MessageEvent>;
+};
+export declare enum CredentialsType {
+    SECRET_INPUT = "secret-input",
+    TEXT_INPUT = "text-input",
+    SELECT = "select",
+    REMOTE_SELECT = "remote-select",
+    COPILOT_MODEL = "copilot-model",
+    BOOLEAN = "boolean",
+    INT = "int",
+    NUMBER = "number"
+}
+export interface ToolCredentialsOption {
+    value: string;
+    label: I18nObject | string;
+}
+export interface ToolProviderCredentials {
+    name: string;
+    type: CredentialsType;
+    required?: boolean;
+    default?: number | string;
+    options?: ToolCredentialsOption[];
+    /**
+     * Url for fetch remote select options
+     */
+    selectUrl?: string;
+    /**
+     * Is multiple select
+     */
+    multi?: boolean;
+    /**
+     * Depends on credentials
+     */
+    depends?: string[];
+    label?: I18nObject;
+    help?: I18nObject;
+    /**
+     * Url for help document
+     */
+    url?: string;
+    placeholder?: I18nObject;
+    max?: number;
+    config?: Record<string, any>;
+}
+export declare enum ApiProviderSchemaType {
+    /**
+     * Enum class for api provider schema type.
+     */
+    OPENAPI = "openapi",
+    SWAGGER = "swagger",
+    OPENAI_PLUGIN = "openai_plugin",
+    OPENAI_ACTIONS = "openai_actions"
+}
+export declare enum ToolTagEnum {
+    SEARCH = "search",
+    IMAGE = "image",
+    VIDEOS = "videos",
+    WEATHER = "weather",
+    FINANCE = "finance",
+    DESIGN = "design",
+    TRAVEL = "travel",
+    SOCIAL = "social",
+    NEWS = "news",
+    MEDICAL = "medical",
+    PRODUCTIVITY = "productivity",
+    EDUCATION = "education",
+    BUSINESS = "business",
+    ENTERTAINMENT = "entertainment",
+    UTILITIES = "utilities",
+    ANALYSIS = "analysis",
+    SANDBOX = "sandbox",
+    PROJECT = "project",
+    AGENT = "agent",
+    OTHER = "other"
+}
+export interface IToolTag {
+    name: string;
+    label: I18nObject;
+    icon: string;
+    description?: I18nObject;
+}
+export interface IToolProvider {
+    not_implemented?: boolean;
+    pro?: boolean;
+    id: string;
+    author: string;
+    name: string;
+    description: I18nObject;
+    /**
+     * @deprecated use avatar
+     */
+    icon?: string;
+    avatar: TAvatar;
+    label: I18nObject;
+    help_url?: string;
+    type: XpertToolsetCategoryEnum;
+    masked_credentials?: Record<string, any>;
+    original_credentials?: Record<string, any>;
+    is_team_authorization: boolean;
+    allow_delete: boolean;
+    tools?: XpertToolType[];
+    tags: ToolTagEnum[];
+}
+export type TToolCredentials = Record<string, string | number | boolean | any>;
+export type TToolsetParams = {
+    tenantId: string;
+    organizationId?: string;
+    projectId?: string;
+    userId?: string;
+    xpertId?: string;
+    conversationId?: string;
+    agentKey?: string;
+    signal?: AbortSignal;
+    env: Record<string, unknown>;
+};
+export interface IBaseToolset {
+    toolNamePrefix?: string;
+}
+export type TProgramToolMessage = {
+    code: string;
+    output: string;
+    error?: string;
+};

package/src/ai/xpert-workflow-task.prompt.d.ts

@@ -0,0 +1,2 @@
+export declare const TASK_DESCRIPTION_PREFIX = "Launch a new agent to handle complex, multi-step tasks autonomously. \n\nAvailable agent types and the tools they have access to:";
+export declare const TASK_DESCRIPTION_SUFFIX = "When using the Task tool, you must specify a subagent_type parameter to select which agent type to use.\n\nWhen to use the Agent tool:\n- When you are instructed to execute custom slash commands. Use the Agent tool with the slash command invocation as the entire prompt. The slash command can take arguments. For example: Task(description=\"Check the file\")\n\nWhen NOT to use the Agent tool:\n- If you want to read a specific file path, use the Read or Glob tool instead of the Agent tool, to find the match more quickly\n- If you are searching for a specific term or definition within a known location, use the Glob tool instead, to find the match more quickly\n- If you are searching for content within a specific file or set of 2-3 files, use the Read tool instead of the Agent tool, to find the match more quickly\n- Other tasks that are not related to the agent descriptions above\n\n\nUsage notes:\n1. Launch multiple agents concurrently whenever possible, to maximize performance; to do that, use a single message with multiple tool uses\n2. When the agent is done, it will return a single message back to you. The result returned by the agent is not visible to the user. To show the user the result, you should send a text message back to the user with a concise summary of the result.\n3. Each agent invocation is stateless. You will not be able to send additional messages to the agent, nor will the agent be able to communicate with you outside of its final report. Therefore, your prompt should contain a highly detailed task description for the agent to perform autonomously and you should specify exactly what information the agent should return back to you in its final and only message to you.\n4. The agent's outputs should generally be trusted\n5. Clearly tell the agent whether you expect it to create content, perform analysis, or just do research (search, file reads, web fetches, etc.), since it is not aware of the user's intent\n6. If the agent description mentions that it should be used proactively, then you should try your best to use it without the user having to ask for it first. Use your judgement.\n\nExample usage:\n\n<example_agent_descriptions>\n\"content-reviewer\": use this agent after you are done creating significant content or documents\n\"greeting-responder\": use this agent when to respond to user greetings with a friendly joke\n\"research-analyst\": use this agent to conduct thorough research on complex topics\n</example_agent_description>\n\n<example>\nuser: \"Please write a function that checks if a number is prime\"\nassistant: Sure let me write a function that checks if a number is prime\nassistant: First let me use the Write tool to write a function that checks if a number is prime\nassistant: I'm going to use the Write tool to write the following code:\n<code>\nfunction isPrime(n) {\n  if (n <= 1) return false\n  for (let i = 2; i * i <= n; i++) {\n    if (n % i === 0) return false\n  }\n  return true\n}\n</code>\n<commentary>\nSince significant content was created and the task was completed, now use the content-reviewer agent to review the work\n</commentary>\nassistant: Now let me use the content-reviewer agent to review the code\nassistant: Uses the Task tool to launch with the content-reviewer agent \n</example>\n\n<example>\nuser: \"Can you help me research the environmental impact of different renewable energy sources and create a comprehensive report?\"\n<commentary>\nThis is a complex research task that would benefit from using the research-analyst agent to conduct thorough analysis\n</commentary>\nassistant: I'll help you research the environmental impact of renewable energy sources. Let me use the research-analyst agent to conduct comprehensive research on this topic.\nassistant: Uses the Task tool to launch with the research-analyst agent, providing detailed instructions about what research to conduct and what format the report should take\n</example>\n\n<example>\nuser: \"Hello\"\n<commentary>\nSince the user is greeting, use the greeting-responder agent to respond with a friendly joke\n</commentary>\nassistant: \"I'm going to use the Task tool to launch with the greeting-responder agent\"\n</example>";

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

@@ -0,0 +1,369 @@
+import { I18nObject } from "../types";
+import { ICopilotModel } from "./copilot-model.model";
+import { TKBRecallParams } from "./knowledgebase.model";
+import { ApiAuthType, TErrorHandling, TXpertRefParameter } from "./types";
+import { TStateVariable, TXpertParameter } from "./xpert.model";
+export type TWorkflowNodeMeta = {
+    name: string;
+    label: I18nObject;
+    icon: {
+        svg?: string;
+        remixicon?: string;
+        color?: string;
+    };
+    configSchema: any;
+};
+export type TWorkflowTriggerMeta = TWorkflowNodeMeta;
+export declare enum WorkflowNodeTypeEnum {
+    /**
+     * Trigger
+     */
+    TRIGGER = "trigger",
+    /**
+     * State Variable Assigner
+     */
+    ASSIGNER = "assigner",
+    /**
+     * Router
+     */
+    IF_ELSE = "if-else",
+    LIST_OPERATOR = "list-operator",
+    VARIABLE_AGGREGATOR = "variable-aggregator",
+    ITERATING = "iterating",
+    ANSWER = "answer",
+    CODE = "code",
+    HTTP = "http",
+    KNOWLEDGE = "knowledge",
+    SUBFLOW = "subflow",
+    TEMPLATE = "template",
+    CLASSIFIER = "classifier",
+    TOOL = "tool",
+    AGENT_TOOL = "agent-tool",
+    NOTE = "note",
+    /**
+     * Task node, distribute tasks to sub-agents
+     */
+    TASK = "task",
+    SOURCE = "source",
+    PROCESSOR = "processor",
+    CHUNKER = "chunker",
+    UNDERSTANDING = "understanding",
+    KNOWLEDGE_BASE = "knowledgebase"
+}
+export interface IWorkflowNode {
+    id: string;
+    key: string;
+    title?: string;
+    description?: string | I18nObject;
+    type: WorkflowNodeTypeEnum;
+}
+export declare enum VariableOperationEnum {
+    APPEND = "append",
+    EXTEND = "extend",
+    OVERWRITE = "overwrite",
+    CLEAR = "clear"
+}
+export type TVariableAssigner = {
+    id: string;
+    inputType: 'variable' | 'constant' | 'message';
+    /**
+     * value from variable
+     */
+    value?: string;
+    /**
+     * value write to state's variable
+     */
+    variableSelector: string;
+    /**
+     * How to write value to variable
+     */
+    operation: VariableOperationEnum;
+    /**
+     * The message template to write to messages variable
+     */
+    messages?: {
+        role: string;
+        content: string;
+    }[];
+};
+export interface IWFNAssigner extends IWorkflowNode {
+    type: WorkflowNodeTypeEnum.ASSIGNER;
+    assigners: TVariableAssigner[];
+}
+export interface IWFNIfElse extends IWorkflowNode {
+    type: WorkflowNodeTypeEnum.IF_ELSE;
+    cases: TWFCase[];
+}
+/**
+ * The list operator can filter and extract attributes such as file format type, file name, and size,
+ * passing different format files to corresponding processing nodes to achieve precise control over different file processing flows.
+ */
+export interface IWFNListOperator extends IWorkflowNode {
+    type: WorkflowNodeTypeEnum.LIST_OPERATOR;
+    input: string;
+    itemVarType: string;
+    filterBy?: {
+        enabled: boolean;
+        conditions: TWFCaseCondition[];
+        logicalOperator: WorkflowLogicalOperator;
+    };
+    extractBy?: {
+        enabled: boolean;
+        index: number;
+    };
+    sortBy?: {
+        enabled: boolean;
+        variable: string;
+        descending?: boolean;
+    };
+    topN?: {
+        enabled: boolean;
+        count: number;
+    };
+}
+/**
+ * Aggregate variables from multiple branches into a single variable to achieve unified configuration for downstream nodes.
+ */
+export interface IWFNVariableAggregator extends IWorkflowNode {
+    type: WorkflowNodeTypeEnum.VARIABLE_AGGREGATOR;
+    inputs: string[];
+    outputType: string;
+}
+export interface IWFNIterating extends IWorkflowNode {
+    type: WorkflowNodeTypeEnum.ITERATING;
+    /**
+     * Variable name of input array in state
+     */
+    inputVariable: string;
+    inputParams?: TXpertRefParameter[];
+    outputParams?: TXpertRefParameter[];
+    /**
+     * Execute in parallel, otherwise execute sequentially
+     */
+    parallel?: boolean;
+    /**
+     * Maximum number of parallel task
+     */
+    maximum?: number;
+    /**
+     * - terminate: terminate on error
+     * - ignore: ignore error and continue
+     * - remove: remove error output
+     */
+    errorMode?: 'terminate' | 'ignore' | 'remove';
+}
+/**
+ * The parameter name that represents the entire current element in array
+ */
+export declare const IteratingItemParameterName = "$item";
+export declare const IteratingIndexParameterName = "$index";
+export interface IWFNAnswer extends IWorkflowNode {
+    type: WorkflowNodeTypeEnum.ANSWER;
+    promptTemplate: string;
+    mute?: boolean;
+}
+export declare enum WorkflowLogicalOperator {
+    AND = "and",
+    OR = "or"
+}
+export declare enum WorkflowComparisonOperator {
+    CONTAINS = "contains",
+    NOT_CONTAINS = "not-contains",
+    EQUAL = "equal",
+    NOT_EQUAL = "not-equal",
+    GT = "gt",
+    LT = "lt",
+    GE = "ge",
+    LE = "le",
+    STARTS_WITH = "starts-with",
+    ENDS_WITH = "ends-with",
+    EMPTY = "empty",
+    NOT_EMPTY = "not-empty",
+    IS_TRUE = "is-true",
+    IS_FALSE = "is-false",
+    LIKE = "like",
+    NOT_LIKE = "not-like"
+}
+/**
+ * Comparison condition for if-else and list-operator nodes
+ */
+export type TWFCaseCondition = {
+    id: string;
+    comparisonOperator: WorkflowComparisonOperator;
+    value?: string;
+    varType?: string;
+    variableSelector?: string;
+};
+export type TWFCase = {
+    caseId: string;
+    conditions: TWFCaseCondition[];
+    logicalOperator: WorkflowLogicalOperator;
+};
+export type TWorkflowVarGroup = {
+    group?: {
+        name: string;
+        description: string | I18nObject;
+    };
+    variables: TStateVariable[];
+};
+export type TWorkflowRetry = {
+    enabled?: boolean;
+    stopAfterAttempt?: number;
+    retryInterval?: number;
+};
+export interface IWFNCode extends IWorkflowNode {
+    type: WorkflowNodeTypeEnum.CODE;
+    language: 'python' | 'javascript';
+    code: string;
+    inputs: {
+        name: string;
+        variable?: string;
+    }[];
+    outputs: TXpertParameter[];
+    /**
+     * Retry on failure
+     */
+    retry?: TWorkflowRetry;
+    /**
+     * Error handling
+     */
+    errorHandling?: TErrorHandling;
+}
+export type BodyType = 'none' | 'form-data' | 'x-www-form-urlencoded' | 'json' | 'raw' | 'binary';
+interface HttpParam {
+    key: string;
+    value: string;
+}
+interface HttpHeader {
+    name: string;
+    value: string;
+}
+export type TWorkflowAuthorization = {
+    auth_type?: ApiAuthType;
+    api_key_type?: '' | 'bearer' | 'custom';
+    api_key_header?: string;
+    api_key_value?: string;
+    username?: string;
+    password?: string;
+};
+export interface IWFNHttp extends IWorkflowNode {
+    type: WorkflowNodeTypeEnum.HTTP;
+    authorization?: TWorkflowAuthorization;
+    method: 'get' | 'post' | 'put' | 'delete' | 'patch' | 'head';
+    url: string;
+    headers: HttpHeader[];
+    params: HttpParam[];
+    body: {
+        type?: BodyType;
+        body?: string;
+        encodedForm?: HttpParam[];
+    };
+    connectionTimeout?: number;
+    readTimeout?: number;
+    writeTimeout?: number;
+    /**
+     * Retry on failure
+     */
+    retry?: TWorkflowRetry;
+    /**
+     * Error handling
+     */
+    errorHandling?: TErrorHandling;
+}
+export interface IWFNKnowledgeRetrieval extends IWorkflowNode {
+    queryVariable: string;
+    knowledgebases: string[];
+    recall?: TKBRecallParams;
+}
+export interface IWFNSubflow extends IWorkflowNode {
+    inputParams?: TXpertRefParameter[];
+    outputParams?: TXpertRefParameter[];
+}
+export interface IWFNTemplate extends IWorkflowNode {
+    type: WorkflowNodeTypeEnum.TEMPLATE;
+    inputParams?: TXpertRefParameter[];
+    code: string;
+    /**
+     * Error handling
+     */
+    errorHandling?: TErrorHandling;
+}
+export interface IWFNClassifier extends IWorkflowNode {
+    type: WorkflowNodeTypeEnum.CLASSIFIER;
+    copilotModel: ICopilotModel;
+    inputVariables: string[];
+    classes: {
+        description?: string;
+    }[];
+    instruction?: string;
+}
+export interface IWFNClassifier extends IWorkflowNode {
+    type: WorkflowNodeTypeEnum.CLASSIFIER;
+    copilotModel: ICopilotModel;
+    inputVariables: string[];
+    classes: {
+        description?: string;
+    }[];
+    instruction?: string;
+}
+export interface IWFNTemplate extends IWorkflowNode {
+    type: WorkflowNodeTypeEnum.TEMPLATE;
+    inputParams?: TXpertRefParameter[];
+    code: string;
+    /**
+     * Error handling
+     */
+    errorHandling?: TErrorHandling;
+}
+export interface IWFNTool extends IWorkflowNode {
+    type: WorkflowNodeTypeEnum.TOOL;
+    toolsetId: string;
+    toolName: string;
+    /**
+     * @deprecated Use parameters instead
+     */
+    parameterVariable: string;
+    parameters?: any;
+    omitBlankValues?: boolean;
+    /**
+     * Error handling
+     */
+    errorHandling?: TErrorHandling;
+}
+export interface IWFNNote extends IWorkflowNode {
+    content: string;
+}
+export interface IWFNAgentTool extends IWorkflowNode {
+    type: WorkflowNodeTypeEnum.AGENT_TOOL;
+    toolName: string;
+    toolDescription?: string;
+    toolParameters?: TXpertParameter[];
+    /**
+     * End point tool
+     */
+    isEnd?: boolean;
+    /**
+     * @deprecated Mixed sub-processes are not suitable for catching exceptions unless they are implemented using a separate subgraph
+     * Error handling
+     */
+    errorHandling?: TErrorHandling;
+}
+export interface IWFNTrigger extends IWorkflowNode {
+    type: WorkflowNodeTypeEnum.TRIGGER;
+    from: 'chat' | 'integration' | 'scheduler';
+    parameters?: TXpertParameter[];
+    config?: any;
+}
+export interface IWFNTask extends IWorkflowNode {
+    type: WorkflowNodeTypeEnum.TASK;
+    descriptionPrefix?: string;
+    descriptionSuffix?: string;
+}
+export declare function genListOperatorKey(): string;
+export declare function genVariableAggregatorKey(): string;
+export declare function isAgentKey(key: string): boolean;
+export declare function isRouterKey(key: string): boolean;
+export declare function isIteratingKey(key: string): boolean;
+export declare function isWorkflowKey(key: string): boolean;
+export declare function workflowNodeIdentifier(node: IWorkflowNode): string;
+export {};

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

@@ -0,0 +1,32 @@
+import { IBasePerTenantAndOrganizationEntityModel } from '../base-entity.model';
+import { IUser } from '../user.model';
+import { IEnvironment } from './environment.model';
+import { IXpert } from './xpert.model';
+/**
+ * Expert Workspace
+ */
+export interface IXpertWorkspace extends IBasePerTenantAndOrganizationEntityModel {
+    name: string;
+    description?: string;
+    status: TXpertWorkspaceStatus;
+    settings?: TXpertWorkspaceSettings;
+    ownerId: string;
+    owner?: IUser;
+    xperts?: IXpert[];
+    environments?: IEnvironment[];
+    members?: IUser[];
+}
+export type TXpertWorkspaceSettings = {};
+export type TXpertWorkspaceStatus = 'active' | 'deprecated' | 'archived';
+export interface IBasePerWorkspaceEntityModel extends IBasePerTenantAndOrganizationEntityModel {
+    workspaceId?: string;
+    workspace?: IXpertWorkspace;
+    /**
+     * Publish date of latest
+     */
+    publishAt?: Date;
+    /**
+     * Soft deleted
+     */
+    deletedAt?: Date;
+}