@vyr/service-chat 0.0.34

package/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "@vyr/service-chat",
+  "version": "0.0.34",
+  "description": "",
+  "main": "src/index.ts",
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "@matechat/core": "^1.5.2",
+    "@mdit/plugin-katex": "^0.24.2",
+    "devui-theme": "^0.1.0",
+    "mermaid": "^11.12.2"
+  },
+  "devDependencies": {
+    "sass": "^1.32.0"
+  }
+}

package/src/ChatService.ts

@@ -0,0 +1,104 @@
+import z from 'zod'
+import { reactive } from "vue";
+import { MastraClient } from "@mastra/client-js";
+import { AsyncTask } from "@vyr/engine";
+import { Option } from "@vyr/design";
+import { Service } from "@vyr/service";
+import { DraggableService, runtime } from "@vyr/runtime";
+import { api, request, ChatWindow as _Window, GatewayService, } from "@vyr/service-gateway"
+import { ChatSession, ChatWindowManager } from "./chat"
+import { Draggable } from "./common";
+import { bindExecutor } from "./executor";
+
+class ChatService extends Service {
+    private static _client: MastraClient | null = null
+    static get client() {
+        if (this._client === null) {
+            const location = new URL(window.location.href)
+            location.pathname = api.chat.prefix.path
+            this._client = new MastraClient({ baseUrl: location.origin + location.pathname, retries: 0, fetch: ChatSession.fetch })
+        }
+        return this._client
+    }
+    readonly initializeTask: AsyncTask
+    readonly manager = reactive<ChatWindowManager>(new ChatWindowManager())
+    agents: Option[] = []
+
+    constructor(name: string) {
+        super(name)
+        this.initializeTask = new AsyncTask(async () => {
+            await this.manager.initialize()
+            await this.initialize()
+        })
+    }
+
+    async initialize() {
+        const collection = await ChatService.client.listAgents()
+        const keys = Object.keys(collection)
+        for (const key of keys) {
+            this.agents.push({ label: key, value: collection[key].id })
+        }
+        const agent = this.agents[0]
+        if (agent) this.manager.window.agentId = agent.value
+    }
+
+    async setup() {
+        const draggableService = runtime.get<DraggableService>('draggable')
+        const draggable = new Draggable()
+        draggableService.set(draggable.id, draggable)
+    }
+
+    async ready() {
+        const gatewayService = runtime.get<GatewayService>('gateway')
+        bindExecutor(gatewayService)
+    }
+
+    async start() {
+        await this.initializeTask.done()
+    }
+
+    getDefaultAgentId() {
+        return this.agents[0]?.value ?? ''
+    }
+
+
+    async list(data: z.infer<typeof api.chat.list.requestSchema>) {
+        const res = await request<{ list: _Window[] }>({
+            url: api.chat.list.path,
+            method: api.chat.list.method,
+            data,
+        })
+
+        return res.data
+    }
+
+    async create(data: z.infer<typeof api.chat.create.requestSchema>) {
+        await request<{ list: _Window[] }>({
+            url: api.chat.create.path,
+            method: api.chat.create.method,
+            data,
+        })
+    }
+
+    async delete(data: z.infer<typeof api.chat.delete.requestSchema>) {
+        await request({
+            url: api.chat.delete.path,
+            method: api.chat.delete.method,
+            data,
+        })
+    }
+
+    async stop(data: z.infer<typeof api.chat.stop.requestSchema>) {
+        const res = await request<{ success: boolean }>({
+            url: api.chat.stop.path,
+            method: api.chat.stop.method,
+            data,
+        })
+
+        return res.data
+    }
+}
+
+export {
+    ChatService
+}

package/src/chat/ChatHistory.ts

