ctod 0.6.3 → 0.7.1

package/lib/broker/chat.ts

@@ -1,406 +0,0 @@
-import { TextParser } from '../core/parser'
-import { ChatBrokerPlugin } from '../core/plugin'
-import { Event, flow, Hook, Log } from 'power-helper'
-import { Translator, TranslatorParams } from '../core/translator'
-import { ValidateCallback, ValidateCallbackOutputs } from '../utils/validate'
-import { ParserError } from '../utils/error'
-
-type Message = {
-    role: 'system' | 'user' | 'assistant'
-    name?: string
-    content: string
-}
-
-export type ChatBrokerHooks<
-    S extends ValidateCallback<any>,
-    O extends ValidateCallback<any>,
-    P extends ChatBrokerPlugin<any, any>,
-    PS extends Record<string, ReturnType<P['use']>>
-> = {
-
-    /**
-     * @zh 第一次聊天的時候觸發
-     * @en Triggered when chatting for the first time
-     */
-
-    start: {
-        id: string
-        data: ValidateCallbackOutputs<S>
-        plugins: {
-            [K in keyof PS]: {
-                send: (data: PS[K]['__receiveData']) => void
-            }
-        }
-        schema: {
-            input: S
-            output: O
-        }
-        messages: Message[]
-        setPreMessages: (messages: (Omit<Message, 'content'> & { content: string | string[] })[]) => void
-        changeMessages: (messages: Message[]) => void
-    }
-
-    /**
-     * @zh 發送聊天訊息給機器人前觸發
-     * @en Triggered before sending chat message to bot
-     */
-
-    talkBefore: {
-        id: string
-        data: ValidateCallbackOutputs<S>
-        messages: Message[]
-        lastUserMessage: string
-    }
-
-    /**
-     * @zh 當聊天機器人回傳資料的時候觸發
-     * @en Triggered when the chatbot returns data
-     */
-
-    talkAfter: {
-        id: string
-        data: ValidateCallbackOutputs<S>
-        response: any
-        messages: Message[]
-        parseText: string
-        lastUserMessage: string
-        /**
-         * @zh 宣告解析失敗
-         * @en Declare parsing failure
-         */
-        parseFail: (error: any) => void
-        changeParseText: (text: string) => void
-    }
-
-    /**
-     * @zh 當回傳資料符合規格時觸發
-     * @en Triggered when the returned data meets the specifications
-     */
-
-    succeeded: {
-        id: string
-        output: ValidateCallbackOutputs<O>
-    }
-
-    /**
-     * @zh 當回傳資料不符合規格，或是解析錯誤時觸發
-     * @en Triggered when the returned data does not meet the specifications or parsing errors
-     */
-
-    parseFailed: {
-        id: string
-        error: any
-        retry: () => void
-        count: number
-        response: any
-        parserFails: { name: string, error: any }[]
-        messages: Message[]
-        lastUserMessage: string
-        changeMessages: (messages: Message[]) => void
-    }
-
-    /**
-     * @zh 不論成功失敗，執行結束的時候會執行。
-     * @en It will be executed when the execution is completed, regardless of success or failure.
-     */
-
-    done: {
-        id: string
-    }
-}
-
-type RequestContext = {
-    count: number
-    isRetry: boolean
-    onCancel: (cb: () => void) => void
-    schema: {
-        input: any
-        output: any
-    }
-}
-
-export type Params<
-    S extends ValidateCallback<any>,
-    O extends ValidateCallback<any>,
-    C extends Record<string, any>,
-    P extends ChatBrokerPlugin<any, any>,
-    PS extends Record<string, ReturnType<P['use']>>
-> = Omit<TranslatorParams<S, O>, 'parsers'> & {
-    name?: string
-    plugins?: PS | (() => PS)
-    request: (messages: Message[], context: RequestContext) => Promise<string>
-    install?: (context: {
-        log: Log
-        attach: Hook<C>['attach']
-        attachAfter: Hook<C>['attachAfter']
-        translator: Translator<S, O>
-    }) => void
-}
-
-export class ChatBroker<
-    S extends ValidateCallback<any>,
-    O extends ValidateCallback<any>,
-    P extends ChatBrokerPlugin<any, any>,
-    PS extends Record<string, ReturnType<P['use']>>,
-    C extends ChatBrokerHooks<S, O, P, PS> = ChatBrokerHooks<S, O, P, PS>
-> {
-    protected __hookType!: C
-    protected log: Log
-    protected hook = new Hook<C>()
-    protected params: Params<S, O, C, P, PS>
-    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')
-        this.params = params
-        this.translator = new Translator({
-            ...params,
-            parsers: [
-                TextParser.JsonMessage()
-            ]
-        })
-    }
-
-    protected _install(): any {
-        if (this.installed === false) {
-            this.installed = true
-            const context = {
-                log: this.log,
-                attach: this.hook.attach.bind(this.hook),
-                attachAfter: this.hook.attachAfter.bind(this.hook),
-                translator: this.translator
-            }
-            if (this.params.plugins) {
-                this.plugins = typeof this.params.plugins === 'function' ? this.params.plugins() : this.params.plugins
-                for (let key in this.plugins) {
-                    this.plugins[key].instance._params.onInstall({
-                        ...context,
-                        params: this.plugins[key].params,
-                        receive: this.plugins[key].receive
-                    })
-                }
-            }
-            this.params.install?.(context)
-        }
-    }
-
-    async cancel(requestId?: string) {
-        if (requestId) {
-            this.event.emit('cancel', {
-                requestId
-            })
-        } else {
-            this.event.emit('cancelAll', {})
-        }
-    }
-
-    requestWithId<T extends Translator<S, O>>(data: T['__schemeType']): {
-        id: string
-        request: Promise<T['__outputType']>
-    } {
-        this._install()
-        let id = flow.createUuid()
-        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()
-            })
-        ]
-        let eventOff = () => listeners.forEach(e => e.off())
-        let cancelTrigger = () => {
-            if (isCancel === false) {
-                if (isSending && waitCancel) {
-                    waitCancel()
-                }
-                isCancel = true
-                eventOff()
-            }
-        }
-        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
-                    })
-                }
-            }
-            await this.hook.notify('start', {
-                id,
-                data,
-                schema,
-                plugins,
-                messages,
-                setPreMessages: ms => {
-                    const newMessage = ms.map(e => {
-                        return {
-                            ...e,
-                            content: Array.isArray(e.content) ? e.content.join('\n') : e.content
-                        }
-                    })
-                    messages = [
-                        ...newMessage,
-                        {
-                            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,
-                        data,
-                        messages,
-                        lastUserMessage
-                    })
-                    const sender = this.params.request(messages, {
-                        count,
-                        schema,
-                        onCancel,
-                        isRetry: retryFlag
-                    })
-                    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,
-                            parseFail: (error) => {
-                                throw new ParserError(error, [])
-                            },
-                            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 instanceof ParserError) {
-                        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
-                    }
-                }
-            })
-            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/parser.ts

