ctod 0.3.6 → 0.4.0

package/lib/broker/chat.ts

@@ -1,6 +1,6 @@
 import { TextParser } from '../core/parser'
 import { ChatBrokerPlugin } from '../core/plugin'
-import { flow, Hook, Log } from 'power-helper'
+import { Event, flow, Hook, Log } from 'power-helper'
 import { Translator, TranslatorParams } from '../core/translator'
 import { ValidateCallback, ValidateCallbackOutputs } from '../utils/validate'
 
@@ -30,6 +30,10 @@ export type ChatBrokerHooks<
                 send: (data: PS[K]['__receiveData']) => void
             }
         }
+        schema: {
+            input: S
+            output: O
+        }
         messages: Message[]
         setPreMessages: (messages: Message[]) => void
         changeMessages: (messages: Message[]) => void
@@ -102,6 +106,11 @@ export type ChatBrokerHooks<
 type RequestContext = {
     count: number
     isRetry: boolean
+    onCancel: (cb: () => void) => void
+    schema: {
+        input: any
+        output: any
+    }
 }
 
 export type Params<
@@ -136,6 +145,12 @@ export class ChatBroker<
     protected plugins = {} as PS
     protected installed = false
     protected translator: Translator<S, O>
+    protected event = new Event<{
+        cancel: {
+            requestId: string
+        }
+        cancelAll: any
+    }>()
 
     constructor(params: Params<S, O, C, P, PS>) {
         this.log = new Log(params.name ?? 'no name')
@@ -171,115 +186,206 @@ export class ChatBroker<
         }
     }
 
-    /**
-     * @zh 將請求發出至聊天機器人。
-     * @en Send request to chatbot.
-     */
+    async cancel(requestId?: string) {
+        if (requestId) {
+            this.event.emit('cancel', {
+                requestId
+            })
+        } else {
+            this.event.emit('cancelAll', {})
+        }
+    }
 
