@metad/contracts 3.6.1 → 3.6.2

package/src/ai/types.d.ts

@@ -0,0 +1,39 @@
+import { TSelectOption } from "../types";
+import { TXpertAttachmentType, XpertParameterTypeEnum } from "./xpert.model";
+export type TErrorHandling = {
+    type?: null | 'defaultValue' | 'failBranch';
+    defaultValue?: {
+        content?: string;
+    } & Record<string, any>;
+    failBranch?: string;
+};
+export declare enum ApiAuthType {
+    /**
+     * Enum class for api provider auth type.
+     */
+    NONE = "none",
+    API_KEY = "api_key",
+    BASIC = "basic"
+}
+/**
+ * Reference variable (parameter)
+ */
+export type TXpertRefParameter = {
+    type?: XpertParameterTypeEnum;
+    name: string;
+    optional?: boolean;
+    /**
+     * Referencing other variable
+     */
+    variable?: string;
+};
+/**
+ * Embedding status of an entity, such as an bi indicator or kb document.
+ */
+export declare enum EmbeddingStatusEnum {
+    PROCESSING = "processing",
+    SUCCESS = "success",
+    FAILED = "failed",
+    REQUIRED = "required"
+}
+export declare const Attachment_Type_Options: TSelectOption<string, TXpertAttachmentType>[];

package/src/ai/xpert-agent-execution.model.d.ts

@@ -0,0 +1,96 @@
+import { StoredMessage } from '@langchain/core/messages';
+import { IBasePerTenantAndOrganizationEntityModel } from '../base-entity.model';
+import { IXpert, TXpertTeamNodeType } from './xpert.model';
+import { IXpertAgent } from './xpert-agent.model';
+import { TSensitiveOperation } from './chat.model';
+import { WorkflowNodeTypeEnum } from './xpert-workflow.model';
+export type TXpertExecution = {
+    category?: TXpertTeamNodeType;
+    type?: WorkflowNodeTypeEnum | string;
+    title?: string;
+    inputs?: any;
+    outputs?: any;
+    status?: XpertAgentExecutionStatusEnum;
+    error?: string;
+    elapsedTime?: number;
+    threadId?: string;
+    checkpointNs?: string;
+    checkpointId?: string;
+    channelName?: string;
+    parent_thread_id?: string;
+    /**
+     * Include workflow node key
+     */
+    agentKey?: string;
+    predecessor?: string;
+    xpert?: IXpert;
+    xpertId?: string;
+    parentId?: string;
+};
+/**
+ * Corresponds to the run in the [Agent Protocol](https://github.com/langchain-ai/agent-protocol).
+ */
+export type TXpertAgentExecution = TXpertExecution & {
+    /**
+     * Total token usage of chat model
+     */
+    tokens?: number;
+    /**
+     * Token usage of embedding
+     */
+    embedTokens?: number;
+    metadata?: TAgentExecutionMetadata;
+    /**
+     * Latency of response from provider (s)
+     */
+    responseLatency?: number;
+    totalPrice?: number;
+    currency?: string;
+    inputTokens?: number;
+    inputUnitPrice?: number;
+    inputPriceUnit?: number;
+    outputTokens?: number;
+    outputUnitPrice?: number;
+    outputPriceUnit?: number;
+    /**
+     * Latest operation when interrupted
+     */
+    operation?: TSensitiveOperation;
+    messages?: StoredMessage[];
+    agent?: IXpertAgent;
+    totalTokens?: number;
+    /**
+     * Summary of conversation
+     */
+    summary?: string;
+};
+/**
+ * Execution of agent or workflow nodes.
+ *
+ * Corresponds to the run in the [Agent Protocol](https://github.com/langchain-ai/agent-protocol).
+ */
+export interface IXpertAgentExecution extends IBasePerTenantAndOrganizationEntityModel, TXpertAgentExecution {
+    subExecutions?: IXpertAgentExecution[];
+    runningExecution?: IXpertAgentExecution;
+}
+/**
+ * Corresponds to the status of Run in [Agent Protocol](https://github.com/langchain-ai/agent-protocol).
+ */
+export declare enum XpertAgentExecutionStatusEnum {
+    RUNNING = "running",
+    SUCCESS = "success",
+    ERROR = "error",
+    PENDING = "pending",
+    TIMEOUT = "timeout",
+    INTERRUPTED = "interrupted"
+}
+export type TAgentExecutionMetadata = {
+    /**
+     * AI model provider
+     */
+    provider: string;
+    /**
+     * AI Model
+     */
+    model: string;
+};

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