@@ -1,62 +0,0 @@
-import JSON5 from 'json5'
-
-type TextParserParams = {
-    /**
-     * @zh 解讀器名字。
-     * @en The name of the parser. 
-     */
-    name: string
-    /**
-     * @zh 解讀文本。
-     * @en Read the text.
-     */
-    handler: (text: string) => Promise<any>
-}
-
-export class TextParser {
-    private params: TextParserParams
-
-    /**
-     * @zh 盡可能將文字內的 json 解讀出來。
-     * @en Try to read the json in the text as much as possible.
-     */
-
-    static JsonMessage() {
-        return new TextParser({
-            name: 'JsonMessage',
-            handler: async (text) => {
-                try {
-                    const result = JSON.parse(text)
-                    return result
-                } catch (error) {
-                    const jsonRegex = /{(?:[^{}]|(?:{[^{}]*}))*}/
-                    const matchedText = text.match(jsonRegex)?.[0] || ''
-                    return JSON5.parse(matchedText)
-                }
-            }
-        })
-    }
-
-    constructor(params: TextParserParams) {
-        this.params = params
-    }
-
-    /**
-     * @zh 解讀器名字。
-     * @en The name of the parser. 
-     */
-
-    get name() {
-        return this.params.name
-    }
-
-    /**
-     * @zh 解讀文本。
-     * @en Read the text.
-     */
-
-    async read(text: string) {
-        const result = await this.params.handler(text)
-        return result
-    }
-}

package/lib/core/plugin.ts

@@ -1,46 +0,0 @@
-import { Translator } from './translator'
-import { ChatBrokerHooks } from '../broker/chat'
-import { Log, Hook, Event } from 'power-helper'
-import { ValidateCallback, ValidateCallbackOutputs } from '../utils/validate'
-
-type BrokerHooks = ChatBrokerHooks<any, any, any, any>
-type BrokerPluginParams<
-    T extends ValidateCallback<any>,
-    R extends ValidateCallback<any>
-> = {
-    name: string
-    params: T
-    receiveData: R
-    onInstall: (context: {
-        log: Log
-        params: ValidateCallbackOutputs<T>
-        attach: Hook<BrokerHooks>['attach']
-        attachAfter: Hook<BrokerHooks>['attachAfter']
-        translator: Translator<any, any>
-        receive: (callback: (params: {
-            id: string
-            data: ValidateCallbackOutputs<R>
-        }) => void) => void
-    }) => void
-}
-
-export class ChatBrokerPlugin<
-    T extends ValidateCallback<any>,
-    R extends ValidateCallback<any>
-> {
-    _event = new Event()
-    _params: BrokerPluginParams<T, R>
-    constructor(params: BrokerPluginParams<T, R>) {
-        this._params = params
-    }
-
-    use(params: ValidateCallbackOutputs<T>) {
-        return {
-            instance: this as any,
-            params,
-            send: (data: ValidateCallbackOutputs<R>) => { this._event.emit('receive', data) },
-            receive: (callback: any) => { this._event.on('receive', callback) },
-            __receiveData: null as unknown as ValidateCallbackOutputs<R>
-        }
-    }
-}

