@metad/contracts 3.6.2 → 3.6.7

package/jest.config.ts

@@ -0,0 +1,16 @@
+/* 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@metad/contracts",
-  "version": "3.6.2",
+  "version": "3.6.7",
   "license": "AGPL-3.0",
   "repository": {
     "type": "git",
@@ -14,4 +14,4 @@
   },
   "module": "./index.esm.js",
   "main": "./index.cjs.js"
-}
+}

package/project.json

@@ -0,0 +1,53 @@
+{
+  "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": "packages/contracts/dist",
+        "project": "packages/contracts/package.json",
+        "main": "packages/contracts/src/index.ts",
+        "tsConfig": "packages/contracts/tsconfig.lib.json",
+        "assets": [
+          {
+            "glob": "README.md",
+            "input": "packages/contracts/",
+            "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"
+      }
+    },
+    "nx-release-publish": {
+      "executor": "@nx/js:release-publish",
+      "options": {
+        "packageRoot": "packages/contracts/dist",
+        "access": "public"
+      }
+    }
+  },
+  "tags": []
+}

package/src/agent/{ai-model.d.ts → ai-model.ts}

@@ -1,4 +1,4 @@
-export declare enum AiModelTypeEnum {
+export enum AiModelTypeEnum {
     LLM = "llm",
     TEXT_EMBEDDING = "text-embedding",
     RERANK = "rerank",
@@ -6,4 +6,4 @@ export declare enum AiModelTypeEnum {
     MODERATION = "moderation",
     TTS = "tts",
     TEXT2IMG = "text2img"
-}
+}

package/src/agent/graph.ts

@@ -0,0 +1,275 @@
+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_SYS_VOLUME = 'volume'
+export const STATE_SYS_WORKSPACE_PATH = 'workspace_path'
+export const STATE_SYS_WORKSPACE_URL = 'workspace_url'
+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

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

package/src/agent/token.ts

@@ -0,0 +1,23 @@
+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

@@ -0,0 +1,283 @@
+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']))
+  })
+})