ctod 0.6.3 → 0.7.1

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
-    }
-}

package/lib/service/openai/index.ts

@@ -1,97 +0,0 @@
-import axios from 'axios'
-import { OpenAIVision } from './vision'
-import { OpenAIChat, Config } from './chat'
-import { OpenAIImagesGeneration } from './images-generation'
-import { validateToJsonSchema } from '../../utils/validate'
-
-export class OpenAI {
-    _axios = axios.create()
-    _apiKey = ''
-
-    static createChatRequest(
-        apiKey: string | (() => Promise<string>),
-        config: Partial<Config> | (() => Promise<Partial<Config>>) = {},
-        options?: {
-            axios?: any
-        }    
-    ) {
-        return async(messages: any[], { onCancel }: any) => {
-            const openai = new OpenAI(typeof apiKey === 'string' ? apiKey : await apiKey())
-            const chat = openai.createChat()
-            const abortController = new AbortController()
-            if (options && options.axios) {
-                openai.setAxios(options.axios)
-            }
-            chat.setConfig(typeof config === 'function' ? await config() : config)
-            onCancel(() => abortController.abort())
-            const { text } = await chat.talk(messages, {
-                abortController
-            })
-            return text
-        }
-    }
-
-    static createChatRequestWithJsonSchema(params:{
-        axios?: any,
-        apiKey: string | (() => Promise<string>),
-        config?: Partial<Pick<Config, 'model' | 'temperature'>> | (() => Promise<Partial<Pick<Config, 'model' | 'temperature'>>>)
-    }) {
-        return async(messages: any[], { schema, onCancel }: any) => {
-            const openai = new OpenAI(typeof params.apiKey === 'string' ? params.apiKey : await params.apiKey())
-            const chat = openai.createChat()
-            const abortController = new AbortController()
-            if (params.config) {
-                chat.setConfig(typeof params.config === 'function' ? await params.config() : params.config)
-            }
-            if (params.axios) {
-                openai.setAxios(params.axios)
-            }
-            onCancel(() => abortController.abort())
-            const jsonSchema = validateToJsonSchema(schema.output)
-            const { text } = await chat.talk(messages, {
-                abortController,
-                jsonSchema: {
-                    name: 'data',
-                    strict: true,
-                    schema: jsonSchema
-                }
-            })
-            return text
-        }
-    }
-
-
-    constructor(apiKey = '') {
-        this._apiKey = apiKey
-    }
-
-    /**
-     * @zh 如果你有需要特別設定 axios，請使用這方法。
-     * @en If you need to set axios, please use this method.
-     */
-
-    setAxios(axios: any) {
-        this._axios = axios
-    }
-
-    /**
-     * @zh 設定 api key。
-     * @en Set api key.
-     */
-
-    setConfiguration(apiKey: string) {
-        this._apiKey = apiKey
-    }
-
-    createChat() {
-        return new OpenAIChat(this)
-    }
-
-    createVision() {
-        return new OpenAIVision(this)
-    }
-
-    createImagesGeneration() {
-        return new OpenAIImagesGeneration(this)
-    }
-}

package/lib/service/openai/vision.ts

@@ -1,111 +0,0 @@
-import { OpenAI } from './index'
-import { PromiseResponseType } from '../../types'
-
-type ImageContent = {
-    type: 'image_url' | 'text'
-    text?: string
-    image_url?: {
-        url: string
-        detail?: string
-    }
-}
-
-type VisionMessage = {
-    role: 'system' | 'user' | 'assistant'
-    name?: string
-    content: string | ImageContent[]
-}
-
-type ApiResponse = {
-    id: string
-    object: string
-    created: number
-    model: string
-    usage: {
-        prompt_tokens: number
-        completion_tokens: number
-        total_tokens: number
-    }
-    choices: Array<{
-        message: {
-            role: string
-            content: string
-        }
-        finish_details: {
-            type: string
-        }
-        index: number
-    }>
-}
-
-export type Config = {
-    /**
-     * @zh 選擇運行的模型。
-     * @en How many chat completion choices to generate for each input message.
-     */
-    model: 'gpt-4-vision-preview'
-    /**
-     * @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 每次對話最多產生幾個 tokens。
-     * @en How many tokens to complete to.
-     */
-    maxTokens?: number
-}
-
-export class OpenAIVision {
-    openai: OpenAI
-    config: Config = {
-        model: 'gpt-4-vision-preview',
-        maxTokens: undefined,
-        temperature: 1
-    }
-
-    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 Recognize images
-     */
-
-    async view(messages: VisionMessage[]) {
-        const result = await this.openai._axios.post<ApiResponse>('https://api.openai.com/v1/chat/completions', {
-            model: this.config.model,
-            n: 1,
-            messages,
-            max_tokens: this.config.maxTokens,
-            temperature: this.config.temperature
-        }, {
-            headers: {
-                'Content-Type': 'application/json',
-                'Authorization': `Bearer ${this.openai._apiKey}`
-            }
-        })
-        const choices = result.data.choices || []
-        const message = choices[0]?.message || {
-            role: 'assistant',
-            content: ''
-        }
-        return {
-            id: result?.data.id as string,
-            text: message.content as string,
-            apiReseponse: result.data
-        }
-    }
-}
-
-export type OpenAIChatVisionResponse = PromiseResponseType<OpenAIVision['view']>

package/lib/shims.d.ts

@@ -1,4 +0,0 @@
-declare module 'chinese-conv' {
-    export function tify(text: string): string
-    export function sify(text: string): string
-}