-    async request<T extends Translator<S, O>>(data: T['__schemeType']): Promise<T['__outputType']> {
+    requestWithId<T extends Translator<S, O>>(data: T['__schemeType']): {
+        id: string
+        request: Promise<T['__outputType']>
+    } {
         this._install()
         let id = flow.createUuid()
-        let output: any = null
-        let plugins = {} as any
-        let question = await this.translator.compile(data)
-        let messages: Message[] = [
-            {
-                role: 'user',
-                content: question.prompt
-            }
+        let waitCancel = null as (() => void) | null
+        let isCancel = false
+        let isSending = false
+
+        // =================
+        //
+        // event
+        //
+
+        let listeners = [
+            this.event.on('cancel', ({ requestId }) => {
+                if (requestId === id) {
+                    cancelTrigger()
+                }
+            }),
+            this.event.on('cancelAll', () => {
+                cancelTrigger()
+            })
         ]
-        for (let key in this.plugins) {
-            plugins[key] = {
-                send: (data: any) => this.plugins[key].send({
-                    id,
-                    data
-                })
+        let eventOff = () => listeners.forEach(e => e.off())
+        let cancelTrigger = () => {
+            if (isCancel === false) {
+                if (isSending && waitCancel) {
+                    waitCancel()
+                }
+                isCancel = true
+                eventOff()
             }
         }
-        await this.hook.notify('start', {
-            id,
-            data,
-            plugins,
-            messages,
-            setPreMessages: ms => {
-                messages = [
-                    ...ms,
-                    {
-                        role: 'user',
-                        content: question.prompt
-                    }
-                ]
-            },
-            changeMessages: ms => {
-                messages = ms
-            }
-        })
-        await flow.asyncWhile(async ({ count, doBreak }) => {
-            if (count >= 10) {
-                return doBreak()
+        let onCancel = (cb: () => void) => {
+            waitCancel = cb
+        }
+
+        // =================
+        //
+        // main
+        //
+
+        let request = async() => {
+            let schema = this.translator.getValidate()
+            let output: any = null
+            let plugins = {} as any
+            let question = await this.translator.compile(data, {
+                schema
+            })
+            let messages: Message[] = [
+                {
+                    role: 'user',
+                    content: question.prompt
+                }
+            ]
+            for (let key in this.plugins) {
+                plugins[key] = {
+                    send: (data: any) => this.plugins[key].send({
+                        id,
+                        data
+                    })
+                }
             }
-            let response = ''
-            let parseText = ''
-            let retryFlag = false
-            let lastUserMessage = messages.filter(e => e.role === 'user').slice(-1)[0]?.content || ''
-            try {
-                await this.hook.notify('talkBefore', {
-                    id,
-                    data,
-                    messages,
-                    lastUserMessage
-                })
-                response = await this.params.request(messages, {
-                    count,
-                    isRetry: retryFlag
-                })
-                parseText = response
-                await this.hook.notify('talkAfter', {
-                    id,
-                    data,
-                    response,
-                    messages,
-                    parseText,
-                    lastUserMessage,
-                    changeParseText: text => {
-                        parseText = text
-                    }
-                })
-                output = (await this.translator.parse(parseText)).output
-                await this.hook.notify('succeeded', {
-                    id,
-                    output
-                })
-                await this.hook.notify('done', { id })
-                doBreak()
-            } catch (error: any) {
-                // 如果解析錯誤，可以選擇是否重新解讀
-                if (error.isParserError) {
-                    await this.hook.notify('parseFailed', {
+            await this.hook.notify('start', {
+                id,
+                data,
+                schema,
+                plugins,
+                messages,
+                setPreMessages: ms => {
+                    messages = [
+                        ...ms,
+                        {
+                            role: 'user',
+                            content: question.prompt
+                        }
+                    ]
+                },
+                changeMessages: ms => {
+                    messages = ms
+                }
+            })
+            await flow.asyncWhile(async ({ count, doBreak }) => {
+                if (count >= 10) {
+                    return doBreak()
+                }
+                let response = ''
+                let parseText = ''
+                let retryFlag = false
+                let lastUserMessage = messages.filter(e => e.role === 'user').slice(-1)[0]?.content || ''
+                try {
+                    await this.hook.notify('talkBefore', {
                         id,
-                        error: error.error,
-                        count,
-                        response,
+                        data,
                         messages,
-                        lastUserMessage,
-                        parserFails: error.parserFails,
-                        retry: () => {
-                            retryFlag = true
-                        },
-                        changeMessages: ms => {
-                            messages = ms
-                        }
+                        lastUserMessage
+                    })
+                    const sender = this.params.request(messages, {
+                        count,
+                        schema,
+                        onCancel,
+                        isRetry: retryFlag
                     })
-                    if (retryFlag === false) {
+                    if (isCancel) {
+                        if (waitCancel) {
+                            waitCancel()
+                        }
+                    } else {
+                        try {
+                            isSending = true
+                            response = await sender
+                            parseText = response
+                        } finally {
+                            isSending = false
+                        }
+                    }
+                    if (isCancel === false) {
+                        await this.hook.notify('talkAfter', {
+                            id,
+                            data,
+                            response,
+                            messages,
+                            parseText,
+                            lastUserMessage,
+                            changeParseText: text => {
+                                parseText = text
+                            }
+                        })
+                        output = (await this.translator.parse(parseText)).output
+                        await this.hook.notify('succeeded', {
+                            id,
+                            output
+                        })
+                    }
+                    await this.hook.notify('done', { id })
+                    doBreak()
+                } catch (error: any) {
+                    // 如果解析錯誤，可以選擇是否重新解讀
+                    if (error.isParserError) {
+                        await this.hook.notify('parseFailed', {
+                            id,
+                            error: error.error,
+                            count,
+                            response,
+                            messages,
+                            lastUserMessage,
+                            parserFails: error.parserFails,
+                            retry: () => {
+                                retryFlag = true
+                            },
+                            changeMessages: ms => {
+                                messages = ms
+                            }
+                        })
+                        if (retryFlag === false) {
+                            await this.hook.notify('done', { id })
+                            throw error
+                        }
+                    } else {
                         await this.hook.notify('done', { id })
                         throw error
                     }
-                } else {
-                    await this.hook.notify('done', { id })
-                    throw error
                 }
+            })
+            return output
+        }
+        const send = async() => {
+            try {
+                const result = await request()
+                return result
+            } finally {
+                eventOff()
             }
-        })
+        }
+        return {
+            id,
+            request: send()
+        }
+    }
+
+    /**
+     * @zh 將請求發出至聊天機器人。
+     * @en Send request to chatbot.
+     */
+
+    async request<T extends Translator<S, O>>(data: T['__schemeType']): Promise<T['__outputType']> {
+        const { request } = this.requestWithId(data)
+        const output = await request
         return output
     }
 }

package/lib/core/translator.ts

@@ -24,7 +24,12 @@ export type TranslatorParams<
      * @zh 組合輸入資料成為提示文字。
      * @en Combine the input data into a prompt.
      */
-    question: (data: ValidateCallbackOutputs<S>) => Promise<string>
+    question: (data: ValidateCallbackOutputs<S>, context: {
+        schema: {
+            input: S
+            output: O
+        }
+    }) => Promise<string>
 }
 
 export class Translator<
@@ -49,15 +54,27 @@ export class Translator<
      * @en Combine the input data into a prompt.
      */
 
-    async compile(data: ValidateCallbackOutputs<S>) {
+    async compile(data: ValidateCallbackOutputs<S>, context: {
+        schema: {
+            input: S
+            output: O
+        }
+    }) {
         const scheme = validate(data, this.params.input)
-        const prompt = await this.params.question(scheme)
+        const prompt = await this.params.question(scheme, context)
         return {
             scheme,
             prompt
         }
     }
 
+    getValidate() {
+        return {
+            input: this.params.input,
+            output: this.params.output
+        }
+    }
+
     /**
      * @zh 將文字轉換成序列化資料。
      * @en Convert text to serialized data.

package/lib/index.ts

@@ -1,41 +1,34 @@
-/* eslint-disable no-redeclare */
-
-import * as _plugins from './plugins'
-import * as _templates from './templates'
-import * as _Translator from './core/translator'
-import { ValidateCallback } from './utils/validate'
-import { OpenAI as _OpenAI } from './service/openai'
-import { ChatGPTMessage as _ChatGPTMessage } from './service/openai/chat'
-import { TextParser as _TextParser } from './core/parser'
-import { ChatBroker as _ChatBroker } from './broker/chat'
-import { ChatBrokerPlugin as _ChatBrokerPlugin } from './core/plugin'
-
-export type OpenAI = _OpenAI
-export type TextParser = _TextParser
-export type Translator<S extends ValidateCallback<any>, O extends ValidateCallback<any>> = _Translator.Translator<S, O>
-export type TranslatorParams<S extends ValidateCallback<any>, O extends ValidateCallback<any>> = _Translator.TranslatorParams<S, O>
-export type ChatBroker<S extends ValidateCallback<any>, O extends ValidateCallback<any>> = _ChatBroker<S, O, any, any>
-export type ChatBrokerPlugin<T extends ValidateCallback<any>, R extends ValidateCallback<any>> = _ChatBrokerPlugin<T, R>
-export type ChatGPTMessage = _ChatGPTMessage
-
-export const OpenAI = _OpenAI
-export const TextParser = _TextParser
-export const Translator = _Translator.Translator
-
-export const ChatBroker = _ChatBroker
-export const ChatBrokerPlugin = _ChatBrokerPlugin
-
-export const plugins = _plugins
-export const templates = _templates
+export * as plugins from './plugins'
+export * as templates from './templates'
+export { validateToJsonSchema, JsonSchemaInfo } from './utils/validate'
+export { OpenAI } from './service/openai'
+export { Llama3Cpp } from './service/llama3.cpp'
+export { TextParser } from './core/parser'
+export { ChatGPTMessage } from './service/openai/chat'
+export { ChatBroker } from './broker/chat'
+export { ChatBrokerPlugin } from './core/plugin'
+export { Translator, TranslatorParams } from './core/translator'
+
+import * as plugins from './plugins'
+import * as templates from './templates'
+import { OpenAI } from './service/openai'
+import { Llama3Cpp } from './service/llama3.cpp'
+import { Translator } from './core/translator'
+import { TextParser } from './core/parser'
+import { ChatBroker } from './broker/chat'
+import { ChatBrokerPlugin } from './core/plugin'
+import { validateToJsonSchema } from './utils/validate'
 
 export const ctod = {
     OpenAI,
+    Llama3Cpp,
     plugins,
     templates,
     ChatBroker,
     Translator,
     TextParser,
-    ChatBrokerPlugin
+    ChatBrokerPlugin,
+    validateToJsonSchema
 }
 
 module.exports = ctod