@@ -0,0 +1,192 @@
+import { IBasePerTenantAndOrganizationEntityModel } from '../base-entity.model';
+import { ICopilotModel, TCopilotModel } from './copilot-model.model';
+import { IKnowledgebase, TKBRecallParams } from './knowledgebase.model';
+import { I18nObject, TAvatar } from '../types';
+import { IXpertToolset } from './xpert-toolset.model';
+import { IXpert, TXpertParameter } from './xpert.model';
+import { TVariableAssigner } from './xpert-workflow.model';
+import { TErrorHandling } from './types';
+import { TInterruptCommand } from '../agent';
+export type TXpertAgent = {
+    key: string;
+    name?: string;
+    title?: string;
+    description?: string;
+    avatar?: TAvatar;
+    /**
+     * System prompt
+     */
+    prompt?: string;
+    /**
+     * Prompt templates (ai or human)
+     */
+    promptTemplates?: TAgentPromptTemplate[];
+    /**
+     * Input parameters for agent
+     */
+    parameters?: TXpertParameter[];
+    /**
+     * Output variables of agent
+     */
+    outputVariables?: TAgentOutputVariable[];
+    /**
+     * More configuration
+     */
+    options?: TXpertAgentOptions;
+    /**
+     * This is the xpert's primary agent
+     */
+    xpert?: IXpert;
+    xpertId?: string;
+    /**
+     * Copilot model of this agent
+     */
+    copilotModel?: ICopilotModel;
+    copilotModelId?: string;
+    /**
+     * This is one of the xpert team's agent
+     */
+    team?: IXpert;
+    teamId?: string;
+    /**
+     * My leader in xpert team
+     */
+    leader?: IXpertAgent;
+    leaderKey?: string;
+    /**
+     * I am the leader of followers in xpert's team
+     */
+    followers?: IXpertAgent[];
+    /**
+     * External xpert teams
+     */
+    collaborators?: IXpert[];
+    collaboratorNames?: string[];
+    /**
+     * I used toolsets
+     */
+    toolsets?: IXpertToolset[];
+    toolsetIds?: string[];
+    /**
+     * I used knowledgebases
+     */
+    knowledgebases?: IKnowledgebase[];
+    knowledgebaseIds?: string[];
+};
+/**
+ * Expert agent, ai agent for the xperts.
+ */
+export interface IXpertAgent extends IBasePerTenantAndOrganizationEntityModel, TXpertAgent {
+}
+export type TXpertAgentOptions = {
+    /**
+     * Hide this agent node in the graph
+     */
+    hidden?: boolean;
+    /**
+     * Disable message history for agent conversation
+     */
+    disableMessageHistory?: boolean;
+    /**
+     * The variable of message history to use
+     */
+    historyVariable?: string;
+    /**
+     * Write output variables to memory (state)
+     */
+    memories?: TVariableAssigner[];
+    /**
+     * Whether to enable parallel tool calls, default: true
+     */
+    parallelToolCalls?: boolean;
+    /**
+     * Retry on failure
+     */
+    retry?: {
+        enabled?: boolean;
+        stopAfterAttempt?: number;
+    };
+    /**
+     * Fallback model
+     */
+    fallback?: {
+        enabled?: boolean;
+        copilotModel?: TCopilotModel;
+    };
+    /**
+     * Error handling
+     */
+    errorHandling?: TErrorHandling;
+    /**
+     * Recall params for kbs
+     */
+    recall?: TKBRecallParams;
+    /**
+     * Available tools
+     */
+    availableTools?: Record<string, string[]>;
+    /**
+     * Options for tools of agent
+     */
+    tools?: Record<string, {
+        timeout?: number;
+    }>;
+    /**
+     * How to achieve structured output (`StructuredOutputMethodOptions['method']`)
+     * - *functionCalling*
+     * - *jsonMode*
+     * - *jsonSchema*
+     *
+     */
+    structuredOutputMethod?: "functionCalling" | "jsonMode" | "jsonSchema" | string;
+    /**
+     * Vision config of agent
+     */
+    vision?: {
+        enabled?: boolean;
+        variable?: string;
+        resolution?: 'high' | 'low';
+    };
+};
+export type TAgentPromptTemplate = {
+    id: string;
+    role: 'ai' | 'human';
+    text: string;
+};
+export type TAgentOutputVariable = TXpertParameter & {
+    /**
+       * value write to state's variable
+       */
+    variableSelector: string;
+    /**
+     * How to write value to variable
+     */
+    operation: 'append' | 'extends' | 'overwrite' | 'clear';
+};
+/**
+ * @deprecated use TChatRequest
+ */
+export type TChatAgentParams = {
+    input: {
+        input?: string;
+        [key: string]: unknown;
+    };
+    agentKey: string;
+    xpertId: string;
+    executionId?: string;
+    environmentId?: string;
+    /**
+     */
+    command?: TInterruptCommand;
+    /**
+     * Reject the sensitive tool calls
+     */
+    reject?: boolean;
+};
+export declare function agentLabel(agent: Partial<IXpertAgent>): string;
+export declare function agentUniqueName(agent: IXpertAgent): string;
+export declare function convertToUrlPath(title: string): string;
+export declare const VariableOperations: {
+    value: TAgentOutputVariable['operation'];
+    label: I18nObject;
+}[];

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

