ctod 0.7.0 → 0.7.1

package/lib/service/llama3.cpp/completion.ts

@@ -1,313 +0,0 @@
-import { Llama3Cpp } from './index'
-import { flow } from 'power-helper'
-import { tify, sify } from 'chinese-conv'
-
-type Message = {
-    role: string
-    content: string
-}
-
-type Options = any
-
-export type Config = {
-    baseUrl: string
-    headers: Record<string, string>
-    autoConvertTraditionalChinese: boolean
-}
-
-type Stream = {
-    onMessage: (data: { message: string }) => void
-    onEnd?: () => void
-    onWarn?: (error: any) => void
-    onError?: (error: any) => void
-}
-
-class Requester {
-    private core: Llama3CppCompletion
-    private streamAbortControllers: {
-        id: string
-        controller: AbortController
-    }[] = []
-
-    constructor(core: Llama3CppCompletion) {
-        this.core = core
-    }
-
-    private createAbortController() {
-        const streamAbortController = new AbortController()
-        const streamAbortControllerId = flow.createUuid()
-        this.streamAbortControllers.push({
-            id: streamAbortControllerId,
-            controller: streamAbortController
-        })
-        return {
-            signal: streamAbortController.signal,
-            controllerId: streamAbortControllerId
-        }
-    }
-
-    private removeAbortController(streamAbortControllerId: string) {
-        this.streamAbortControllers = this.streamAbortControllers.filter(e => e.id !== streamAbortControllerId)
-    }
-
-    async stream(params: {
-        path: string
-        data: any
-        onMessage: (data: any) => void
-        onEnd: () => void
-        onWarn: (error: any) => void
-        onError: (error: any) => void
-    }) {
-        const { signal, controllerId } = this.createAbortController()
-        const end = () => {
-            this.removeAbortController(controllerId)
-            params.onEnd()
-        }
-        const reader = async(response: Response) => {
-            if (response.body) {
-                let reader = response.body.getReader()
-                let done = false
-                let chunk = ''
-                while (!done) {
-                    const { value, done: readerDone } = await reader.read()
-                    if (value) {
-                        chunk += new TextDecoder('utf-8').decode(value)
-                        const payloads = chunk.split('\n\n')
-                        chunk = payloads.pop() || ''
-                        payloads.forEach(payload => {
-                            if (payload.includes('[DONE]')) {
-                                done = true
-                            }
-                            if (payload.startsWith('data:')) {
-                                try {
-                                    const data = JSON.parse(payload.replace('data: ', ''))
-                                    params.onMessage(data)
-                                } catch (error) {
-                                    params.onWarn(error)
-                                }
-                            }
-                        })
-                    }
-                    if (readerDone) {
-                        done = true
-                    }
-                }
-                end()
-            } else {
-                params.onError(new Error('Body not found.'))
-            }
-        }
-        fetch(`${this.core.config.baseUrl}/${params.path}`, {
-            method: 'POST',
-            body: JSON.stringify(params.data),
-            signal,
-            headers: {
-                'Content-Type': 'application/json',
-                ...this.core.config.headers
-            }
-        })
-            .then(reader)
-            .catch(error => {
-                if (error instanceof Error && error.message.includes('The user aborted a request')) {
-                    end()
-                } else {
-                    params.onError(error)
-                }
-            })
-    }
-
-    async fetch(params: {
-        path: string
-        data: any
-    }) {
-        const { signal, controllerId } = this.createAbortController()
-        try {
-            const result = await this.core.core._axios.post(`${this.core.config.baseUrl}/${params.path}`, params.data, {
-                signal,
-                headers: {
-                    'Content-Type': 'application/json',
-                    ...this.core.config.headers
-                }
-            })
-            return {
-                data: result.data
-            }
-        } finally {
-            this.removeAbortController(controllerId)
-        }
-    }
-
-    cancel() {
-        this.streamAbortControllers.forEach(e => e.controller.abort())
-        this.streamAbortControllers = []
-    }
-
-    export() {
-        return {
-            cancel: this.cancel.bind(this)
-        }
-    }
-}
-
-export class Llama3CppCompletion {
-    core: Llama3Cpp
-    config: Config = {
-        baseUrl: '',
-        headers: {},
-        autoConvertTraditionalChinese: true
-    }
-
-    constructor(core: Llama3Cpp) {
-        this.core = core
-    }
-
-    setConfig(config: Partial<Config>) {
-        this.config = {
-            ...this.config,
-            ...config
-        }
-    }
-
-    completion(params: {
-        options?: Options
-        messages: Message[]
-    }) {
-        const prompts: string[] = []
-        for (let { role, content } of params.messages) {
-            if (role === 'system') {
-                prompts.push(`<|start_header_id|>system<|end_header_id|>\n\n${content}\n\n`)
-            }
-            if (role === 'user') {
-                prompts.push(`<|start_header_id|>user<|end_header_id|>\n\n${content?.replaceAll('\n', '\\n') ?? ''}`)
-            }
-            if (role === 'assistant') {
-                prompts.push('<|start_header_id|>assistant<|end_header_id|>\n\n' + content)
-            }
-        }
-        const lastMessage = params.messages.at(-1) || ''
-        const requester = new Requester(this)
-        return {
-            ...requester.export(),
-            run: async(): Promise<{
-                message: string
-                fullMessage: string
-            }> => {
-                const result = await requester.fetch({
-                    path: 'completion',
-                    data: {
-                        ...(params.options || {}),
-                        prompt: this.config.autoConvertTraditionalChinese ? sify(prompts.join('\n')) : prompts.join('\n')
-                    }
-                })
-                const message = this.config.autoConvertTraditionalChinese ? tify(result.data.content) : result.data.content
-                return {
-                    message,
-                    fullMessage: `${lastMessage}${message}`
-                }
-            }
-        }
-    }
-
-    completionStream(params: Stream & {
-        messages: Message[]
-        options?: Options
-    }) {
-        const prompts: string[] = []
-        for (let { role, content } of params.messages) {
-            if (role === 'system') {
-                prompts.push(`<|start_header_id|>system<|end_header_id|>\n\n${content}\n\n`)
-            }
-            if (role === 'user') {
-                prompts.push(`<|start_header_id|>user<|end_header_id|>\n\n${content?.replaceAll('\n', '\\n') ?? ''}`)
-            }
-            if (role === 'assistant') {
-                prompts.push('<|start_header_id|>assistant<|end_header_id|>\n\n' + content)
-            }
-        }
-        const requester = new Requester(this)
-        requester.stream({
-            path: 'completion',
-            onEnd: params.onEnd || (() => null),
-            onMessage: e => {
-                params.onMessage({
-                    message: this.config.autoConvertTraditionalChinese ? tify(e.content) : e.content
-                })
-            },
-            onWarn: params.onWarn || (() => null),
-            onError: params.onError || (() => null),
-            data: {
-                ...(params.options || {}),
-                prompt: this.config.autoConvertTraditionalChinese ? sify(prompts.join('\n')) : prompts.join('\n'),
-                stream: true
-            }
-        })
-        return requester.export()
-    }
-
-    talk(params: {
-        options?: Options
-        messages: Message[]
-        response_format?: {
-            type: 'json_object',
-            schema: any
-        }
-    }) {
-        const requester = new Requester(this)
-        return {
-            ...requester.export(),
-            run: async(): Promise<{
-                message: string
-            }> => {
-                const result = await requester.fetch({
-                    path: 'v1/chat/completions',
-                    data: {
-                        ...(params.options || {}),
-                        response_format: params.response_format,
-                        messages: params.messages.map(e => {
-                            return {
-                                role: e.role,
-                                content: this.config.autoConvertTraditionalChinese ? sify(e.content) : e.content
-                            }
-                        })
-                    }
-                })
-                const content = result.data.choices[0].message.content || ''
-                return {
-                    message: this.config.autoConvertTraditionalChinese ? tify(content) : content
-                }
-            }
-        }
-    }
-
-    talkStream(params: Stream & {
-        options?: Options
-        messages: Message[]
-    }) {
-        const requester = new Requester(this)
-        requester.stream({
-            path: 'v1/chat/completions',
-            onEnd: params.onEnd || (() => null),
-            onMessage: e => {
-                let content = e.choices[0].delta.content
-                if (content) {
-                    params.onMessage({
-                        message: this.config.autoConvertTraditionalChinese ? tify(content) : content
-                    })
-                }
-            },
-            onWarn: params.onWarn || (() => null),
-            onError: params.onError || (() => null),
-            data: {
-                ...(params.options || {}),
-                stream: true,
-                messages: params.messages.map(e => {
-                    return {
-                        role: e.role,
-                        content: this.config.autoConvertTraditionalChinese ? sify(e.content) : e.content
-                    }
-                })
-            }
-        })
-        return requester.export()
-    }
-}

