ctod 0.7.0 → 0.7.1

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'] : R[K]
-}
-
-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'] : R[K]
-    }
-}
-
-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
-}