@metad/contracts 0.0.1 → 3.6.0-beta.1

package/.babelrc

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

package/.eslintrc.json

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

package/README.md

@@ -1 +1,3 @@
-# Pangolin
+# contracts
+
+Contacts is a package that contains all the types used in the ocap project.

package/babel.config.json

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

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,8 +1,8 @@
 {
   "name": "@metad/contracts",
-  "version": "0.0.1",
-  "module": "./index.js",
-  "main": "./index.cjs",
-  "type": "module",
-  "types": "./index.d.ts"
+  "version": "3.6.0-beta.1",
+  "license": "AGPL-3.0",
+  "scripts": {
+    "docs": "yarn typedoc --out ./.docs"
+  }
 }

package/project.json

@@ -0,0 +1,46 @@
+{
+  "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/ai-model.ts

@@ -0,0 +1,9 @@
+export enum AiModelTypeEnum {
+    LLM = "llm",
+    TEXT_EMBEDDING = "text-embedding",
+    RERANK = "rerank",
+    SPEECH2TEXT = "speech2text",
+    MODERATION = "moderation",
+    TTS = "tts",
+    TEXT2IMG = "text2img"
+}

package/src/agent/graph.ts

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

@@ -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
+}