@@ -0,0 +1,127 @@
+import { MastraDBMessage } from "@mastra/core/agent";
+import { TaskItem } from "../components/executor/types";
+import { ChatWindow } from "./ChatWindow";
+
+interface ChatMessageTextChunk {
+    type: 'text'
+    content: string
+}
+
+interface ChatMessageReasoningChunk {
+    type: 'reasoning'
+    content: string
+}
+
+interface ChatMessageToolChunk {
+    type: 'tool'
+    collection: Map<string, TaskItem>
+}
+
+type ChatMessageChunk = ChatMessageTextChunk | ChatMessageReasoningChunk | ChatMessageToolChunk
+
+interface ChatMessageTool {
+    toolName: string
+    args: any
+}
+
+class ChatMessage {
+    id: string
+    role: 'user' | 'assistant' | 'system';
+    chunks: ChatMessageChunk[]
+    avatarPosition: 'side-left' | 'side-right';
+    avatarConfig?: string
+    loading?: boolean
+    complete?: boolean;
+    current?: ChatMessageChunk
+
+    constructor(msg: Partial<ChatMessage> = {}) {
+        this.id = msg.id ?? ''
+        this.role = msg.role ?? 'assistant'
+        this.chunks = msg.chunks ?? []
+        this.avatarPosition = `side-${this.role === 'user' ? 'right' : 'left'}`
+        this.avatarConfig = `logo/${this.role === 'user' ? 'chat' : '透明图标'}.png`
+        this.loading = msg.loading ?? false
+        this.complete = msg.complete ?? true
+    }
+
+    add(chunk: ChatMessageChunk) {
+        this.chunks.push(chunk)
+        this.current = chunk
+    }
+
+    startNewChunk(type: ChatMessageChunk['type'], initialContent = '') {
+        let currentChunk: ChatMessageChunk
+        if (type === 'tool') {
+            currentChunk = { type, collection: new Map }
+        } else {
+            currentChunk = { type, content: initialContent }
+        }
+        this.add(currentChunk)
+        return currentChunk
+    }
+
+    startToolChunk(): ChatMessageToolChunk {
+        const chunk = this.chunks[this.chunks.length - 1]
+        if (chunk === undefined || chunk.type !== 'tool') {
+            return this.startNewChunk('tool') as ChatMessageToolChunk
+        } else {
+            return chunk
+        }
+    }
+
+    addFromParts(parts: { type: string, [k: string]: any }[]) {
+        for (const part of parts) {
+            if (part.type === 'text') {
+                if (part.text.length === 0) continue
+                this.add({ type: 'text', content: part.text })
+            } else if (part.type === 'reasoning') {
+                if (part.reasoning.length === 0) continue
+                this.add({ type: 'reasoning', content: part.reasoning })
+            } else if (part.type === 'tool-invocation') {
+                const tool = part.toolInvocation as any
+                const chunk = this.startToolChunk()
+                chunk.collection.set(tool.toolCallId, {
+                    ...tool,
+                    state: tool.result?.error ? 'failed' : 'success'
+                })
+            }
+        }
+    }
+}
+
+class ChatHistory {
+    private messages: ChatMessage[] = []
+    get list() {
+        return [...this.messages]
+    }
+    lastMessage!: ChatMessage
+
+    addMessage(msg: ChatMessage) {
+        this.messages.push(msg)
+        this.lastMessage = msg
+    }
+
+    addMessageFromRecord(record: MastraDBMessage) {
+        const chatMsg = new ChatMessage({ role: record.role })
+        chatMsg.addFromParts(record.content.parts)
+        this.addMessage(chatMsg)
+    }
+
+    async restore(window: ChatWindow) {
+        try {
+            const thread = await window.getThread()
+            const result = await thread.listMessages({ resourceId: window.threadId })
+            for (const record of result.messages) this.addMessageFromRecord(record)
+        } catch (error) {
+            console.log(error)
+        }
+    }
+}
+
+export {
+    ChatMessageToolChunk,
+    ChatMessageChunk,
+    ChatMessageTool,
+    ChatMessage,
+    ChatHistory,
+}

package/src/chat/ChatSession.ts