@@ -0,0 +1,86 @@
+import { IBasePerTenantAndOrganizationEntityModel } from '../base-entity.model';
+import { IIntegration } from '../integration.model';
+import { IStorageFile, TFile } from '../storage-file.model';
+import { TAvatar } from '../types';
+import { IUser } from '../user.model';
+import { ICopilotModel } from './copilot-model.model';
+import { IKnowledgebase } from './knowledgebase.model';
+import { IXpertToolset } from './xpert-toolset.model';
+import { IXpertWorkspace } from './xpert-workspace.model';
+import { IXpert, TXpertTeamDraft } from './xpert.model';
+export type TXpertProjectSettings = {
+    instruction: string;
+    mode?: '' | 'plan';
+};
+export type TXpertProjectStatus = 'active' | 'deprecated' | 'archived';
+export type TXpertProject = {
+    name: string;
+    avatar?: TAvatar;
+    description?: string;
+    status: TXpertProjectStatus;
+    settings?: TXpertProjectSettings;
+    copilotModel?: ICopilotModel;
+    copilotModelId?: string;
+    vcsId?: string;
+};
+/**
+ * Expert Project
+ */
+export interface IXpertProject extends TXpertProject, IBasePerTenantAndOrganizationEntityModel {
+    workspaceId?: string;
+    workspace?: IXpertWorkspace;
+    ownerId: string;
+    owner?: IUser;
+    xperts?: IXpert[];
+    toolsets?: IXpertToolset[];
+    knowledges?: IKnowledgebase[];
+    members?: IUser[];
+    /**
+     * @deprecated Use *file volume* instead
+     */
+    files?: IXpertProjectFile[];
+    attachments?: IStorageFile[];
+    vcs?: IXpertProjectVCS;
+}
+export interface IBasePerXpertProjectEntityModel extends IBasePerTenantAndOrganizationEntityModel {
+    projectId?: string;
+    project?: IXpertProject;
+}
+export interface IXpertProjectTask extends IBasePerXpertProjectEntityModel {
+    threadId?: string;
+    name: string;
+    type?: string;
+    status: 'pending' | 'in_progress' | 'completed' | 'failed';
+    steps: IXpertProjectTaskStep[];
+}
+export interface IXpertProjectTaskStep extends IBasePerXpertProjectEntityModel {
+    taskId: string;
+    stepIndex: number;
+    description: string;
+    notes: string;
+    status: 'pending' | 'running' | 'done' | 'failed';
+}
+export interface IXpertProjectTaskLog extends IBasePerXpertProjectEntityModel {
+    stepId: string;
+    logType: 'input' | 'output' | 'error';
+    content: string;
+}
+export interface IXpertProjectVCS extends IBasePerXpertProjectEntityModel {
+    integrationId?: string;
+    integration?: IIntegration;
+    auth?: {
+        token_type?: string;
+        access_token?: string;
+        state?: string;
+    };
+    installationId?: number | string;
+    repository?: string;
+}
+/**
+ * @deprecated Use `attachments`
+ */
+export interface IXpertProjectFile extends IBasePerXpertProjectEntityModel, Omit<TFile, 'createdAt'> {
+}
+export type TXpertProjectDSL = IXpertProject & {
+    xperts?: TXpertTeamDraft[];
+};

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