package/lib/templates.ts

@@ -1,71 +0,0 @@
-import Handlebars from 'handlebars'
-import { record } from 'power-helper'
-
-type JsonResponseFormat = {
-    desc: string
-    example: any
-}
-
-/**
- * @zh 協助使用者將格式需求轉成論敘語句。
- * @en Assist the user in converting the formatting requirements into declarative sentences.
- */
-
-export const requireJsonResponse = (question: string | string[], format: Record<string, JsonResponseFormat>) => {
-    return [
-        ...(Array.isArray(question) ? question : [question]),
-        'Please respond using the following JSON format and minify the JSON without including any explanation: ',
-        '{',
-        Object.entries(format).map(([key, value]) => {
-            return [
-                `/* ${value.desc} */`,
-                `"${key}": ${JSON.stringify(value.example)}`,
-            ].join('\n')
-        }).join(',\n'),
-        '}'
-    ].join('\n')
-}
-
-/**
- * @zh 協助使用者將格式需求轉成論敘語句，支援 Handlebars。
- * @en Assist the user in converting the formatting requirements into declarative sentences, support Handlebars.
- */
-
-export const requireJsonResponseWithHandlebars = (
-    value: Record<string, any>,
-    question: string | string[],
-    format: Record<string, JsonResponseFormat>
-) => {
-    const handlebars = Handlebars.create()
-
-    handlebars.registerHelper('DATA', function(this: any, value) {
-        return JSON.stringify(value)
-    })
-
-    handlebars.registerHelper('ENV', function(this: any, value) {
-        return this.__envs && value ? this.__envs[value] : ''
-    })
-
-    handlebars.registerHelper('INPUT', function(this: any) {
-        return JSON.stringify(record.omit(this, ['__envs']))
-    })
-
-    handlebars.registerHelper('JOIN', function(this: any, value) {
-        return Array.isArray(value) ? value.join() : JSON.stringify(value)
-    })
-
-    return handlebars.compile(requireJsonResponse(question, format))(value)
-}
-
-/**
- * @zh 協助使用者將格式需求轉成論敘語句，並支援 Json Schema。
- * @en Assist the user in converting the formatting requirements into declarative sentences, and support Json Schema.
- */
-
-export const requireJsonResponseWithJsonSchema = (question: string | string[], format: Record<string, any>) => {
-    return [
-        ...(Array.isArray(question) ? question : [question]),
-        'Please provide JSON data according to the following JSON Schema format:',
-        JSON.stringify(format)
-    ].join('\n')
-}

package/lib/types.ts

@@ -1,4 +0,0 @@
-export type PromiseResponseType<
-    T extends (...args: any) => Promise<any>,
-    R = Parameters<ReturnType<T>['then']>[0]
-> =  R extends (value: infer P) => any ? P : never

package/lib/utils/error.ts

@@ -1,14 +0,0 @@
-type ParserFail = {
-    name: string
-    error: any
-}
-
-export class ParserError {
-    isParserError = true
-    parserFails: ParserFail[] = []
-    error: any
-    constructor(error: any, parserFails: ParserFail[]) {
-        this.error = error
-        this.parserFails = parserFails
-    }
-}

package/lib/utils/validate.ts

@@ -1,64 +0,0 @@
-import * as Yup from 'yup'
-import { convertSchema } from '@sodaru/yup-to-json-schema'
-import { Schema } from 'yup'
-
-export type ValidateCallback<T extends Record<string, Schema>> = (_yup: typeof Yup) => {
-    [K in keyof T]: T[K]
-}
-
-export type ValidateCallbackOutputs<
-    T extends ValidateCallback<any>,
-    R = ReturnType<T>
-> = {
-    [K in keyof R]: R[K] extends { '__outputType': any } ? R[K]['__outputType'] : unknown
-}
-
-export function definedValidateSchema<T extends ValidateCallback<any>>(cb: T): T {
-    return cb
-}
-
-export function validate<
-    T extends ValidateCallback<any>,
-    R = ReturnType<T>
->(target: any, schemaCallback: T) {
-    return Yup.object(schemaCallback(Yup)).required().validateSync(target || {}) as {
-        [K in keyof R]: R[K] extends { '__outputType': any } ? R[K]['__outputType'] : unknown
-    }
-}
-
-export const defineYupSchema = <T extends Record<string, Schema>>(cb: ValidateCallback<T>): T => {
-    return cb(Yup)
-}
-
-export const validateToJsonSchema = <T extends ValidateCallback<any>>(cb: T) => {
-    const removeAllDefault = (schema: any) => {
-        if (schema.default) {
-            delete schema.default
-        }
-        if (schema.properties) {
-            for (let key in schema.properties) {
-                if (schema.properties[key].default) {
-                    delete schema.properties[key].default
-                }
-                removeAllDefault(schema.properties[key])
-            }
-        }
-        if (schema.items) {
-            removeAllDefault(schema.items)
-        }
-    }
-    const addAllAdditionalProperties = (jsonSchema: any) => {
-        if (jsonSchema.type === 'object') {
-            jsonSchema.additionalProperties = false
-            for (const key in jsonSchema.properties) {
-                addAllAdditionalProperties(jsonSchema.properties[key])
-            }
-        } else if (jsonSchema.type === 'array') {
-            addAllAdditionalProperties(jsonSchema.items)
-        }
-    }
-    const jsonSchema = convertSchema(Yup.object(cb(Yup)))
-    removeAllDefault(jsonSchema)
-    addAllAdditionalProperties(jsonSchema)
-    return jsonSchema
-}