@@ -0,0 +1,183 @@
+import z from 'zod'
+import { MastraMessagePart } from "@mastra/core/agent/message-list"
+import { RequestContext } from "@mastra/core/request-context"
+import { AsyncTask, Generate } from "@vyr/engine"
+import { runtime } from "@vyr/runtime"
+import { api, GatewayService, setAuthorization, setClient } from "@vyr/service-gateway"
+import { UserService } from "@vyr/service-user"
+import { language } from "../locale"
+import { TaskItem } from "../components/executor/types"
+import { ChatMessage, ChatMessageChunk } from "./ChatHistory"
+import { ChatWindow } from "./ChatWindow"
+import { ChatService } from "../ChatService"
+
+class ChatSession {
+    static fetch = async (input: RequestInfo | URL, init?: RequestInit) => {
+        const modifiedInit = { ...init }
+        if (modifiedInit.headers === undefined) modifiedInit.headers = {}
+        setAuthorization(modifiedInit.headers, UserService.getToken())
+        setClient(modifiedInit.headers)
+
+        return fetch(input, modifiedInit)
+    }
+    private executor
+    readonly runId = Generate.uuid()
+    readonly window
+
+    constructor(window: ChatWindow) {
+        this.window = window
+        this.executor = new AsyncTask(this.start)
+    }
+
+    private onChunk = async (chunk: any) => {
+        if (chunk.type === 'start') {
+            this.window.history.lastMessage.id = chunk?.payload?.messageId ?? ''
+        }
+
+        if (chunk.type === 'text-start' || chunk.type === 'reasoning-start') {
+            this.window.history.lastMessage.loading = false
+        }
+
+        if (chunk.type === 'tool-call') {
+            this.window.history.lastMessage.loading = false
+            const payload = chunk.payload ?? {}
+            const toolChunk = this.window.history.lastMessage.startToolChunk()
+            toolChunk.collection.set(payload.toolCallId, {
+                ...payload,
+                state: 'running',
+            })
+        }
+
+        if (chunk.type === 'tool-result') {
+            const payload = chunk.payload || {};
+            const toolChunk = this.window.history.lastMessage.startToolChunk()
+            const task = toolChunk.collection.get(payload.toolCallId) as TaskItem
+            task.state = payload.result?.error ? 'failed' : 'success'
+            task.result = payload.result
+            return
+        }
+
+        if (chunk.type === 'text-delta' && chunk.payload?.text) {
+            if (!this.window.history.lastMessage.current || this.window.history.lastMessage.current.type !== 'text') {
+                this.window.history.lastMessage.startNewChunk('text', chunk.payload.text)
+            } else {
+                this.window.history.lastMessage.current.content += chunk.payload.text
+            }
+            return
+        }
+
+        if (chunk.type === 'reasoning-delta' && chunk.payload?.text) {
+            if (!this.window.history.lastMessage.current || this.window.history.lastMessage.current.type !== 'reasoning') {
+                this.window.history.lastMessage.startNewChunk('reasoning', chunk.payload.text)
+            } else {
+                this.window.history.lastMessage.current.content += chunk.payload.text;
+            }
+            return
+        }
+
+        // 成功完成
+        if (chunk.type === 'finish') {
+            return
+        }
+
+        // 异常终止
+        if (chunk.type === 'error') {
+            return;
+        }
+
+        console.log('未处理的数据块类型:', chunk.type)
+    }
+
+    private start = async (question: string) => {
+        this.window.history.addMessage(new ChatMessage({ role: 'user', chunks: [{ type: 'text', content: question }] }))
+        this.window.history.addMessage(new ChatMessage({ role: 'assistant', complete: false, loading: true }))
+
+        const requestContext = new RequestContext()
+        requestContext.set('client', GatewayService.client)
+
+        const response = await this.window.getAgent().stream(question, {
+            runId: this.runId,
+            memory: { thread: this.window.threadId, resource: this.window.threadId },
+            requestContext
+        })
+        await response.processDataStream({ onChunk: this.onChunk })
+
+        this.window.history.lastMessage.loading = false
+        this.window.history.lastMessage.complete = true
+    }
+
+    run(question: string) {
+        return this.executor.run(question)
+    }
+
+    done() {
+        return this.executor.done()
+    }
+
+    async closeRequest() {
+        const chatService = runtime.get<ChatService>('chat')
+
+        const data: z.infer<typeof api.chat.stop.requestSchema> = {
+            runId: this.runId
+        }
+        return await chatService.stop(data)
+    }
+
+    async shouldSaveMessage() {
+        if (this.window.history.lastMessage.id) {
+            const thread = await this.window.getThread()
+            const result = await thread.listMessages({ page: 0, perPage: 1, orderBy: { field: 'createdAt', direction: 'DESC' } })
+            const lastId = result.messages[0]?.id
+            if (lastId === this.window.history.lastMessage.id) return false
+        }
+
+        return true
+    }
+
+    async saveMessage() {
+        const chunk: ChatMessageChunk = { type: 'text', content: language.get('chat.user.stop') }
+        this.window.history.lastMessage.add(chunk)
+        let content = ''
+        const parts: MastraMessagePart[] = []
+        const toolInvocations: any[] = []
+        for (const chunk of this.window.history.lastMessage.chunks) {
+            if (chunk.type === 'text') {
+                content += chunk.content
+                parts.push({ type: 'text', text: chunk.content })
+            } else if (chunk.type === 'tool') {
+                const toolInvocation = { ...chunk, type: undefined, state: 'result' }
+                toolInvocations.push(toolInvocation)
+                parts.push({ type: 'tool-invocation', toolInvocation })
+            }
+        }
+
+        const agentId = this.window.agentId
+        await ChatService.client.saveMessageToMemory({
+            messages: [
+                {
+                    id: this.window.history.lastMessage.id,
+                    type: 'text',
+                    createdAt: new Date(),
+                    threadId: this.window.threadId,
+                    resourceId: this.window.threadId,
+                    role: 'assistant',
+                    content: { format: 2, content, parts, toolInvocations },
+                }
+            ],
+            agentId,
+        })
+    }
+
+    async stop() {
+        const data = await this.closeRequest()
+        this.window.history.lastMessage.loading = false
+        if (data.success === false) return
+        const isSave = await this.shouldSaveMessage()
+        if (isSave === false) return
+        await this.saveMessage()
+    }
+}
+
+export {
+    ChatSession
+}

