@metad/contracts 3.6.7 → 3.7.0

package/src/agent/utils.spec.ts

@@ -1,283 +0,0 @@
-import { TXpertGraph } from '../ai/xpert.model'
-import { DeepPartial } from '../types'
-import { allChannels, findStartNodes, getCurrentGraph } from './utils'
-
-describe('findStartNodes', () => {
-  it('should return the correct start nodes for a given key', () => {
-    const graph: DeepPartial<TXpertGraph> = {
-      connections: [
-        { from: 'A', to: 'B' },
-        { from: 'B', to: 'C' },
-        { from: 'D', to: 'C' },
-        { from: 'C', to: 'E' },
-        { from: 'E', to: 'F' }
-      ]
-    }
-
-    const startNodes = findStartNodes(graph, 'C')
-    expect(startNodes).toEqual(expect.arrayContaining(['A', 'D']))
-  })
-
-  it('should return the node itself if it has no upstream nodes', () => {
-    const graph: DeepPartial<TXpertGraph> = {
-      connections: [
-        { from: 'A', to: 'B' },
-        { from: 'B', to: 'C' }
-      ]
-    }
-
-    const startNodes = findStartNodes(graph, 'A')
-    expect(startNodes).toEqual(['A'])
-  })
-
-  it('should return an empty array if the key is not in the graph', () => {
-    const graph: DeepPartial<TXpertGraph> = {
-      connections: [
-        { from: 'A', to: 'B' },
-        { from: 'B', to: 'C' }
-      ]
-    }
-
-    const startNodes = findStartNodes(graph, 'Z')
-    expect(startNodes).toEqual(['Z'])
-  })
-
-  it('should use start part of from key', () => {
-    const graph: DeepPartial<TXpertGraph> = {
-      connections: [
-        {
-          type: "edge",
-          // key: "Knowledge_XlSM1H1rCb/Router_zBkMXfqpXk",
-          from: "Knowledge_XlSM1H1rCb",
-          to: "Router_zBkMXfqpXk",
-        },
-        {
-          type: "edge",
-          // key: "Router_zBkMXfqpXk/oUluRQoFdV/Agent_cPnbaxekWd",
-          from: "Router_zBkMXfqpXk/oUluRQoFdV",
-          to: "Agent_cPnbaxekWd",
-        },
-        {
-          type: "edge",
-          // key: "Router_zBkMXfqpXk/else/Answer_Pb7cYUvTJU",
-          from: "Router_zBkMXfqpXk/else",
-          to: "Answer_Pb7cYUvTJU",
-        },
-      ]
-    }
-
-    const startNodes = findStartNodes(graph, 'Agent_cPnbaxekWd')
-    expect(startNodes).toEqual(['Knowledge_XlSM1H1rCb'])
-  })
-
-  it('only edge connections', () => {
-    const graph: DeepPartial<TXpertGraph> = {
-      connections: [
-        {
-          type: 'edge',
-          key: 'Agent_UMVcdTL9w1/Iterating_jsCXACz4wh',
-          from: 'Agent_UMVcdTL9w1',
-          to: 'Iterating_jsCXACz4wh'
-        },
-        {
-          type: 'agent',
-          key: 'Iterating_jsCXACz4wh/Agent_albUSvIcdF',
-          from: 'Iterating_jsCXACz4wh',
-          to: 'Agent_albUSvIcdF'
-        },
-        {
-          type: 'edge',
-          key: 'Agent_albUSvIcdF/Http_T9uLo1NJUV',
-          from: 'Agent_albUSvIcdF',
-          to: 'Http_T9uLo1NJUV'
-        },
-        {
-          type: 'edge',
-          key: 'Iterating_jsCXACz4wh/Code_27ERnJwa2t',
-          from: 'Iterating_jsCXACz4wh',
-          to: 'Code_27ERnJwa2t'
-        },
-        {
-          type: 'edge',
-          key: 'Code_27ERnJwa2t/Agent_M2Wa9MQVpM',
-          from: 'Code_27ERnJwa2t',
-          to: 'Agent_M2Wa9MQVpM'
-        },
-        {
-          type: 'edge',
-          key: 'Agent_M2Wa9MQVpM/Answer_uzsdBtAqPq',
-          from: 'Agent_M2Wa9MQVpM',
-          to: 'Answer_uzsdBtAqPq'
-        }
-      ]
-    }
-
-    const startNodes = findStartNodes(graph, 'Agent_albUSvIcdF')
-    expect(startNodes).toEqual(['Agent_albUSvIcdF'])
-  })
-
-  it('only edge connections', () => {
-    const graph: DeepPartial<TXpertGraph> = {
-      nodes: [],
-      connections: [
-        {
-          type: 'edge',
-          key: 'Agent_UMVcdTL9w1/Iterating_jsCXACz4wh',
-          from: 'Agent_UMVcdTL9w1',
-          to: 'Iterating_jsCXACz4wh'
-        },
-        {
-          type: 'agent',
-          key: 'Iterating_jsCXACz4wh/Agent_albUSvIcdF',
-          from: 'Iterating_jsCXACz4wh',
-          to: 'Agent_albUSvIcdF'
-        },
-        {
-          type: 'edge',
-          key: 'Agent_albUSvIcdF/Http_T9uLo1NJUV',
-          from: 'Agent_albUSvIcdF',
-          to: 'Http_T9uLo1NJUV'
-        },
-        {
-          type: 'edge',
-          key: 'Iterating_jsCXACz4wh/Code_27ERnJwa2t',
-          from: 'Iterating_jsCXACz4wh',
-          to: 'Code_27ERnJwa2t'
-        },
-        {
-          type: 'edge',
-          key: 'Code_27ERnJwa2t/Agent_M2Wa9MQVpM',
-          from: 'Code_27ERnJwa2t',
-          to: 'Agent_M2Wa9MQVpM'
-        },
-        {
-          type: 'edge',
-          key: 'Agent_M2Wa9MQVpM/Answer_uzsdBtAqPq',
-          from: 'Agent_M2Wa9MQVpM',
-          to: 'Answer_uzsdBtAqPq'
-        }
-      ]
-    }
-
-    const startNodes = getCurrentGraph(graph as TXpertGraph, 'Agent_albUSvIcdF')
-    expect(startNodes).toEqual(['Agent_albUSvIcdF'])
-  })
-  
-})
-
-describe('allChannels', () => {
-  it('should return the correct start nodes for a given key', () => {
-    const graph: DeepPartial<TXpertGraph> = {
-      nodes: [
-        {
-          type: "agent",
-          key: "Agent_xv0UeM91O6",
-        },
-        {
-          type: "agent",
-          key: "Agent_DiQbU6FKZ6",
-        },
-        {
-          type: "workflow",
-          key: "Router_Q1uTcWa1rZ",
-        },
-        {
-          type: "workflow",
-          key: "Code_MlXFPNEphR",
-        },
-        {
-          type: "workflow",
-          key: "Knowledge_PJ2H5EObqJ",
-        },
-        {
-          type: "workflow",
-          key: "Router_A1Na6n49Ri",
-        },
-        {
-          type: "workflow",
-          key: "Code_1uEOTXgBNQ",
-        },
-        {
-          type: "workflow",
-          key: "Answer_za0cCTiayv",
-        },
-        {
-          type: "workflow",
-          key: "Iterating_CsvbR5teUm",
-        },
-        {
-          type: "workflow",
-          key: "Answer_SowVtmiosK",
-        },
-      ],
-      connections: [
-        {
-          type: "edge",
-          key: "Router_Q1uTcWa1rZ/TT9sQAeTa2/Agent_DiQbU6FKZ6",
-          from: "Router_Q1uTcWa1rZ/TT9sQAeTa2",
-          to: "Agent_DiQbU6FKZ6",
-        },
-        {
-          type: "edge",
-          key: "Knowledge_PJ2H5EObqJ/Router_A1Na6n49Ri",
-          from: "Knowledge_PJ2H5EObqJ",
-          to: "Router_A1Na6n49Ri",
-        },
-        {
-          type: "edge",
-          key: "Router_A1Na6n49Ri/2syn8OhkzH/Agent_xv0UeM91O6",
-          from: "Router_A1Na6n49Ri/2syn8OhkzH",
-          to: "Agent_xv0UeM91O6",
-        },
-        {
-          type: "edge",
-          key: "Router_A1Na6n49Ri/else/Code_1uEOTXgBNQ",
-          from: "Router_A1Na6n49Ri/else",
-          to: "Code_1uEOTXgBNQ",
-        },
-        {
-          type: "edge",
-          key: "Router_Q1uTcWa1rZ/else/Answer_za0cCTiayv",
-          from: "Router_Q1uTcWa1rZ/else",
-          to: "Answer_za0cCTiayv",
-        },
-        {
-          type: "edge",
-          key: "Code_MlXFPNEphR/Router_Q1uTcWa1rZ",
-          from: "Code_MlXFPNEphR",
-          to: "Router_Q1uTcWa1rZ",
-        },
-        {
-          type: "edge",
-          key: "Code_1uEOTXgBNQ/Iterating_CsvbR5teUm",
-          from: "Code_1uEOTXgBNQ",
-          to: "Iterating_CsvbR5teUm",
-        },
-        {
-          type: "agent",
-          key: "Iterating_CsvbR5teUm/Agent_DiQbU6FKZ6",
-          from: "Iterating_CsvbR5teUm",
-          to: "Agent_DiQbU6FKZ6",
-        },
-        {
-          type: "edge",
-          key: "Iterating_CsvbR5teUm/Answer_SowVtmiosK",
-          from: "Iterating_CsvbR5teUm",
-          to: "Answer_SowVtmiosK",
-        },
-      ],
-    }
-
-    const key = 'Agent_xv0UeM91O6'
-    const workflowNodes = allChannels(graph as TXpertGraph, key)
-    expect(workflowNodes).toEqual(expect.arrayContaining([
-      'Agent_xv0UeM91O6',
-      'Knowledge_PJ2H5EObqJ',
-      'Code_1uEOTXgBNQ',
-      'Iterating_CsvbR5teUm',
-      'Answer_SowVtmiosK',
-    ]))
-
-    expect(workflowNodes).toEqual(expect.not.arrayContaining(['Router_Q1uTcWa1rZ']))
-  })
-})

