ctod 0.7.1 → 0.7.2

package/lib/core/parser.ts

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

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

@@ -0,0 +1,115 @@
+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 = this.params.input ? validate(data, this.params.input) : data
+        const prompt = this.params.question ? 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
+        }
+    }
+
+    changeOutputSchema(schema: O) {
+        this.params.output = schema
+    }
+
+    /**
+     * @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/ctod.ts

@@ -0,0 +1,71 @@
+import { ChatBroker, Message, Params as ChatBrokerParams, ChatBrokerHooks, RequestContext } from './broker/chat'
+import { ChatBrokerPlugin } from './core/plugin'
+import { Schema } from 'yup'
+import * as Yup from 'yup'
+
+type IO = any
+
+export class CtoD<
+    P extends ChatBrokerPlugin<IO, IO>,
+    PS extends Record<string, ReturnType<P['use']>>
+> {
+    params
+    constructor(params: {
+        request: (messages: Message[], context: RequestContext) => Promise<string>
+        plugins?: () => PS
+    }) {
+        this.params = params
+    }
+
+    createBrokerBuilder<I extends Record<string, any>>(params?: {
+        install?: ChatBrokerParams<() => I, IO, ChatBrokerHooks<() => I, IO, P, PS>, P, PS>['install']
+    }) {
+        return {
+            create: <O extends Record<string, Schema>>(install: (context: {
+                id: string
+                yup: typeof Yup
+                data: I
+                plugins: {
+                    [K in keyof PS]: {
+                        send: (data: PS[K]['__receiveData']) => void
+                    }
+                }
+                setMessages: (messages: (Omit<Message, 'content'> & { content: string | string[] })[]) => void
+                metadata: Map<string, any>
+            }) => Promise<O>) => {
+                return new ChatBroker<
+                    () => I,
+                    () => O,
+                    P,
+                    PS,
+                    ChatBrokerHooks<() => I, () => O, P, PS>
+                        >({
+                            output: () => ({} as any),
+                            install: (context) => {
+                                params?.install?.(context)
+                                context.attach('start', async({ id, plugins, data, metadata, changeMessages, changeOutputSchema }) => {
+                                    const schema = await install({
+                                        id,
+                                        data: data as any,
+                                        plugins,
+                                        yup: Yup,
+                                        setMessages: (messages) => {
+                                            changeMessages(messages.map(e => {
+                                                return {
+                                                    role: e.role,
+                                                    content: Array.isArray(e.content) ? e.content.join('\n') : e.content
+                                                }
+                                            }))
+                                        },
+                                        metadata
+                                    })
+                                    changeOutputSchema(() => schema)
+                                })
+                            },
+                            plugins: this.params.plugins ? (() => this.params.plugins!()) : undefined,
+                            request: this.params.request
+                        })
+            }
+        }
+    }
+}

package/lib/index.ts

@@ -0,0 +1,41 @@
+export * as plugins from './plugins'
+export * as templates from './templates'
+export { CtoD } from './ctod'
+export { validateToJsonSchema, defineYupSchema, ValidateCallback } 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 { CtoD } from './ctod'
+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 = {
+    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

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

package/lib/plugins/limiter.ts

@@ -0,0 +1,103 @@
+import { ChatBrokerPlugin } from '../core/plugin'
+import { Event, flow, Schedule } from 'power-helper'
+
+type Events = {
+    run: {
+        id: string
+    }
+    waitTimeChange: {
+        waitTime: number
+    }
+}
+
+const config = {
+    limit: 3,
+    interval: 60000,
+}
+
+const state = {
+    event: new Event<Events>(),
+    schedule: null as Schedule | null,
+    waitTimes: [] as number[],
+    waitQueue: [] as string[]
+}
+
+export default {
+    /**
+     * @zh 你可以監聽一些事件行為，例如還需要等待多少時間。
+     * @en You can listen for some event behaviors, such as how long you still need to wait.
+     */
+
+    event: state.event,
+
+    /**
+     * @zh 預設是每分鐘限制3次，你可以在設定中改變限制流量。
+     * @en By default, the limit is 3 times per minute, and you can change the limit flow in the settings.
+     */
+
+    config,
+
+    /**
+     * @zh 由於排程會在背景持續倒數，如果有關閉程式的需求，需要手動進行移除。
+     * @en Since the schedule will continue to count down in the background, if there is a need to close the program, you need to manually remove it.
+     */
+
+    closeSchedule: () => {
+        if (state.schedule) {
+            state.schedule.close()
+            state.schedule = null
+        }
+    },
+
+    /**
+     * @zh Plugin 的接口
+     * @en Plugin interface
+     */
+
+    plugin: new ChatBrokerPlugin({
+        name: 'limiter',
+        params: () => {
+            return {}
+        },
+        receiveData: () => {
+            return {}
+        },
+        onInstall({ attach }) {
+            if (state.schedule == null) {
+                state.schedule = new Schedule()
+                state.schedule.add('calc queue', 1000, async() => {
+                    const now = Date.now()
+                    state.waitTimes = state.waitTimes.filter(time => {
+                        return now - time < config.interval
+                    })
+                    if (state.waitTimes.length !== config.limit) {
+                        let nextId = state.waitQueue.shift()
+                        if (nextId) {
+                            state.waitTimes.push(Date.now())
+                            state.event.emit('run', {
+                                id: nextId
+                            })
+                        }
+                    } else if (state.waitTimes[0]) {
+                        state.event.emit('waitTimeChange', {
+                            waitTime: Math.floor(60 - (now - state.waitTimes[0]) / 1000)
+                        })
+                    }
+                })
+                state.schedule.play()
+            }
+            attach('talkBefore', async() => {
+                const uid = flow.createUuid()
+                state.waitQueue.push(uid)
+                return new Promise(resolve => {
+                    state.event.on('run', ({ id }, { off }) => {
+                        if (id === uid) {
+                            off()
+                            resolve()
+                        }
+                    })
+                })
+            })
+        }
+    })
+}