package/lib/service/llama3.cpp/index.ts

@@ -1,53 +0,0 @@
-import axios, { AxiosInstance } from 'axios'
-import { sify } from 'chinese-conv'
-import { validateToJsonSchema } from '../../utils/validate'
-import { Llama3CppCompletion, Config } from './completion'
-
-export class Llama3Cpp {
-    _axios = axios.create()
-
-    static createChatRequest(params: {
-        config: Partial<Config> | (() => Promise<Partial<Config>>)
-        talkOptions?: any
-    }) {
-        return async(messages: any[], { schema, onCancel }: any) => {
-            const ll3cpp = new Llama3Cpp()
-            const chat = ll3cpp.createCompletion()
-            const config = typeof params.config === 'function' ? await params.config() : params.config
-            chat.setConfig(config)
-            let formatSchema = validateToJsonSchema(schema.output)
-            if (chat.config.autoConvertTraditionalChinese) {
-                formatSchema = JSON.parse(sify(JSON.stringify(formatSchema)))
-            }
-            const { run, cancel } = chat.talk({
-                options: params.talkOptions,
-                messages: messages,
-                response_format: {
-                    type: 'json_object',
-                    schema: formatSchema
-                }
-            })
-            onCancel(cancel)
-            const { message } = await run()
-            return message
-        }
-    }
-
-    /**
-     * @zh 如果你有需要特別設定 axios，請使用這方法。
-     * @en If you need to set axios, please use this method.
-     */
-
-    setAxios(axios: AxiosInstance) {
-        this._axios = axios
-    }
-
-    /**
-     * @zh 建立 補強/ 對話物件。
-     * @en Create completion object.
-     */
-
-    createCompletion() {
-        return new Llama3CppCompletion(this)
-    }
-}