package/src/agent/utils.ts

@@ -1,122 +0,0 @@
-import { isRouterKey } from '../ai'
-import { TXpertGraph } from '../ai/xpert.model'
-import { DeepPartial } from '../types'
-
-/**
- * Channels of all upstream and downstream nodes relative to the starting point startKey.
- *
- * @param graph
- * @param startKey
- */
-export function allChannels(graph: TXpertGraph, startKey: string) {
-  graph = getCurrentGraph(graph, startKey)
-  return graph.nodes.filter((node) => !(node.type === 'workflow' && isRouterKey(node.key))).map((node) => node.key)
-}
-
-export function findStartNodes(graph: DeepPartial<TXpertGraph>, key: string): string[] {
-  const toMap = new Map<string, string[]>()
-  // Consider only horizontal processes
-  const connections = graph.connections.filter((_) => _.type === 'edge')
-  // Construct toMap: record all upstream nodes of each node
-  for (const conn of connections) {
-    if (!toMap.has(conn.to)) toMap.set(conn.to, [])
-    const [fromKey] = conn.from.split('/')
-    if (conn.type === 'edge') {
-      toMap.get(conn.to).push(fromKey)
-    }
-  }
-
-  const result = new Set<string>()
-
-  const checked = []
-  // Recursively search upstream until you reach the starting point
-  function dfsUp(nodeKey: string) {
-    checked.push(nodeKey)
-    const parents = toMap.get(nodeKey)
-
-    // There is no upstream, this is the starting point
-    if (!parents || parents.length === 0) {
-      result.add(nodeKey)
-      return
-    }
-
-    for (const parent of parents) {
-      // There is a cycle
-      if (checked.includes(parent)) {
-        return
-      }
-      dfsUp(parent)
-    }
-  }
-
-  dfsUp(key)
-
-  return Array.from(result)
-}
-
-/**
- * Keep the content in the same graph as the key node (including the node, its connected nodes, and the 'edge' type connections between them)
- * 
- * @param graph 
- * @param key 
- * @returns 
- */
-export function getCurrentGraph(graph: TXpertGraph, key: string): TXpertGraph {
-  const validConnections = graph.connections.filter(conn => conn.type === 'edge')
-
-  // Extract the primary key (remove the / suffix)
-  const normalize = (k: string) => k.split('/')[0]
-
-  // Adjacency list: bidirectional (because you want to traverse the current graph)
-  const adjacency = new Map<string, Set<string>>()
-
-  for (const conn of validConnections) {
-    const from = normalize(conn.from)
-    const to = normalize(conn.to)
-
-    if (!adjacency.has(from)) adjacency.set(from, new Set())
-    if (!adjacency.has(to)) adjacency.set(to, new Set())
-
-    adjacency.get(from).add(to)
-    adjacency.get(to).add(from)
-  }
-
-  const visited = new Set<string>()
-  const queue: string[] = key ? [normalize(key)] : []
-
-  // BFS/DFS collects all nodes in the same graph
-  while (queue.length > 0) {
-    const current = queue.pop()
-    if (visited.has(current)) continue
-    visited.add(current)
-
-    const neighbors = adjacency.get(current) || new Set()
-    for (const neighbor of neighbors) {
-      if (!visited.has(neighbor)) {
-        queue.push(neighbor)
-      }
-    }
-  }
-
-  const nodeSet = new Set(graph.nodes.map(n => n.key))
-  const keptNodes = graph.nodes.filter(n => visited.has(normalize(n.key)))
-  const keptNodeKeys = new Set(keptNodes.map(n => n.key))
-
-  const keptConnections = validConnections.filter(conn => {
-    const from = normalize(conn.from)
-    const to = normalize(conn.to)
-    return visited.has(from) && visited.has(to)
-  })
-
-  return {
-    nodes: keptNodes,
-    connections: keptConnections
-  }
-}
-
-export function shortTitle(input: string) {
-  if (input) {
-    return input.length <= 50 ? input : input.slice(0, 50) + '...'
-  }
-  return null
-}