package/src/chat/ChatWindow.ts

@@ -0,0 +1,92 @@
+import z from 'zod'
+import { MemoryThread } from "@mastra/client-js/dist/resources";
+import { Generate } from "@vyr/engine";
+import { runtime } from "@vyr/runtime";
+import { ChatWindow as _Window, api } from "@vyr/service-gateway";
+import { ChatHistory } from "./ChatHistory";
+import { ChatSession } from "./ChatSession";
+import { ChatService } from "../ChatService";
+
+class ChatWindow {
+    private _needCreate = true
+    get completed() {
+        return this._needCreate === false
+    }
+    private _thread: MemoryThread | null = null
+    readonly history
+    readonly threadId
+    readonly title
+    agentId = ''
+    runing = false
+    disbaled = false
+    maxLength = 2000
+    question = ''
+
+    constructor(options: Partial<_Window> = {}) {
+        this.history = new ChatHistory()
+        this.threadId = options.id ?? Generate.uuid()
+        this.title = options.title ?? this.threadId
+        this.agentId = options.agentId ?? ''
+    }
+
+    private async tryCreate() {
+        const chatService = runtime.get<ChatService>('chat')
+        const listData: z.infer<typeof api.chat.list.requestSchema> = {
+            id: this.threadId,
+        }
+        const data = await chatService.list(listData)
+        if (data.list.length > 0) {
+            this._needCreate = false
+            return
+        }
+
+        const createData: z.infer<typeof api.chat.create.requestSchema> = {
+            window: {
+                id: this.threadId,
+                title: this.title,
+                agentId: this.agentId,
+            }
+        }
+        await chatService.create(createData)
+        this._needCreate = false
+    }
+
+    setNeedCreate(create: boolean) {
+        this._needCreate = create
+    }
+
+    async getThread() {
+        if (this._thread === null) {
+            try {
+                this._thread = ChatService.client.getMemoryThread({ threadId: this.threadId, agentId: this.agentId })
+            } catch (error) {
+                await ChatService.client.createMemoryThread({
+                    threadId: this.threadId,
+                    resourceId: this.threadId,
+                    agentId: this.agentId
+                })
+                this._thread = ChatService.client.getMemoryThread({
+                    threadId: this.threadId,
+                    agentId: this.agentId
+                })
+            }
+        }
+
+        return this._thread
+    }
+
+    getAgent() {
+        return ChatService.client.getAgent(this.agentId)
+    }
+
+    async ask(question: string) {
+        if (this._needCreate) await this.tryCreate()
+        const chatSession = new ChatSession(this)
+        chatSession.run(question)
+        return chatSession
+    }
+}
+
+export {
+    ChatWindow,
+}

package/src/chat/ChatWindowManager.ts