package/lib/service/openai/chat.ts

@@ -1,244 +0,0 @@
-import { json } from 'power-helper'
-import { OpenAI } from './index'
-import { PromiseResponseType } from '../../types'
-
-export type ChatGPTMessage = {
-    role: 'system' | 'user' | 'assistant'
-    name?: string
-    content: string
-}
-
-type ApiResponse = {
-    id: string
-    object: string
-    created: number
-    choices: Array<{
-        index: number
-        finish_reason: string
-        message: {
-            role: 'system' | 'user' | 'assistant'
-            name?: string
-            content: string
-        }
-    }>
-    usage: {
-        prompt_tokens: number
-        completion_tokens: number
-        total_tokens: number
-    }
-}
-
-export type Config = {
-    /**
-     * @zh 一次回應數量
-     * @en How many chat completion choices to generate for each input message.
-     */
-    n: number
-    /**
-     * @zh 選擇運行的模型，16k意味著能處理長度為 16,384 的文本，32k意味著能處理長度為 32768 的文本。
-     * @en How many chat completion choices to generate for each input message.
-     */
-    model: 'gpt-4' | 'gpt-3.5-turbo' | 'gpt-4-turbo' | 'gpt-4o' | 'gpt-4o-mini' | 'o1-preview' | 'o1' | 'o1-mini'
-    /**
-     * @zh 冒險指數，數值由 0 ~ 2 之間，越低回應越穩定。
-     * @en What sampling temperature to use, between 0 and 2. Higher values like 0.8 will make the output more random, while lower values like 0.2 will make it more focused and deterministic.
-     */
-    temperature: number
-    /**
-     * @zh 是否強制要回傳 JSON 格式的資料
-     * @en Whether to force the return of JSON format data
-     */
-    forceJsonFormat: boolean
-    /**
-     * @zh 每次對話最多產生幾個 tokens。
-     * @en How many tokens to complete to.
-     */
-    maxTokens?: number
-}
-
-export class OpenAIChat {
-    openai: OpenAI
-    config: Config = {
-        n: 1,
-        model: 'gpt-4o',
-        temperature: 1,
-        maxTokens: undefined,
-        forceJsonFormat: true
-    }
-
-    constructor(openai: OpenAI) {
-        this.openai = openai
-    }
-
-    /**
-     * @zh 改變對話的一些設定
-     * @en Change some settings of the conversation
-     */
-
-    setConfig(options: Partial<Config>) {
-        Object.assign(this.config, options)
-    }
-
-    /**
-     * @zh 檢視內容是否符合 OpenAI 的審查
-     * @en View content for OpenAI moderation
-     */
-
-    async moderations(input: string) {
-        const result = await this.openai._axios.post<any>('https://api.openai.com/v1/moderations', {
-            input: input
-        }, {
-            headers: {
-                'Content-Type': 'application/json',
-                'Authorization': `Bearer ${this.openai._apiKey}`
-            }
-        })
-        return {
-            isSafe: result.data.results?.[0]?.flagged === false,
-            result: result.data
-        }
-    }
-
-    /**
-     * @zh 進行對話
-     * @en Talk to the AI
-     */
-
-    async talk(messages: ChatGPTMessage[] = [], options?: {
-        /** 要 forceJsonFormat 為 true 才會生效 */
-        jsonSchema?: any
-        abortController?: AbortController
-    }) {
-        const newMessages = json.jpjs(messages)
-        const isSupportJson =  [
-            'gpt-4-turbo-preview',
-            'gpt-4-turbo',
-            'gpt-4o',
-            'gpt-4o-mini',
-            'gpt-3.5-turbo-1106'
-        ].includes(this.config.model)
-        let response_format: any = undefined
-        if (isSupportJson && this.config.forceJsonFormat) {
-            response_format = {
-                type: 'json_object'
-            }
-        }
-        if (isSupportJson && this.config.forceJsonFormat && options?.jsonSchema) {
-            response_format = {
-                type: 'json_schema',
-                json_schema: options.jsonSchema
-            }
-        }
-        const result = await this.openai._axios.post<ApiResponse>('https://api.openai.com/v1/chat/completions', {
-            model: this.config.model,
-            n: this.config.n,
-            messages: newMessages,
-            response_format,
-            temperature: this.config.temperature
-        }, {
-            signal: options?.abortController?.signal,
-            headers: {
-                'Content-Type': 'application/json',
-                'Authorization': `Bearer ${this.openai._apiKey}`
-            }
-        })
-        const choices = result.data.choices || []
-        const message = choices[0]?.message || {
-            role: 'assistant',
-            content: ''
-        }
-        newMessages.push(message)
-        return {
-            id: result?.data.id as string,
-            text: message.content as string,
-            newMessages,
-            isDone: choices[0]?.finish_reason === 'stop',
-            apiReseponse: result.data
-        }
-    }
-
-    talkStream(params: {
-        messages: any[]
-        onMessage: (message: string) => void
-        onEnd: () => void
-        onWarn: (warn: any) => void
-        onError: (error: any) => void
-    }) {
-        const controller = new AbortController()
-        fetch('https://api.openai.com/v1/chat/completions', {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                Authorization: `Bearer ${this.openai._apiKey}`
-            },
-            body: JSON.stringify({
-                model: this.config.model,
-                stream: true,
-                messages: params.messages
-            }),
-            signal: controller.signal
-        }).then(async response => {
-            // eslint-disable-next-line no-undef
-            const reader = response.body?.pipeThrough(new TextDecoderStream()).getReader()
-            if (!reader) {
-                throw new Error('Can not get reader')
-            }
-            // eslint-disable-next-line no-constant-condition
-            while (true) {
-                const { value, done } = await reader.read()
-                if (done) {
-                    break
-                }
-                const items = value.split('\n')
-                for (let item of items) {
-                    if (item.length === 0) {
-                        continue
-                    }
-                    if (item.startsWith(':')) {
-                        continue
-                    }
-                    if (item === 'data: [DONE]') {
-                        params.onEnd()
-                        break
-                    }
-                    try {
-                        const result = JSON.parse(item.substring(6))
-                        const content = result.choices[0].delta.content
-                        params.onMessage(content)
-                    } catch (error) {
-                        params.onWarn(error)
-                    }
-                }
-            }
-        }).catch(error => {
-            if (error.name === 'AbortError') {
-                params.onEnd()
-            } else {
-                params.onError(error)
-            }
-        })
-        return {
-            cancel: () => controller.abort()
-        }
-    }
-
-    /**
-     * @zh 開啟持續性對話
-     */
-
-    async keepTalk(prompt: string | string[], oldMessages: ChatGPTMessage[] = []) {
-        const result = await this.talk([
-            ...oldMessages,
-            {
-                role: 'user',
-                content: Array.isArray(prompt) ? prompt.join('\n') : prompt
-            }
-        ])
-        return {
-            result,
-            nextTalk: (prompt: string | string[]) => this.keepTalk(prompt, result.newMessages)
-        }
-    }
-}
-
-export type OpenAIChatTalkResponse = PromiseResponseType<OpenAIChat['talk']>

