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

package/src/visibility.model.d.ts

@@ -0,0 +1,6 @@
+export declare enum Visibility {
+    Public = "public",
+    Internal = "internal",
+    Secret = "secret",
+    Private = "private"
+}

package/.babelrc

@@ -1,5 +0,0 @@
-{
-  "presets": [
-    "@nrwl/js/babel"
-  ]
-}

package/.eslintrc.json

@@ -1,18 +0,0 @@
-{
-  "extends": ["../../.eslintrc.json"],
-  "ignorePatterns": ["!**/*"],
-  "overrides": [
-    {
-      "files": ["*.ts", "*.tsx", "*.js", "*.jsx"],
-      "rules": {}
-    },
-    {
-      "files": ["*.ts", "*.tsx"],
-      "rules": {}
-    },
-    {
-      "files": ["*.js", "*.jsx"],
-      "rules": {}
-    }
-  ]
-}

package/babel.config.json

@@ -1 +0,0 @@
-{}

package/jest.config.ts

@@ -1,16 +0,0 @@
-/* eslint-disable */
-export default {
-  displayName: 'contracts',
-  preset: '../../jest.preset.js',
-  globals: {},
-  transform: {
-    '^.+\\.[tj]s$': [
-      'ts-jest',
-      {
-        tsconfig: '<rootDir>/tsconfig.spec.json'
-      }
-    ]
-  },
-  moduleFileExtensions: ['ts', 'js', 'html'],
-  coverageDirectory: '../../coverage/packages/contracts'
-}

package/project.json

@@ -1,46 +0,0 @@
-{
-  "name": "contracts",
-  "$schema": "../../node_modules/nx/schemas/project-schema.json",
-  "sourceRoot": "packages/contracts/src",
-  "projectType": "library",
-  "targets": {
-    "build": {
-      "executor": "@nx/rollup:rollup",
-      "outputs": ["{options.outputPath}"],
-      "options": {
-        "outputPath": "dist/packages/contracts",
-        "project": "packages/contracts/package.json",
-        "main": "packages/contracts/src/index.ts",
-        "tsConfig": "packages/contracts/tsconfig.lib.json",
-        "assets": [
-          {
-            "glob": "README.md",
-            "input": ".",
-            "output": "."
-          }
-        ],
-        "compiler": "swc",
-        "format": ["cjs", "esm"]
-      }
-    },
-    "publish": {
-      "command": "node tools/scripts/publish.mjs contracts {args.ver} {args.tag}",
-      "dependsOn": ["build"]
-    },
-    "lint": {
-      "executor": "@nx/eslint:lint",
-      "outputs": ["{options.outputFile}"],
-      "options": {
-        "lintFilePatterns": ["packages/contracts/**/*.ts", "packages/contracts/package.json"]
-      }
-    },
-    "test": {
-      "executor": "@nx/jest:jest",
-      "outputs": ["{workspaceRoot}/coverage/packages/contracts"],
-      "options": {
-        "jestConfig": "packages/contracts/jest.config.ts"
-      }
-    }
-  },
-  "tags": []
-}

package/src/agent/graph.ts