@@ -0,0 +1,26 @@
+import { IBasePerTenantAndOrganizationEntityModel } from '../base-entity.model';
+import { ScheduleTaskStatus, TScheduleOptions } from '../schedule';
+import { IChatConversation } from './chat.model';
+import { IXpert } from './xpert.model';
+/**
+ * Tools for Xpert
+ */
+export interface IXpertTask extends IBasePerTenantAndOrganizationEntityModel, XpertTaskType {
+}
+export type XpertTaskType = {
+    name?: string;
+    schedule?: string;
+    options?: TScheduleOptions;
+    timeZone?: string;
+    prompt?: string;
+    status?: ScheduleTaskStatus;
+    xpert?: IXpert;
+    xpertId?: string;
+    agentKey?: string;
+    conversations?: IChatConversation[];
+    job?: any;
+    scheduleDescription?: string;
+    executionCount?: number;
+    errorCount?: number;
+    successCount?: number;
+};

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

@@ -0,0 +1,47 @@
+import { IBasePerTenantEntityModel } from '../base-entity.model';
+import { IconDefinition, TAvatar } from '../types';
+import { TCopilotModel } from './copilot-model.model';
+import { MCPServerType, TMCPServer } from './xpert-tool-mcp.model';
+import { XpertTypeEnum } from './xpert.model';
+export interface IXpertTemplate extends IBasePerTenantEntityModel {
+    key: string;
+    name?: string;
+    visitCount: number;
+    lastVisitedAt?: Date;
+}
+export type TTemplate = {
+    id: string;
+    name: string;
+    title: string;
+    description: string;
+    category: string;
+    copyright: string;
+    privacyPolicy?: string;
+    export_data: string;
+};
+export type TXpertTemplate = TTemplate & {
+    avatar: TAvatar;
+    type: XpertTypeEnum | 'project';
+    copilotModel?: Partial<TCopilotModel>;
+};
+export interface IXpertMCPTemplate extends TTemplate {
+    /**
+     * string is the backward compatible image file URL format
+     */
+    icon: IconDefinition | string;
+    type: MCPServerType;
+    author: string;
+    transport: MCPServerType;
+    explore: string;
+    tags?: string[];
+    visitCount?: number;
+    server: TMCPServer;
+    options?: any;
+}
+export type TKnowledgePipelineTemplate = TTemplate & {
+    icon: IconDefinition;
+    author: string;
+    explore: string;
+    tags?: string[];
+    visitCount?: number;
+};

package/src/ai/xpert-tool-mcp.model.d.ts

@@ -0,0 +1,67 @@
+export declare enum MCPServerType {
+    SSE = "sse",
+    STDIO = "stdio",
+    CODE = "code"
+}
+/**
+ * Configuration for stdio transport connection
+ */
+export interface StdioConnection {
+    transport: "stdio";
+    command: string;
+    args: string[];
+    env?: Record<string, string>;
+    encoding?: string;
+    encodingErrorHandler?: "strict" | "ignore" | "replace";
+}
+/**
+ * Configuration for SSE transport connection
+ */
+export interface SSEConnection {
+    transport: "sse";
+    url: string;
+    headers?: Record<string, string>;
+    useNodeEventSource?: boolean;
+}
+export type TMCPServerReconnect = {
+    /**
+     * Whether to automatically restart the process if it exits
+     */
+    enabled?: boolean;
+    /**
+      * Maximum number of restart attempts
+      */
+    maxAttempts?: number;
+    /**
+      * Delay in milliseconds between restart attempts
+      */
+    delayMs?: number;
+};
+export type TMCPServer = {
+    type: MCPServerType;
+    command?: string;
+    args?: string[];
+    env?: Record<string, string>;
+    encoding?: string;
+    encodingErrorHandler?: string;
+    /**
+     * Additional reconnection settings
+     */
+    reconnect?: TMCPServerReconnect;
+    url?: string;
+    headers?: Record<string, string>;
+    useNodeEventSource?: boolean;
+    files?: {
+        name: string;
+        content: string;
+    }[];
+    toolNamePrefix?: string;
+    /**
+     * Init scripts for sandbox
+     */
+    initScripts?: string;
+};
+export type TMCPSchema = {
+    servers?: Record<string, TMCPServer>;
+    mcpServers?: Record<string, TMCPServer>;
+};

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