package/lib/service/openai/images-generation.ts

@@ -1,64 +0,0 @@
-import { OpenAI } from './index'
-
-type ApiResponse = {
-    created: string
-    data: {
-        b64_json: string
-    }[]
-}
-
-type Config = {
-    /**
-     * @zh 模型，支援 dall-e-2 和 dall-e-3
-     * @en Model, support dall-e-2 and dall-e-3
-     */
-    model: 'dall-e-2' | 'dall-e-3'
-    /**
-     * @zh 解析度，例如 1024x1024
-     * @en Resolution, for example 1024x1024
-     */
-    size: `${number}x${number}`
-}
-
-export class OpenAIImagesGeneration {
-    private openai: OpenAI
-    private config: Config = {
-        model: 'dall-e-2',
-        size: '1024x1024'
-    }
-
-    constructor(openai: OpenAI) {
-        this.openai = openai
-    }
-
-    /**
-     * @zh 改變對話的一些設定
-     * @en Change some settings of the conversation
-     */
-
-    setConfig(options: Partial<Config>) {
-        Object.assign(this.config, options)
-    }
-
-    /**
-     * @zh 產生圖片
-     * @en Generate image
-     */
-
-    async create(prompt: string) {
-        const result = await this.openai._axios.post<ApiResponse>('https://api.openai.com/v1/images/generations', {
-            prompt,
-            n: 1,
-            size: this.config.size,
-            model: this.config.model,
-            response_format: 'b64_json'
-        }, {
-            timeout: 1000 * 60 * 5,
-            headers: {
-                'Content-Type': 'application/json',
-                'Authorization': `Bearer ${this.openai._apiKey}`
-            }
-        })
-        return result.data
-    }
-}