@@ -1,272 +0,0 @@
-import { BaseMessage } from '@langchain/core/messages'
-import { RunnableConfig } from '@langchain/core/runnables'
-import { Subscriber } from 'rxjs'
-import { IWFNTrigger, TWorkflowVarGroup, WorkflowNodeTypeEnum } from '../ai/xpert-workflow.model'
-import { TMessageContentComplex } from '../ai/chat-message.model'
-import { I18nObject } from '../types'
-import { TStateVariable, TXpertGraph, TXpertParameter, TXpertTeamNode, XpertParameterTypeEnum } from '../ai/xpert.model'
-import { agentLabel, IXpertAgent } from '../ai/xpert-agent.model'
-
-/**
- * @deprecated can use getCurrentTaskInput instead?
- */
-export const CONTEXT_VARIABLE_CURRENTSTATE = 'currentState'
-export const STATE_VARIABLE_SYS = 'sys'
-export const STATE_VARIABLE_HUMAN = 'human'
-export const GRAPH_NODE_SUMMARIZE_CONVERSATION = 'summarize_conversation'
-export const GRAPH_NODE_TITLE_CONVERSATION = 'title_conversation'
-export const STATE_VARIABLE_FILES = 'files'
-export const STATE_VARIABLE_INPUT = 'input'
-export const STATE_VARIABLE_TITLE_CHANNEL = channelName('title')
-
-export type TMessageChannel = {
-  system: string
-  messages: BaseMessage[]
-  summary?: string
-  error?: string | null
-}
-
-export type TAgentRunnableConfigurable = {
-  /**
-   * Thread id
-   */
-  thread_id: string
-  checkpoint_ns: string
-  checkpoint_id: string
-  tool_call_id?: string
-
-  // Custom configurable of invoke
-  tenantId: string
-  organizationId: string
-  language: string
-  userId: string
-  /**
-   * Xpert project id
-   */
-  projectId?: string
-  xpertId?: string
-  // Caller
-  agentKey: string
-  xpertName?: string
-  toolName?: string
-
-  subscriber: Subscriber<any>
-  /**
-   * Execution id of agent workflow node
-   */
-  executionId: string
-//   /**
-//    * Knowledge xpert's knowledgebase
-//    */
-//   knowledgebaseId?: string
-//   knowledgeTaskId?: string
-  
-  signal?: AbortSignal
-}
-
-export type TToolCall = {
-	id?: string
-	name: string
-	type?: 'tool_call'
-	args: Record<string, any>
-}
-
-/**
- * 
- * Example:
- * 
- * ```typescript
- *  const result = interrupt<TInterruptMessage<{ name: string }>, { projectId: string }>({
- *		category: 'BI',
- *		type: 'switch_project',
- *		title: {
- *			en_US: 'Switch project',
- *			zh_Hans: '切换项目'
- *		},
- *		message: {
- *			en_US: 'Please select a project or create a new one',
- *			zh_Hans: '请选择或创建一个新的项目'
- *		},
- *		data: { name: '' }
- *	})
- * ```
- */
-export type TInterruptMessage<T = unknown> = {
-	/**
-	 * Major categories of interrupt components
-	 */
-	category: 'BI'
-	/**
-	 * The specific type of interactive component
-	 */
-	type: string
-	/**
-	 * Title of the interrupt component
-	 */
-	title: string | I18nObject
-	/**
-	 * Message content of the interrupt component
-	 */
-	message: string | I18nObject
-	/**
-	 * Additional data
-	 */
-	data?: T
-}
-
-export type TInterruptCommand = {
-  resume?: any
-  update?: any
-  toolCalls?: TToolCall[]
-  agentKey?: string
-}
-
-// Helpers
-export function channelName(name: string) {
-	return name.toLowerCase() + '_channel'
-}
-
-export function messageContentText(content: string | TMessageContentComplex) {
-	return typeof content === 'string' ? content : content.type === 'text' ? content.text : ''
-}
-
-export function getWorkspaceFromRunnable(configurable: TAgentRunnableConfigurable): {type?: 'project' | 'conversation'; id?: string} {
-	return configurable?.projectId  ? {type: 'project', id: ''} : 
-		configurable?.thread_id ? {
-			type: 'conversation',
-			id: configurable.thread_id
-		} : {}
-  }
-
-export function getToolCallFromConfig(config): TToolCall {
-	return config?.toolCall	|| config?.configurable?.toolCall
-}
-
-export function getToolCallIdFromConfig(config): string {
-	return config.metadata?.tool_call_id || config?.configurable?.tool_call_id || getToolCallFromConfig(config)?.id 
-}
-
-/**
- * Compute long-term memory namespace:
- * 1. When a user talks to a digital expert individually, use `ExpertId` + `UserId` to store memory
- * 2. When talking to a digital expert in a project, all users and digital experts share `ProjectId` to store memory
- * 
- * @param config 
- * @returns 
- */
-export function getStoreNamespace(config: RunnableConfig): string[] {
-	const configurable = config.configurable as TAgentRunnableConfigurable
-	return configurableStoreNamespace(configurable)
-}
-
-export function configurableStoreNamespace(configurable: Partial<TAgentRunnableConfigurable>): string[] {
-	return configurable?.projectId ? [configurable?.projectId] : configurable?.userId ? [configurable.xpertId, configurable.userId] : []
-}
-
-/**
- * Set value into variable of state.
- * 
- * @param state 
- * @param varName 
- * @param value 
- * @returns 
- */
-export function setStateVariable(state: Record<string, any>, varName: string, value: any) {
-	const [agentChannelName, variableName] = varName.split('.')
-	if (variableName) {
-		state[agentChannelName] = {
-			...(state[agentChannelName] ?? {}),
-			[variableName]: value
-		}
-	} else {
-		state[agentChannelName] = value
-	}
-
-	return state
-}
-
-/**
- * Get agent variable group from graph.
- * 
- * @param key 
- * @param graph 
- * @returns 
- */
-export function getAgentVarGroup(key: string, graph: TXpertGraph): TWorkflowVarGroup {
-	const node = graph.nodes.find((_) => _.type === 'agent' && _.key === key) as TXpertTeamNode & {type: 'agent'}
-
-	const variables: TXpertParameter[] = []
-	const varGroup: TWorkflowVarGroup = {
-		group: {
-			name: channelName(node.key),
-			description: {
-				en_US: agentLabel(node.entity)
-			},
-		},
-		variables
-	}
-
-	variables.push({
-		name: `messages`,
-		type: XpertParameterTypeEnum.ARRAY,
-		description: {
-			zh_Hans: `消息列表`,
-			en_US: `Message List`
-		}
-	})
-	variables.push({
-		name: `output`,
-		type: XpertParameterTypeEnum.STRING,
-		description: {
-			zh_Hans: `输出`,
-			en_US: `Output`
-		}
-	})
-	variables.push({
-		name: `error`,
-		type: XpertParameterTypeEnum.STRING,
-		description: {
-			zh_Hans: `错误`,
-			en_US: `Error`
-		}
-	})
-	const agent = <IXpertAgent>node.entity
-	if (agent.options?.structuredOutputMethod && agent.outputVariables) {
-		agent.outputVariables.forEach((variable) => {
-			variables.push({
-				name: variable.name || '',
-				type: variable.type as TStateVariable['type'],
-				description: variable.description,
-				item: variable.item
-			})
-		})
-	}
-
-	return varGroup
-}
-
-
-// Swarm
-/**
- * Get swarm partners of agent in team
- * 
- * @param graph 
- * @param agentKey 
- */
-export function getSwarmPartners(graph: TXpertGraph, agentKey: string, partners: string[], leaderKey?: string) {
-  const connections = graph.connections.filter((conn) => conn.type === 'agent' && conn.to === agentKey && (leaderKey ? conn.from !== leaderKey : true)
-		&& graph.connections.some((_) => _.type === 'agent' && _.to === conn.from && _.from === agentKey))
-
-  connections.forEach((conn) => {
-	const key = conn.from
-	if (partners.indexOf(key) < 0) {
-		partners.push(key)
-		getSwarmPartners(graph, key, partners)
-	}
-  })
-  return partners
-}
-
-export function getWorkflowTriggers(graph: TXpertGraph, from: string) {
-	return graph.nodes.filter((node) => node.type === 'workflow' && node.entity.type === WorkflowNodeTypeEnum.TRIGGER && (<IWFNTrigger>node.entity).from === from)
-}

package/src/agent/index.ts

@@ -1,5 +0,0 @@
-export * from './ai-model'
-export * from './token'
-export * from './graph'
-export * from './utils'
-export * from './variables'

package/src/agent/token.ts

@@ -1,23 +0,0 @@
-export type TTokenUsage = {
-  promptTokens: number
-  completionTokens: number
-  totalTokens: number
-}
-
-export interface IModelUsage {
-  totalTokens: number
-  totalPrice: number
-  currency: string
-  latency: number
-}
-
-export interface ILLMUsage extends IModelUsage {
-  promptTokens: number
-  promptUnitPrice: number
-  promptPriceUnit: number
-  promptPrice: number
-  completionTokens: number
-  completionUnitPrice: number
-  completionPriceUnit: number
-  completionPrice: number
-}

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']))
-  })
-})