package/lib/core/translator.ts

@@ -1,111 +0,0 @@
-import { TextParser } from './parser'
-import { validate, ValidateCallback, ValidateCallbackOutputs } from '../utils/validate'
-import { ParserError } from '../utils/error'
-
-export type TranslatorParams<
-    S extends ValidateCallback<any>,
-    O extends ValidateCallback<any>
-> = {
-    /**
-     * @zh 輸入的資料格式。
-     * @en The input data format.
-     */
-    input: S
-    /**
-     * @zh 輸出的資料格式。
-     * @en The output data format. 
-     */
-    output: O
-    /**
-     * @zh 註冊解讀文字的解析器。
-     * @en Register the parser to interpret the text.
-     */
-    parsers: TextParser[]
-    /**
-     * @zh 組合輸入資料成為提示文字。
-     * @en Combine the input data into a prompt.
-     */
-    question: (data: ValidateCallbackOutputs<S>, context: {
-        schema: {
-            input: S
-            output: O
-        }
-    }) => Promise<string | string[]>
-}
-
-export class Translator<
-    S extends ValidateCallback<any>,
-    O extends ValidateCallback<any>
-> {
-    private params: TranslatorParams<S, O>
-
-    constructor(params: TranslatorParams<S, O>) {
-        this.params = params
-    }
-
-    get __schemeType(): ValidateCallbackOutputs<S> {
-        return null as any
-    }
-    get __outputType(): ValidateCallbackOutputs<O> {
-        return null as any
-    }
-
-    /**
-     * @zh 組合輸入資料成為提示文字。
-     * @en Combine the input data into a prompt.
-     */
-
-    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, context)
-        return {
-            scheme,
-            prompt: Array.isArray(prompt) ? prompt.join('\n') : prompt
-        }
-    }
-
-    getValidate() {
-        return {
-            input: this.params.input,
-            output: this.params.output
-        }
-    }
-
-    /**
-     * @zh 將文字轉換成序列化資料。
-     * @en Convert text to serialized data.
-     */
-
-    async parse(text: string) {
-        let result: any = undefined
-        let parserName = ''
-        let parserFails: { name: string, error: any }[] = []
-        for (let parse of this.params.parsers) {
-            try {
-                result = await parse.read(text)
-                parserName = parse.name
-            } catch (error) {
-                result = undefined
-                parserFails.push({
-                    name: parse.name,
-                    error
-                })
-            }
-        }
-        try {
-            let output = validate(result, this.params.output)
-            return {
-                output,
-                parserName,
-                parserFails
-            }
-        } catch (error) {
-            throw new ParserError(error, parserFails)
-        }
-    }
-}

package/lib/index.ts

@@ -1,38 +0,0 @@
-export * as plugins from './plugins'
-export * as templates from './templates'
-export { validateToJsonSchema, defineYupSchema } 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, defineYupSchema } from './utils/validate'
-
-export const ctod = {
-    OpenAI,
-    Llama3Cpp,
-    plugins,
-    templates,
-    ChatBroker,
-    Translator,
-    TextParser,
-    ChatBrokerPlugin,
-    defineYupSchema,
-    validateToJsonSchema
-}
-
-module.exports = ctod
-module.exports.ctod = ctod
-
-export default ctod

package/lib/plugins/index.ts

@@ -1,38 +0,0 @@
-import Retry from './retry'
-import PrintLog from './print-log'
-import Limiter from './limiter'
-import Role from './role'
-
-/**
- * @zh 一個基於印出 log 的 plugin。
- * @en A plugin based on printing log.
- */
-
-export const PrintLogPlugin = PrintLog
-
-/**
- * @zh 當解析失敗時，會自動重試的對話。
- * @en A conversation that will automatically retry when parsing fails.
- */
-
-export const RetryPlugin = Retry
-
-/**
- * @zh 限制使用流量，這個 plugin 可以有效讓所有對話不會再限制內同時發送，可用於在開發過程中遭遇伺服器因頻率過高而阻擋請求。
- * @en Limit the use of traffic. This plugin can effectively prevent all conversations from being sent at the same time within the limit, and can be used when the server blocks requests due to high frequency during development.
- */
-
-export const LimiterPlugin = Limiter.plugin
-
-/**
- * @zh 排程系統將全域託管，有什麼必要設定可以來更動它的狀態，例如：關閉排程。
- * @en The scheduling system will be globally hosted. What is necessary to set can come to change its status, for example: close the schedule.
- */
-export const LimiterPluginGlobState = Limiter
-
-/**
- * @zh 設定角色扮演。
- * @en Set role play.
- */
-
-export const RolePlugin = Role