package/src/agent/variables.ts

@@ -1,66 +0,0 @@
-import { TWorkflowVarGroup } from "../ai/xpert-workflow.model"
-import { TXpertParameter, XpertParameterTypeEnum } from "../ai/xpert.model"
-
-/**
- * 
- * Returns the variable schema for a given variable name.
- * The variable name can be in the format of 'groupName.variableName' or just 'variableName'.
- * 
- * @param variables 
- * @param variable 
- * @returns 
- */
-export function getVariableSchema(variables: TWorkflowVarGroup[], variable: string) {
-    const [groupName, ...rest] = variable?.split('.') ?? []
-
-    const group = variables?.find((_) => (rest.length ? _.group?.name === groupName : !_.group?.name))
-
-    return {
-        group,
-        variable: group?.variables.find((_) => _.name === (rest.join('.') || groupName))
-    }
-}
-
-export const FILE_VARIABLES: TXpertParameter[] = [
-    {
-        name: 'filePath',
-        type: XpertParameterTypeEnum.STRING,
-        description: {
-            en_US: 'The path to the file',
-            zh_Hans: '文件的路径'
-        },
-
-    },
-    {
-        name: 'fileName',
-        type: XpertParameterTypeEnum.STRING,
-        description: {
-            en_US: 'The name of the file',
-            zh_Hans: '文件的名称'
-        },
-    },
-    {
-        name: 'fileUrl',
-        type: XpertParameterTypeEnum.STRING,
-        description: {
-            en_US: 'The URL of the file',
-            zh_Hans: '文件的URL地址'
-        },
-    },
-    {
-        name: 'fileSize',
-        type: XpertParameterTypeEnum.NUMBER,
-        description: {
-            en_US: 'The size of the file in bytes',
-            zh_Hans: '文件的大小，单位为字节'
-        },
-    },
-    {
-        name: 'mimeType',
-        type: XpertParameterTypeEnum.STRING,
-        description: {
-            en_US: 'The MIME type of the file',
-            zh_Hans: '文件的MIME类型'
-        },
-    }
-]