@@ -0,0 +1,147 @@
+import { IBasePerTenantAndOrganizationEntityModel } from '../base-entity.model';
+import { I18nObject } from '../types';
+import { AiProviderRole } from './copilot.model';
+import { TAvatar } from '../types';
+import { IXpertToolset } from './xpert-toolset.model';
+/**
+ * Tools for Xpert
+ */
+export interface IXpertTool extends IBasePerTenantAndOrganizationEntityModel, XpertToolType {
+}
+export type XpertToolType = {
+    name: string;
+    description?: string;
+    avatar?: TAvatar;
+    /**
+     * @deprecated use disabled
+     */
+    enabled?: boolean;
+    /**
+     * Is disabled in toolset
+     */
+    disabled?: boolean;
+    options?: Record<string, any>;
+    /**
+     * Schema of tool
+     */
+    schema?: Record<string, any> | TXpertToolEntity | IBuiltinTool;
+    /**
+     * Default input parameters of tool
+     */
+    parameters?: Record<string, any>;
+    /**
+     * Priority role of AI provider
+     * @default `AiProviderRole.Secondary`
+     */
+    aiProviderRole?: AiProviderRole;
+    toolset?: IXpertToolset;
+    toolsetId?: string;
+    provider?: IBuiltinTool;
+};
+export type TToolProviderIdentity = {
+    name: string;
+    author: string;
+    label: I18nObject;
+    provider: string;
+    entity?: string;
+};
+interface ToolParameterOption {
+    value: string;
+    label: I18nObject;
+}
+export declare enum ToolParameterType {
+    STRING = "string",
+    NUMBER = "number",
+    BOOLEAN = "boolean",
+    ARRAY = "array",
+    SELECT = "select",
+    SECRET_INPUT = "secret-input",
+    FILE = "file"
+}
+export declare enum ToolParameterForm {
+    SCHEMA = "schema",// should be set while adding tool
+    FORM = "form",// should be set before invoking tool
+    LLM = "llm"
+}
+export type TToolParameter = {
+    name: string;
+    label: I18nObject;
+    human_description?: I18nObject;
+    placeholder?: I18nObject;
+    type: ToolParameterType;
+    form: ToolParameterForm;
+    llm_description?: string;
+    required?: boolean;
+    default?: number | string;
+    min?: number;
+    max?: number;
+    options?: ToolParameterOption[];
+    items?: {
+        type: ToolParameterType;
+    };
+    /**
+     * Is visible for ai tool parameters
+     */
+    visible?: boolean;
+};
+export interface ApiToolBundle {
+    /**
+     * This interface is used to store the schema information of an api based tool,
+     * such as the url, the method, the parameters, etc.
+     */
+    server_url: string;
+    method: string;
+    summary?: string;
+    operation_id?: string;
+    parameters?: TToolParameter[];
+    author: string;
+    icon?: string;
+    openapi: Record<string, any>;
+}
+export interface IBuiltinTool {
+    identity: TToolProviderIdentity;
+    description: {
+        human: I18nObject;
+        llm: string;
+    };
+    /**
+     * Definition of input parameters (yaml schema)
+     */
+    parameters?: TToolParameter[];
+    /**
+     * Schema of tool (zod/json-schema)
+     */
+    schema?: any;
+    /**
+     * @deprecated how to use?
+     */
+    entity?: string;
+}
+export type TXpertToolEntity = {
+    name: string;
+    method: 'create' | 'get' | 'query' | 'update' | 'delete';
+    entity: string;
+    path: string;
+    /**
+     * Definition of properties
+     */
+    parameters: Partial<TToolParameter>[];
+    description?: string;
+};
+export declare const TOOL_NAME_REGEX: RegExp;
+/**
+ *
+ * @param tool Tool
+ * @param disableToolDefault Is default disable tools
+ * @returns Tool is enabled?
+ */
+export declare function isToolEnabled(tool: IXpertTool, disableToolDefault?: boolean): boolean;
+/**
+ * Tool is enabled?
+ *
+ * @deprecated use isToolEnabled
+ */
+export declare function isEnableTool(tool: IXpertTool, toolset: IXpertToolset): boolean;
+export declare function getEnabledTools(toolset: IXpertToolset): IXpertTool[];
+export declare function getToolLabel(tool: IXpertTool): I18nObject | string;
+export {};