@@ -0,0 +1,72 @@
+import z from 'zod'
+import { api, ChatWindow as _Window } from "@vyr/service-gateway";
+import { ChatWindow } from "./ChatWindow";
+import { runtime } from "@vyr/runtime";
+import { ChatService } from "../ChatService";
+
+class ChatWindowManager {
+    private collection = new Map<string, ChatWindow>()
+    window = this.createWindow()
+
+    createWindow(options: Partial<_Window> = {}) {
+        const window = new ChatWindow(options)
+        this.collection.set(window.threadId, window)
+        return window
+    }
+
+    async deleteWindow(window: ChatWindow) {
+        if (window.completed) {
+            const thread = await window.getThread()
+            await thread.delete()
+            const chatService = runtime.get<ChatService>('chat')
+
+            const data: z.infer<typeof api.chat.delete.requestSchema> = {
+                id: window.threadId,
+            }
+            await chatService.delete(data)
+        }
+        this.collection.delete(window.threadId)
+    }
+
+    setCurrentWindow(window: ChatWindow) {
+        this.window = window
+    }
+
+    getWindow(id: string) {
+        return this.collection.get(id) ?? null
+    }
+
+    getWindows() {
+        return [...this.collection.values()]
+    }
+
+    isPendingWindow() {
+        const windows = this.collection.values()
+        for (const window of windows) {
+            if (window.completed === false) return true
+        }
+
+        return false
+    }
+
+    async initialize() {
+        const chatService = runtime.get<ChatService>('chat')
+
+        const listData: z.infer<typeof api.chat.list.requestSchema> = {}
+        const data = await chatService.list(listData)
+        const first = data?.list[0]
+        if (first === undefined) return
+        this.collection.clear()
+        for await (const item of data.list) {
+            const window = this.createWindow(item)
+            window.setNeedCreate(false)
+            await window.history.restore(window)
+        }
+        const window = this.collection.get(first.id) as ChatWindow
+        this.setCurrentWindow(window)
+    }
+}
+
+export {
+    ChatWindowManager
+}

package/src/chat/index.ts

@@ -0,0 +1,4 @@
+export * from './ChatSession'
+export * from './ChatHistory'
+export * from './ChatWindow'
+export * from './ChatWindowManager'

package/src/common/Draggable.ts

@@ -0,0 +1,36 @@
+import { Descriptor } from "@vyr/engine"
+import { Draggable as _Draggable, DraggableService, runtime } from "@vyr/runtime"
+import { DraggableData, DraggableEndType, } from '@vyr/declare'
+import { Prefab, VirtualNode } from "@vyr/service-gateway"
+import { language } from '../locale'
+import { ChatService } from "../ChatService"
+
+class Draggable extends _Draggable<VirtualNode> {
+  readonly id = DraggableService.key.chat
+
+  starter(dragData: VirtualNode) {
+    return false
+  }
+
+  validator(dragData: DraggableData<VirtualNode>, targetData: DraggableData<VirtualNode>) {
+    return true
+  }
+
+  finished(dragData: DraggableData<VirtualNode | Descriptor | Prefab>, targetData: DraggableData, type: DraggableEndType) {
+    const chatService = runtime.get<ChatService>('chat')
+
+    let content = ''
+    if (dragData.id === DraggableService.key.footer && dragData.data instanceof VirtualNode) {
+      content = language.get('chat.input.format.content.asset', { url: dragData.data.url })
+    } else if (dragData.id === DraggableService.key.asset && dragData.data instanceof Descriptor) {
+      content = language.get('chat.input.format.content.node', { uuid: dragData.data.uuid, url: targetData.data.value })
+    } else if (dragData.id === DraggableService.key.prefab) {
+      const prefab = dragData.data as unknown as Prefab
+      content = language.get('chat.input.format.content.prefab', { id: prefab.id })
+    }
+
+    chatService.manager.window.question += content
+  }
+}
+
+export { Draggable }

package/src/common/index.ts

@@ -0,0 +1 @@
+export * from './Draggable'

package/src/components/ChatAgent.vue

@@ -0,0 +1,44 @@
+<template>
+  <vyr-dropdown class="agent-wrapper" :data="chatService.agents" :model-value="chatService.manager.window.agentId">
+    <div class="agent">
+      {{ agentName }}
+    </div>
+  </vyr-dropdown>
+</template>
+
+<script setup lang="ts">
+import { computed } from 'vue';
+import { runtime } from '@vyr/runtime';
+import { VyrDropdown } from '@vyr/design';
+import { ChatService } from '../ChatService';
+
+const chatService = runtime.get<ChatService>('chat')
+
+const agentName = computed(() => {
+  for (const agent of chatService.agents) {
+    if (agent.value === chatService.manager.window.agentId) return agent.label
+  }
+  return ' - '
+})
+</script>
+
+<style scoped lang="scss">
+@import "devui-theme/styles-var/devui-var.scss";
+
+$item-height: 24px;
+
+.agent-wrapper {
+  width: 120px;
+  background-color: $devui-base-bg;
+  box-shadow: 0px 1px 8px 0px rgba(25, 25, 25, 0.06);
+  cursor: pointer;
+
+  .agent {
+    overflow: hidden;
+    height: $item-height;
+    line-height: $item-height;
+    padding: 0 0 0 8px;
+    box-sizing: border-box;
+  }
+}
+</style>