@cloudbase/ai 3.6.5-alpha.0 → 3.6.5-alpha.2

package/.eslintignore

@@ -0,0 +1,2 @@
+dist/
+node_modules/

package/.eslintrc.js

@@ -0,0 +1,16 @@
+module.exports = {
+    "extends": [
+        "../../.eslintrc.js"
+    ],
+    "parser": "@typescript-eslint/parser",
+
+    overrides: [
+        {
+            files: ['*.ts'],
+            parserOptions: {
+                project: ['./tsconfig.json'],
+                tsconfigRootDir: __dirname,
+            },
+        },
+    ],
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cloudbase/ai",
-  "version": "3.6.5-alpha.0",
+  "version": "3.6.5-alpha.2",
   "description": "cloudbase js sdk ai module",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",
@@ -30,8 +30,8 @@
   "author": "",
   "license": "Apache-2.0",
   "dependencies": {
-    "@cloudbase/types": "^3.6.5-alpha.0",
-    "@cloudbase/utilities": "^3.6.5-alpha.0",
+    "@cloudbase/types": "3.6.5-alpha.0",
+    "@cloudbase/utilities": "3.6.5-alpha.0",
     "@mattiasbuelens/web-streams-adapter": "^0.1.0",
     "text-encoding-shim": "^1.0.5",
     "web-streams-polyfill": "^4.0.0"
@@ -39,9 +39,5 @@
   "devDependencies": {
     "@cloudbase/adapter-interface": "^0.7.1"
   },
-  "gitHead": "1d601bbe3490e54b2481849f194cbb989dd1e675",
-  "types": "dist/cjs/index.d.ts",
-  "files": [
-    "dist/"
-  ]
+  "gitHead": "6afb931a6dbe46151514627109b2a03f0554ae70"
 }

package/src/AI.ts

@@ -0,0 +1,191 @@
+/* eslint-disable eqeqeq */
+/* eslint-disable @typescript-eslint/naming-convention */
+import type { SDKRequestInterface } from '@cloudbase/adapter-interface'
+import { Bot } from './bot'
+import * as models from './models'
+import * as types from './type'
+import { readableStream2JsonObject } from './utils'
+import { ICloudbaseConfig } from '@cloudbase/types'
+import { langEvent } from '@cloudbase/utilities'
+
+const { MODELS } = models
+
+class AI {
+  public bot: Bot
+  public i18n: ICloudbaseConfig['i18n']
+  defaultHeaders: { [x: string]: any }
+  private _getBaseUrl?: () => string
+
+  /** 动态获取 aiBaseUrl，支持 registerEndPointWithKey 后端点变更生效 */
+  get aiBaseUrl(): string {
+    return `${this._getBaseUrl ? this._getBaseUrl() : this.baseUrl}/ai`
+  }
+
+  /** 动态获取 aiBotBaseUrl，支持 registerEndPointWithKey 后端点变更生效 */
+  get aiBotBaseUrl(): string {
+    return `${this._getBaseUrl ? this._getBaseUrl() : this.baseUrl}/aibot`
+  }
+
+  constructor(
+    private req: SDKRequestInterface,
+    public baseUrl: string,
+    i18n: ICloudbaseConfig['i18n'],
+    getBaseUrl?: () => string,
+  ) {
+    this._getBaseUrl = getBaseUrl
+    this.bot = new Bot(this.botRequest, this.aiBotBaseUrl)
+    this.i18n = i18n
+
+    langEvent.bus.on(langEvent.LANG_CHANGE_EVENT, (params) => {
+      this.i18n = params.data?.i18n || this.i18n
+    })
+  }
+
+  async handleResponseData(responseData: Promise<unknown> | ReadableStream<Uint8Array>, header?: Headers) {
+    const GO_TO_AI_TEXT = `${this.i18n.t('请检查调用方式，或前往云开发 AI+ 首页查看文档')}：https://tcb.cloud.tencent.com/dev#/ai`
+
+    const throwIfError = (json: unknown) => {
+      if (typeof json === 'object' && json && 'code' in json && (json as any).code !== 'NORMAL') {
+        throw new Error(`${this.i18n.t('AI+ 请求出错，错误码')}：${(json as any).code}，${this.i18n.t('错误信息')}：${
+          (json as any).message
+        }\n${GO_TO_AI_TEXT}\n${JSON.stringify(json, null, 2)}`,)
+      }
+    }
+
+    // 非流式请求：
+    // - 小程序/Web 适配器返回 Promise（has 'then'）
+    // - Node 适配器已将 body 解析为普通对象（无 'then'、无 getReader）
+    // 两种情况都按 JSON 校验错误码后原样返回
+    if (typeof responseData === 'object' && responseData && typeof (responseData as any).getReader !== 'function') {
+      const json = 'then' in responseData ? await responseData : responseData
+      throwIfError(json)
+      return responseData
+    }
+
+    // 判断 responseData 是否是 ReadableStream 实例（兼容 Node.js 适配器非流式场景已解析为 JSON 对象的情况）
+    const isStream = typeof (responseData as any)?.getReader === 'function'
+
+    if (!isStream) {
+      // responseData 已经是解析后的 JSON 对象（如 Node.js 适配器非流式返回），直接检查错误码
+      const json = responseData as unknown as Record<string, unknown>
+      if (typeof json === 'object' && json && 'code' in json && json.code !== 'NORMAL') {
+        throw new Error(`${this.i18n.t('AI+ 请求出错，错误码')}：${json.code}，${this.i18n.t('错误信息')}：${
+          json.message
+        }\n${GO_TO_AI_TEXT}\n${JSON.stringify(json, null, 2)}`,)
+      }
+      return responseData
+    }
+
+    // 流式请求，如果接口出错，会变成传 json 格式的响应，通过 header 判断格式
+    if (header?.get?.('content-type')?.includes('application/json')) {
+      const json = await readableStream2JsonObject(responseData as ReadableStream<Uint8Array>)
+      throwIfError(json)
+    }
+    return responseData
+  }
+
+  createModel(
+    model: string,
+    options?: {
+      defaultModelSubUrl?: string
+    },
+  ) {
+    let simpleModel: types.SimpleChatModel
+
+    const SimpleModelConstructor = MODELS[model]
+    if (SimpleModelConstructor) {
+      simpleModel = new SimpleModelConstructor(this.modelRequest, this.aiBaseUrl)
+    } else {
+      const subUrl = typeof options?.defaultModelSubUrl === 'string' ? options.defaultModelSubUrl : '/chat/completions'
+
+      simpleModel = new models.DefaultSimpleModel(this.modelRequest, this.aiBaseUrl, `${model}${subUrl}`)
+    }
+
+    const reactModel = new models.ReactModel(simpleModel)
+    return reactModel
+  }
+
+  registerModel(name: string, model: types.ChatModelConstructor) {
+    if (MODELS[name] != null) {
+      console.warn(`AI model ${name} already exists!`)
+      return
+    }
+    MODELS[name] = model
+  }
+
+  createImageModel<T extends 'hunyuan-image' | (string & {})>(provider: T) {
+    return new models.DefaultImageModel<T>(this.modelRequest, this.aiBaseUrl, provider)
+  }
+
+  modelRequest: types.ModelReq = async ({ url, data, headers, stream, timeout }) => {
+    const fetchHeaders = {
+      'Content-Type': 'application/json',
+    }
+    // 带 Accept: text/event-stream  请求头显式指定是 SSE 绕过 60s 的限制
+    stream && Object.assign(fetchHeaders, { Accept: 'text/event-stream' })
+
+    const { data: responseData, header } = (await this.req.fetch({
+      method: 'post',
+      headers: { [this.i18n?.LANG_HEADER_KEY]: this.i18n?.lang, ...fetchHeaders, ...headers },
+      body: JSON.stringify(data),
+      url: this.resolveUrl(url),
+      stream,
+      timeout,
+    })) as { data: Promise<unknown> | ReadableStream<Uint8Array>; header?: Headers }
+
+    return this.handleResponseData(responseData, header) as any
+  }
+
+  botRequest: types.BotReq = async ({ method, url, data = {}, headers, stream, timeout }) => {
+    const resolvedUrl = this.resolveUrl(url)
+    if (method === 'get') {
+      return this.handleResponseData((await this.req.fetch({ url: `${resolvedUrl}?${objectToParam(data)}`, method, headers, stream, timeout })).data,)
+    }
+
+    const fetchHeaders = {
+      'Content-Type': 'application/json',
+    }
+    // 带 Accept: text/event-stream  请求头显式指定是 SSE 绕过 60s 的限制
+    stream && Object.assign(fetchHeaders, { Accept: 'text/event-stream' })
+
+    const { data: responseData, header } = (await this.req.fetch({
+      url: resolvedUrl,
+      body: JSON.stringify(data),
+      headers: {
+        [this.i18n?.LANG_HEADER_KEY]: this.i18n?.lang,
+        ...fetchHeaders,
+        ...headers,
+      },
+      stream,
+      method,
+      timeout,
+    })) as { data: Promise<unknown> | ReadableStream<Uint8Array>; header?: Headers }
+
+    return this.handleResponseData(responseData, header) as any
+
+    function objectToParam(obj: Object) {
+      return Object.entries(obj)
+        .map(([key, value]) => `${key}=${value}`)
+        .join('&')
+    }
+  }
+
+  registerFunctionTool(functionTool: types.FunctionTool) {
+    if (models.toolMap.has(functionTool.name)) {
+      console.warn(`AI function tool ${functionTool.name} already exists and will be overwritten!`)
+    }
+    models.toolMap.set(functionTool.name, functionTool.fn)
+  }
+
+  /** 动态替换 URL 中的 origin 部分，支持 registerEndPointWithKey 后生效 */
+  private resolveUrl(url: string): string {
+    if (!this._getBaseUrl) return url
+    const currentBase = this._getBaseUrl()
+    if (currentBase !== this.baseUrl && url.startsWith(this.baseUrl)) {
+      return url.replace(this.baseUrl, currentBase)
+    }
+    return url
+  }
+}
+
+export { AI }

package/src/bot/index.ts

@@ -0,0 +1,278 @@
+import { type ParsedEvent } from '../eventsource_parser'
+import { BotReq, ReqOptions } from '../type'
+import {
+  IBotCreateConversation,
+  IBotDeleteConversation,
+  IBotGetConversation,
+  IBotGetTextToSpeechResult,
+  IBotPreview,
+  IBotSendMessage,
+  IBotSpeechToText,
+  IBotTextToSpeech,
+  IBotUploadFiles,
+  ICreateBot,
+  IDeleteBot,
+  IGenerateBot,
+  IGenerateImage,
+  IGetBot,
+  IGetBotChatRecords,
+  IGetBotFeedback,
+  IGetBotList,
+  IGetBotRecommendQuestions,
+  ISendBotFeedback,
+  IUpdateBot,
+} from './types'
+import {
+  createAsyncIterable,
+  toPolyfillReadable,
+  createEventSourceParserTransformStream,
+  TextDecoderStream,
+  TransformStream,
+} from '../utils'
+
+export class Bot {
+  req: BotReq
+
+  constructor(req: BotReq, public baseUrl: string) {
+    // eslint-disable-next-line prefer-rest-params
+    const token = arguments[2]
+    if (typeof token === 'string') {
+      this.req = ({ headers = {}, ...rest }) => req({ ...rest, headers: { ...headers, Authorization: `Bearer ${token}` } })
+    } else {
+      this.req = req
+    }
+  }
+
+  list(props: IGetBotList, options?: ReqOptions) {
+    return this.req({
+      method: 'get',
+      url: this.join('bots'),
+      data: props,
+      timeout: options?.timeout,
+    })
+  }
+
+  create({ botInfo }: ICreateBot, options?: ReqOptions) {
+    return this.req({
+      method: 'post',
+      url: this.join('bots'),
+      data: botInfo,
+      timeout: options?.timeout,
+    })
+  }
+
+  get({ botId }: IGetBot, options?: ReqOptions) {
+    return this.req({
+      method: 'get',
+      url: this.join(`bots/${botId}`),
+      timeout: options?.timeout,
+    })
+  }
+
+  update({ botId, botInfo }: IUpdateBot, options?: ReqOptions) {
+    return this.req({
+      method: 'PATCH',
+      url: this.join(`bots/${botId}`),
+      data: botInfo,
+      timeout: options?.timeout,
+    })
+  }
+
+  delete({ botId }: IDeleteBot, options?: ReqOptions) {
+    return this.req({ method: 'delete', url: this.join(`bots/${botId}`), timeout: options?.timeout })
+  }
+
+  getChatRecords(props: IGetBotChatRecords, options?: ReqOptions) {
+    return this.req({
+      method: 'get',
+      url: this.join(`bots/${props.botId}/records`),
+      data: props,
+      timeout: options?.timeout,
+    })
+  }
+
+  sendFeedback({ userFeedback }: ISendBotFeedback, options?: ReqOptions) {
+    return this.req({
+      method: 'post',
+      url: this.join(`bots/${userFeedback.botId}/feedback`),
+      data: userFeedback,
+      timeout: options?.timeout,
+    })
+  }
+
+  getFeedback(props: IGetBotFeedback, options?: ReqOptions) {
+    return this.req({
+      method: 'get',
+      url: this.join(`bots/${props.botId}/feedback`),
+      data: props,
+      timeout: options?.timeout,
+    })
+  }
+
+  async uploadFiles(props: IBotUploadFiles, options?: ReqOptions) {
+    return this.req({
+      method: 'post',
+      url: this.join(`bots/${props.botId}/files`),
+      data: props,
+      timeout: options?.timeout,
+    })
+  }
+
+  async createConversation({ botId, ...rest }: IBotCreateConversation, options?: ReqOptions) {
+    return this.req({
+      method: 'post',
+      url: this.join(`bots/${botId}/conversation`),
+      data: rest,
+      timeout: options?.timeout,
+    })
+  }
+
+  async getConversation({ pageSize = 10, pageNumber = 1, botId, ...rest }: IBotGetConversation, options?: ReqOptions) {
+    if (pageNumber < 1) throw new Error('pageNumber must be greater than 0')
+    const offset = pageSize * (pageNumber - 1)
+    const limit = pageSize
+    return this.req({
+      method: 'get',
+      url: this.join(`bots/${botId}/conversation`),
+      data: { ...rest, offset, limit },
+      timeout: options?.timeout,
+    })
+  }
+
+  async deleteConversation({ botId, conversationId, ...rest }: IBotDeleteConversation, options?: ReqOptions) {
+    return this.req({
+      method: 'delete',
+      url: this.join(`bots/${botId}/conversation/${conversationId}`),
+      data: rest,
+      timeout: options?.timeout,
+    })
+  }
+
+  async speechToText(props: IBotSpeechToText, options?: ReqOptions) {
+    return this.req({
+      method: 'post',
+      url: this.join(`bots/${props.botId}/speech-to-text`),
+      data: props,
+      timeout: options?.timeout,
+    })
+  }
+
+  async textToSpeech(props: IBotTextToSpeech, options?: ReqOptions) {
+    return this.req({
+      method: 'post',
+      url: this.join(`bots/${props.botId}/text-to-speech`),
+      data: props,
+      timeout: options?.timeout,
+    })
+  }
+
+  async getTextToSpeechResult(props: IBotGetTextToSpeechResult, options?: ReqOptions) {
+    return this.req({
+      method: 'get',
+      url: this.join(`bots/${props.botId}/text-to-speech`),
+      data: props,
+      timeout: options?.timeout,
+    })
+  }
+
+  async getRecommendQuestions(props: IGetBotRecommendQuestions, options?: ReqOptions) {
+    const res = await this.req({
+      method: 'post',
+      url: this.join(`bots/${props.botId}/recommend-questions`),
+      data: props,
+      stream: true,
+      timeout: options?.timeout,
+    })
+    return new StreamResult(res)
+  }
+
+  async generateBot(props: IGenerateBot, options?: ReqOptions) {
+    const res = await this.req({
+      method: 'post',
+      url: this.join('generate-bot'),
+      data: props,
+      stream: true,
+      timeout: options?.timeout,
+    })
+    return new StreamResult(res)
+  }
+
+  async getPreview(props: IBotPreview, options?: ReqOptions) {
+    const res = await this.req({
+      method: 'post',
+      url: this.join('preview'),
+      data: props,
+      stream: true,
+      timeout: options?.timeout,
+    })
+    return new StreamResult(res)
+  }
+
+  generateImage(props: IGenerateImage, options?: ReqOptions) {
+    return this.req({ method: 'post', url: this.join('generate-image'), data: props, timeout: options?.timeout })
+  }
+
+  async sendMessage(props: IBotSendMessage, options?: ReqOptions) {
+    const res = await this.req({
+      method: 'post',
+      url: this.join(`bots/${props.botId}/send-message`),
+      data: props,
+      stream: true,
+      timeout: options?.timeout,
+    })
+    return new StreamResult(res)
+  }
+
+  private join(url: string) {
+    return `${this.baseUrl}/${url}`
+  }
+}
+
+type BotEventStreamData = { content: string }
+
+class StreamResult {
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  private _eventSourceStream: ReadableStream<ParsedEvent>
+
+  constructor(_stream: ReadableStream<Uint8Array>) {
+    const stream = toPolyfillReadable(_stream) as typeof _stream
+    this._eventSourceStream = stream
+      .pipeThrough(new TextDecoderStream())
+      .pipeThrough(createEventSourceParserTransformStream())
+  }
+
+  private get teeedStream() {
+    const [s1, s2] = this._eventSourceStream.tee()
+    this._eventSourceStream = s2
+    return s1
+  }
+
+  get eventSourceStream() {
+    return createAsyncIterable(this.teeedStream)
+  }
+
+  get dataStream() {
+    return createAsyncIterable(this.eventSourceStream.pipeThrough(new TransformStream<ParsedEvent, BotEventStreamData>({
+      transform(chunk, controller) {
+        try {
+          const data = JSON.parse(chunk.data)
+          controller.enqueue(data)
+        } catch (e) {
+          if (chunk.data !== '[DONE]') {
+            console.warn('Error when transforming event source data to json', e, chunk)
+          } else {
+            controller.terminate()
+          }
+        }
+      },
+    }),),)
+  }
+
+  get textStream() {
+    return createAsyncIterable(this.dataStream.pipeThrough(new TransformStream<BotEventStreamData, string>({
+      transform(chunk, controller) {
+        controller.enqueue(chunk?.content ?? '')
+      },
+    }),),)
+  }
+}

package/src/bot/types.ts

@@ -0,0 +1,165 @@
+export interface IGetBotList {
+  name: string
+  introduction: string
+  information: string
+  enable: boolean
+  pageSize: number
+  pageNumber: number
+}
+
+export interface ICreateBot {
+  botInfo: BotInfo
+}
+
+export interface IGetBot {
+  botId: string
+}
+
+export interface IUpdateBot {
+  botId: string
+  botInfo: BotInfo
+}
+
+export interface IDeleteBot {
+  botId: string
+}
+
+export interface IGetBotChatRecords {
+  botId: string
+  sort: 'asc' | 'desc' | string
+  pageSize: number
+  pageNumber: number
+}
+
+export interface ISendBotFeedback {
+  userFeedback: IUserFeedback
+}
+
+export interface IGetBotFeedback {
+  botId: string
+  type: 'upvote' | 'downvote' | string
+  sender: string
+  senderFilter: 'include' | 'exclude' | 'equal' | 'unequal' | 'prefix' | string
+  minRating: number
+  maxRating: number
+  from: number
+  to: number
+  pageSize: number
+  pageNumber: number
+}
+
+export interface IGetBotRecommendQuestions {
+  botId: string
+  name: string
+  introduction: string
+  agentSetting: string
+  msg: string
+  history: Array<{
+    role: string
+    content: string
+  }>
+}
+
+export interface IGenerateBot {
+  simple: boolean
+  prompt: string
+}
+
+export interface IBotPreview {
+  name: string
+  introduction: string
+  agentSetting: string
+  msg: string
+  history: Array<{
+    role: string
+    content: string
+  }>
+  knowledgeBase: Array<string>
+}
+
+export interface IGenerateImage {
+  prompt: string
+}
+
+export interface IBotSendMessage {
+  botId: string
+  msg: string
+  history: Array<{
+    role: string
+    content: string
+  }>
+}
+
+export interface IBotUploadFiles {
+  botId: string
+  fileList: Array<{
+    fileName: string
+    fileId: string
+    type: string
+  }>
+}
+
+export interface IBotCreateConversation {
+  botId: string
+  title?: string
+}
+
+export interface IBotGetConversation {
+  botId: string
+  pageSize?: number
+  pageNumber?: number
+  isDefault?: boolean
+}
+
+export interface IBotDeleteConversation {
+  botId: string
+  conversationId: string
+}
+
+export interface IBotSpeechToText {
+  botId: string
+  engSerViceType: string
+  voiceFormat: string
+  url: string
+  isPreview?: boolean
+}
+
+export interface IBotTextToSpeech {
+  botId: string
+  voiceType: number
+  text: string
+  isPreview?: boolean
+}
+
+export interface IBotGetTextToSpeechResult {
+  botId: string
+  taskId: string
+  isPreview?: boolean
+}
+
+export interface IUserFeedback {
+  recordId: string
+  type: string
+  botId: string
+  comment: string
+  rating: number
+  tags: Array<string>
+  input: string
+  aiAnswer: string
+}
+
+export interface BotInfo {
+  botId: string
+  name: string
+  introduction: string
+  agentSetting: string
+  welcomeMessage: string
+  avatar: string
+  background: string
+  tags: Array<string>
+  isNeedRecommend: boolean
+  knowledgeBase: Array<string>
+  type: string
+  initQuestions: Array<string>
+  enable: true
+}

package/src/errors.ts

@@ -0,0 +1,23 @@
+/**
+ * 参数校验错误类
+ * 用于统一参数校验错误的格式
+ */
+export class InvalidParamsError extends Error {
+  public code: string
+  public field?: string
+
+  constructor(message: string, field?: string) {
+    super(message)
+    this.name = 'InvalidParamsError'
+    this.code = 'INVALID_PARAMS'
+    this.field = field
+  }
+
+  toJSON() {
+    return {
+      code: this.code,
+      message: this.message,
+      field: this.field,
+    }
+  }
+}

package/src/eventsource_parser/index.ts

@@ -0,0 +1,2 @@
+export type { EventSourceParser, ParsedEvent, ReconnectInterval, ParseEvent, EventSourceParseCallback } from './types'
+export { createParser } from './parse'