package/src/ai/ai-model.model.ts

@@ -1,232 +0,0 @@
-import { AiModelTypeEnum } from '../agent/'
-import { IBasePerTenantAndOrganizationEntityModel } from '../base-entity.model'
-import { I18nObject } from '../types'
-import { ICopilot } from './copilot.model'
-
-
-export interface IAiModel extends IBasePerTenantAndOrganizationEntityModel {
-  /**
-   * Model name
-   */
-  name: string
-
-  /**
-   * Model display name
-   */
-  label: string
-
-  /**
-   * Model type
-   */
-  modelType: string
-
-  /**
-   * Model features
-   */
-  features: string[]
-
-  /**
-   * Model properties
-   */
-  modelProperties: Record<string, any>
-
-  /**
-   * Parameter rules
-   */
-  parameterRules: Record<string, any>[]
-
-  /**
-   * Pricing information
-   */
-  pricing: {
-    input: string
-    output: string
-    unit: string
-    currency: string
-  }
-
-  /**
-   * Deprecated
-   */
-  deprecated: boolean
-}
-
-export enum ProviderType {
-  CUSTOM = 'custom',
-  SYSTEM = 'system'
-}
-
-export interface ICopilotWithProvider extends ICopilot {
-  providerWithModels: Partial<IAiProviderEntity>
-}
-
-export interface IAiProviderEntity {
-  provider: string;
-  label: I18nObject;
-  description: I18nObject;
-  icon_small: I18nObject;
-  icon_large: I18nObject;
-  background: string;
-  help: ProviderHelpInfo;
-  supported_model_types: AiModelTypeEnum[];
-  configurate_methods: ConfigurateMethod[];
-  model_credential_schema: ModelCredentialSchema;
-  provider_credential_schema: ProviderCredentialSchema;
-  models: ProviderModel[]
-  /**
-   * Not yet implemented, your contribution is needed
-   */
-  not_implemented?: boolean
-}
-
-export interface ProviderHelpInfo {
-  title: I18nObject;
-  url: I18nObject;
-}
-
-export interface ProviderModel {
-  model: string;
-  label: I18nObject;
-  model_type: AiModelTypeEnum;
-  features?: ModelFeature[];
-  fetch_from: FetchFrom;
-  model_properties: Partial<Record<ModelPropertyKey, any>>;
-  deprecated?: boolean;
-  modelConfig?: any;
-}
-
-export interface ProviderCredentialSchema {
-  credential_form_schemas: CredentialFormSchema[];
-}
-
-/**
- * @todo Use JSON Schema to implement
- */
-export enum CredentialFormTypeEnum {
-  TEXT_INPUT = "text-input",
-  SECRET_INPUT = "secret-input",
-  SELECT = "select",
-  RADIO = "radio",
-  // SWITCH = "switch", // use ParameterType.BOOLEAN
-}
-
-export interface CredentialFormSchema {
-  variable: string;
-  label: I18nObject;
-  type: CredentialFormTypeEnum | ParameterType
-  required: boolean;
-  default?: number | string | boolean
-  options?: {
-    label: I18nObject
-    value: number | string | boolean
-    show_on?: FormShowOnObject[]
-  }[]
-  placeholder: I18nObject;
-
-  max_length?: number
-  show_on?: FormShowOnObject[]
-}
-
-export interface FormShowOnObject {
-  variable: string
-  value: string
-}
-
-export enum FetchFrom {
-  PREDEFINED_MODEL = "predefined-model",
-  CUSTOMIZABLE_MODEL = "customizable-model"
-}
-
-export enum ModelFeature {
-  TOOL_CALL = "tool-call",
-  MULTI_TOOL_CALL = "multi-tool-call",
-  AGENT_THOUGHT = "agent-thought",
-  VISION = "vision",
-  STREAM_TOOL_CALL = "stream-tool-call",
-  VIDEO = "video",
-  STRUCTURED_OUTPUT = "structured-output"
-}
-
-export enum ModelPropertyKey {
-  MODE = "mode",
-  CONTEXT_SIZE = "context_size",
-  MAX_CHUNKS = "max_chunks",
-  FILE_UPLOAD_LIMIT = "file_upload_limit",
-  SUPPORTED_FILE_EXTENSIONS = "supported_file_extensions",
-  MAX_CHARACTERS_PER_CHUNK = "max_characters_per_chunk",
-  DEFAULT_VOICE = "default_voice",
-  VOICES = "voices",
-  WORD_LIMIT = "word_limit",
-  AUDIO_TYPE = "audio_type",
-  MAX_WORKERS = "max_workers"
-}
-
-export enum ConfigurateMethod {
-  PREDEFINED_MODEL = 'predefined-model',
-  CUSTOMIZABLE_MODEL = 'customizable-model'
-}
-
-/**
- * @todo Use JSON Schema to implement
- */
-export enum ParameterType {
-  FLOAT = "float",
-  INT = "int",
-  STRING = "string",
-  BOOLEAN = "boolean",
-  TEXT = "text"
-}
-
-/**
- * @todo Use JSON Schema to implement
- */
-export interface ParameterRule {
-  name?: string;
-  useTemplate?: string;
-  label: I18nObject;
-  type: ParameterType;
-  help?: I18nObject;
-  required?: boolean;
-  default?: any;
-  min?: number;
-  max?: number;
-  precision?: number;
-  options?: string[];
-}
-
-export interface PriceConfig {
-  input: number;
-  output?: number;
-  unit: number;
-  currency: string;
-}
-
-export interface AIModelEntity extends ProviderModel {
-  parameter_rules?: ParameterRule[]
-  pricing?: PriceConfig
-}
-
-export interface FieldModelSchema {
-  label: I18nObject
-  placeholder?: I18nObject
-}
-    
-
-export interface ModelCredentialSchema {
-  model: FieldModelSchema
-  credential_form_schemas: CredentialFormSchema[]
-}
-
-export const AI_MODEL_TYPE_VARIABLE = "__model_type"
-
-export enum PriceType {
-  INPUT = "input",
-  OUTPUT = "output"
-}
-
-export interface PriceInfo {
-  unitPrice: number;
-  unit: number;
-  totalAmount: number;
-  currency: string;
-}