package/lib/plugins/print-log.ts

@@ -0,0 +1,35 @@
+import { ChatBrokerPlugin } from '../core/plugin'
+
+export default new ChatBrokerPlugin({
+    name: 'print-log',
+    params: yup => {
+        return {
+            detail: yup.boolean().default(false)
+        }
+    },
+    receiveData: () => {
+        return {}
+    },
+    onInstall({ params, log, attach }) {
+        attach('talkBefore', async({ lastUserMessage, messages }) => {
+            log.print('Send:', { color: 'green' })
+            if (params.detail) {
+                log.print('\n' + JSON.stringify(messages, null, 4))
+            } else {
+                log.print('\n' + lastUserMessage)
+            }
+        })
+        attach('talkAfter', async({ parseText }) => {
+            log.print('Receive:', { color: 'cyan' })
+            log.print('\n' + parseText)
+        })
+        attach('succeeded', async({ output }) => {
+            log.print('Output:', { color: 'yellow' })
+            try {
+                log.print('\n' + JSON.stringify(output, null, 4))
+            } catch (error) {
+                log.print('\n' + output)
+            }
+        })
+    }
+})

package/lib/plugins/retry.ts

@@ -0,0 +1,25 @@
+import { ChatBrokerPlugin } from '../core/plugin'
+
+export default new ChatBrokerPlugin({
+    name: 'retry',
+    params: yup => {
+        return {
+            retry: yup.number().required().default(1),
+            printWarn: yup.boolean().required().default(true)
+        }
+    },
+    receiveData: () => {
+        return {}
+    },
+    onInstall({ log, attach, params }) {
+        attach('parseFailed', async({ count, retry, messages, changeMessages }) => {
+            if (count <= params.retry) {
+                if (params.printWarn) {
+                    log.print(`Is Failed, Retry ${count} times.`)
+                }
+                changeMessages(messages)
+                retry()
+            }
+        })
+    }
+})

package/lib/plugins/role.ts

@@ -0,0 +1,28 @@
+import { ChatBrokerPlugin } from '../core/plugin'
+
+export default new ChatBrokerPlugin({
+    name: 'role',
+    params: yup => {
+        return {
+            role: yup.string().required()
+        }
+    },
+    receiveData: () => {
+        return {}
+    },
+    onInstall({ attach, params }) {
+        attach('start', async({ messages, changeMessages }) => {
+            changeMessages([
+                {
+                    role: 'user',
+                    content: `你現在是${params.role}。`
+                },
+                {
+                    role: 'assistant',
+                    content: `沒問題，我現在是${params.role}，有什麼可以幫你的嗎？`
+                },
+                ...messages
+            ])
+        })
+    }
+})