@cloudbase/ai 3.3.14-beta.1 → 3.6.4-alpha.1

package/src/type.ts

@@ -1,349 +0,0 @@
-export abstract class SimpleChatModel {
-  public abstract doGenerate(data: BaseChatModelInput, options?: ReqOptions): Promise<DoGenerateOutput>
-
-  public abstract doStream(data: BaseChatModelInput, options?: ReqOptions): Promise<DoStreamOutput>
-}
-
-type RawResponse = { rawResponse?: any }
-
-export type DoGenerateOutput = BaseDoGenerateOutput & RawResponse
-
-export type DoStreamOutput = AsyncIterableReadableStream<BaseDoStreamOutputChunk & RawResponse>
-
-export type ChatModelConstructor = typeof SimpleChatModel
-
-export type AsyncIterableReadableStream<T> = ReadableStream<T> & {
-  [Symbol.asyncIterator]: () => { next(): Promise<IteratorResult<T>> }
-}
-
-export interface IModelReqInput {
-  url: string
-  headers?: Record<string, string>
-  data?: Object
-  stream?: boolean
-  timeout?: number
-}
-
-export type ModelReq = <T extends IModelReqInput>(
-  props: T,
-) => T['stream'] extends true ? Promise<ReadableStream<Uint8Array>> : Promise<Object>
-
-export interface IBotReqInput {
-  url: string
-  method: string
-  headers?: Record<string, string>
-  data?: Object
-  stream?: boolean
-  timeout?: number
-}
-
-export interface ReqOptions {
-  timeout?: number
-}
-
-export type BotReq = <T extends IBotReqInput>(
-  props: T,
-) => T['stream'] extends true ? Promise<ReadableStream<Uint8Array>> : Promise<Object>
-
-export type UserMessage = {
-  role: 'user'
-  content: string
-}
-
-export type SystemMessage = {
-  role: 'system'
-  content: string
-}
-
-export type AssistantMessage = PlainAssistantMessage | ToolCallAssistantMessage
-
-export type PlainAssistantMessage = {
-  role: 'assistant'
-  content: string
-}
-
-export type ToolCallAssistantMessage = {
-  role: 'assistant'
-  tool_calls: Array<ToolCall>
-  content?: string
-}
-
-export type ToolMessage = {
-  role: 'tool'
-  tool_call_id: string
-  content: string
-}
-
-export type ChatModelMessage = UserMessage | SystemMessage | AssistantMessage | ToolMessage
-
-export type FunctionTool = {
-  name: string
-  description: string
-  fn: CallableFunction
-  parameters: object
-}
-
-// #region 大模型标准输入类型
-export interface BaseChatModelInput {
-  model: string
-  messages: Array<ChatModelMessage>
-  temperature?: number
-  top_p?: number
-  tools?: Array<ModelTool>
-  tool_choice?: 'none' | 'auto' | 'custom'
-}
-
-/**
- * 给 LLM 发请求时要传的工具
- */
-export type ModelTool = {
-  type: string
-  function: ModelToolFunction
-}
-
-/**
- * 给 LLM 发请求时要传的工具函数
- */
-export type ModelToolFunction = {
-  name: string
-  description: string
-  /**
-   * 描述函数参数的 JSON Schema
-   */
-  parameters: object
-}
-// #endregion
-
-// #region 大模型标准响应类型
-export type ToolCall = {
-  id: string
-  type: string
-  function: { name: string; arguments: string }
-}
-
-type FinishReason = 'tool_calls' | (string & {})
-
-export type Usage = {
-  completion_tokens: number
-  prompt_tokens: number
-  total_tokens: number
-}
-
-export interface BaseDoGenerateOutput {
-  choices?: Array<{
-    finish_reason?: FinishReason
-    message?: ChatModelMessage
-  }>
-  usage?: Usage
-}
-
-export interface BaseDoStreamOutputChunk {
-  choices?: Array<{
-    finish_reason?: FinishReason
-    delta?: ChatModelMessage
-  }>
-  usage?: Usage
-}
-// #endregion
-
-// #region Image Model Types
-/**
- * 图片生成输入参数
- */
-export interface ImageGenerateInput {
-  model: string // 模型名称，例如 'hunyuan-image'、'dall-e-3'
-  prompt: string // 用于描述要生成的图片内容
-  size?: string // 尺寸
-  n?: number // 张数
-  [key: string]: unknown // 允许额外的厂商特定参数
-}
-
-/**
- * 图片编辑输入参数
- */
-export interface ImageEditInput {
-  model: string
-  prompt: string
-  size?: string // 尺寸
-  n?: number // 张数
-  [key: string]: unknown // 允许额外的厂商特定参数
-}
-
-export interface HunyuanGenerateImageInput {
-  model: 'hunyuan-image'
-  /** 用来生成图像的文本描述 */
-  prompt: string
-  /**
-   * 模型版本，支持 v1.8.1 和 v1.9，默认版本 v1.8.1
-   * - v1.8.1: 采用二阶段模型支持文生图任务，针对图像细节、稳定性等要求高的任务较为合适
-   * - v1.9: 采用模型矩阵能力支持文生图任务，后端由人像、游戏、通用模型，以及各类功能插件组成，灵活适配多种文生图任务
-   */
-  version?: 'v1.8.1' | 'v1.9' | (string & {})
-  /**
-   * 图片尺寸，默认 "1024x1024"
-   * v1.9 仅支持以下几个尺寸：
-   * - 1024x1024
-   * - 1024x768, 1152x864
-   * - 768x1024, 864x1152
-   * - 1280x768 (16:9)
-   * - 768x1280 (9:16)
-   * - 1280x720 (16:9)
-   * - 720x1280 (9:16)
-   *
-   * 支持用户自定义尺寸，但输入尺寸只支持 768-1280 之间且为 64 的倍数的数字
-   */
-  size?: string
-  /**
-   * 仅 v1.9 支持，负向词
-   * 如果不传则使用各个模型内部的默认负向词
-   */
-  negative_prompt?: string
-  /**
-   * 仅 v1.9 支持，可指定风格：
-   * - 古风二次元风格
-   * - 都市二次元风格
-   * - 悬疑风格
-   * - 校园风格
-   * - 都市异能风格
-   */
-  style?: '古风二次元风格' | '都市二次元风格' | '悬疑风格' | '校园风格' | '都市异能风格' | (string & {})
-  /**
-   * 为 true 时对 prompt 进行改写，实际生成的图片会使用改写后的 prompt 进行生成
-   * 多数场景可提升生成的图片效果，默认为 true
-   */
-  revise?: boolean
-  /**
-   * 生成图片个数，默认为 1
-   * 目前只支持生成一张，固定为 1，传其他的值会报错
-   */
-  n?: number
-  /**
-   * 业务自定义水印内容
-   * 限制 16 个字符长度（不区分中英文），生成在图片右下角
-   */
-  footnote?: string
-  /**
-   * 生成种子，仅当生成图片数为 1 时生效
-   * 范围 [1, 4294967295]，不传时默认随机
-   */
-  seed?: number
-}
-
-export interface HunyuanARGenerateImageInput {
-  /** 模型名称：hunyuan-image-v3.0-v1.0.4（推荐）或 hunyuan-image-v3.0-v1.0.1 */
-  model: 'hunyuan-image-v3.0-v1.0.4' | 'hunyuan-image-v3.0-v1.0.1'
-  /** 生成图片使用的文本，不超过 8192 字符 */
-  prompt: string
-  /**
-   * 图片尺寸，格式 "${宽}x${高}"，默认 "1024x1024"
-   * hunyuan-image-v3.0-v1.0.4：宽高 [512, 2048]，面积不超过 1024x1024
-   * hunyuan-image-v3.0-v1.0.1：支持固定尺寸列表
-   */
-  size?: string
-  /** 生成种子，仅当生成图片数为 1 时生效，范围 [1, 4294967295] */
-  seed?: number
-  /** 业务自定义水印内容，限制 16 字符，生成在图片右下角 */
-  footnote?: string
-  /** 是否对 prompt 改写，默认开启。改写会增加约 30s 耗时 */
-  revise?: { value: boolean }
-  /** 改写是否开启 thinking 模式，默认开启。开启后效果提升但耗时增加（最大 60s） */
-  enable_thinking?: { value: boolean }
-}
-
-export interface HunyuanARGenerateImageOutput {
-  /** 此次请求的 id */
-  id: string
-  /** unix 时间戳 */
-  created: number
-  /** 返回的图片生成内容 */
-  data: Array<{
-    /** 生成的图片 url，有效期 24 小时 */
-    url: string
-    /** 改写后的 prompt */
-    revised_prompt?: string
-  }>
-}
-
-export type HunyuanEditImageInput = {
-  /** 模型名称，本期为 hunyuan-image，即为商品图编辑场景 */
-  model: 'hunyuan-image' | (string & {})
-  /** 编辑的文本描述 */
-  prompt: string
-  /** 模型版本 */
-  version?: string
-  /**
-   * 图片尺寸，默认 "800x800"
-   * 支持用户自定义尺寸，但输入尺寸只支持 512-1280 之间
-   * 目前只支持 1:1、16:9、9:16 三个尺寸
-   */
-  size?: string
-  /**
-   * 生成图片个数，默认为 1
-   * 目前只支持生成一张，固定为 1，传其他的值会报错
-   */
-  n?: number
-  /**
-   * beta 参数，随机种子
-   * 范围 [1, 4294967295]，不传时默认随机
-   */
-  seed?: number
-  /**
-   * 业务自定义角标内容
-   * 限制 16 个字符长度（不区分中英文）
-   */
-  footnote?: string
-  /**
-   * 图 base64 编码，大小不超过 6M
-   * 支持 jpg/jpeg 格式，和 image_url 二选一
-   * 长短边比例要求 2:1 内
-   */
-  image?: string
-  /**
-   * 图片 url
-   * 长短边比例要求 2:1 内，和 image 二选一
-   */
-  image_url?: string
-} & (
-  | {
-    mask: string
-    mask_url?: never
-  }
-  | {
-    mask?: never
-    mask_url: string
-  }
-)
-
-/**
- * 混元图片生成输出
- */
-export interface HunyuanGenerateImageOutput {
-  /** 此次请求的 id */
-  id: string
-  /** unix 时间戳 */
-  created: number
-  /** 返回的图片生成内容 */
-  data: Array<{
-    /** 生成的图片 url，有效期为 24 小时 */
-    url: string
-    /** 原 prompt 改写后的文本。若 revise 为 false，则为原 prompt */
-    revised_prompt?: string
-  }>
-}
-
-/**
- * 混元图片编辑输出
- */
-export interface HunyuanEditImageOutput {
-  /** 此次请求的 id */
-  id: string
-  /** unix 时间戳 */
-  created: number
-  /** 返回的图片生成内容 */
-  data: Array<{
-    /** 生成的图片 url，有效期为 24 小时 */
-    url: string
-  }>
-}
-
-// #endregion

package/src/utils.ts

@@ -1,183 +0,0 @@
-import { TransformStream as _TransformStream, ReadableStream as _ReadableStream } from 'web-streams-polyfill'
-import { createReadableStreamWrapper } from '@mattiasbuelens/web-streams-adapter'
-import { createParser, type EventSourceParser, type ParsedEvent } from './eventsource_parser'
-import type {
-  AsyncIterableReadableStream,
-  ChatModelMessage,
-  ToolCallAssistantMessage,
-  ModelTool,
-  FunctionTool,
-} from './type'
-import { TextDecoder } from 'text-encoding-shim'
-
-export const ReadableStream = _ReadableStream as {
-  prototype: ReadableStream
-
-  new (
-    underlyingSource: UnderlyingByteSource,
-    strategy?: {
-      highWaterMark?: number
-    },
-  ): ReadableStream<Uint8Array>
-  new <R = any>(underlyingSource: UnderlyingDefaultSource<R>, strategy?: QueuingStrategy<R>): ReadableStream<R>
-  new <R = any>(underlyingSource?: UnderlyingSource<R>, strategy?: QueuingStrategy<R>): ReadableStream<R>
-}
-
-export const TransformStream = _TransformStream as {
-  prototype: TransformStream
-
-  new <I = any, O = any>(
-    transformer?: Transformer<I, O>,
-    writableStrategy?: QueuingStrategy<I>,
-    readableStrategy?: QueuingStrategy<O>,
-  ): TransformStream<I, O>
-}
-
-export const createEventSourceParserTransformStream = () => {
-  let parser!: EventSourceParser
-
-  return new TransformStream<string, ParsedEvent>({
-    start(controller) {
-      parser = createParser((event) => {
-        if (event.type === 'event') {
-          controller.enqueue(event)
-        }
-      })
-    },
-    transform(chunk) {
-      parser.feed(chunk)
-    },
-  })
-}
-
-export const toPolyfillReadable = createReadableStreamWrapper(ReadableStream)
-
-export class TextDecoderStream {
-  private handle: TextDecoder
-
-  private transform = new TransformStream({
-    transform: (chunk, controller) => {
-      const value = this.handle.decode(new Uint8Array(chunk), { stream: true })
-
-      if (value) {
-        controller.enqueue(value)
-      }
-    },
-    flush: (controller) => {
-      const value = this.handle.decode()
-      if (value) {
-        controller.enqueue(value)
-      }
-
-      controller.terminate()
-    },
-  })
-
-  constructor(encoding = 'utf-8', options: TextDecoderOptions = {}) {
-    this.handle = new TextDecoder(encoding, options)
-  }
-
-  get encoding() {
-    return this.handle.encoding
-  }
-
-  get fatal() {
-    return this.handle.fatal
-  }
-
-  get ignoreBOM() {
-    return this.handle.ignoreBOM
-  }
-
-  get readable() {
-    return this.transform.readable
-  }
-
-  get writable() {
-    return this.transform.writable
-  }
-
-  get [Symbol.toStringTag]() {
-    return 'TextDecoderStream'
-  }
-}
-
-export function createAsyncIterable<T>(stream: ReadableStream<T>) {
-  // eslint-disable-next-line @typescript-eslint/naming-convention
-  const _stream = stream as AsyncIterableReadableStream<T>
-  (_stream as any)[Symbol.asyncIterator] = () => {
-    const reader = stream.getReader()
-    return {
-      async next(): Promise<IteratorResult<T>> {
-        const { done, value } = await reader.read()
-        return done ? { done: true, value: undefined } : { done: false, value }
-      },
-    }
-  }
-  return _stream
-}
-
-/**
- * 将 SSE 二进制流转换为 T 类型的流
- */
-export function intoStandardStream<T>(stream: ReadableStream<Uint8Array>): ReadableStream<T> {
-  return createAsyncIterable(stream
-    .pipeThrough(new TextDecoderStream())
-    .pipeThrough(createEventSourceParserTransformStream())
-    .pipeThrough(new TransformStream<ParsedEvent, T>({
-      transform(chunk, controller) {
-        try {
-          const data = JSON.parse(chunk.data) as T
-          controller.enqueue(data)
-        } catch (e) {
-          if (chunk.data !== '[DONE]') {
-            console.warn('Error when transforming event source data to json', e, chunk)
-          } else {
-            controller.terminate()
-          }
-        }
-      },
-    }),),)
-}
-
-/**
- * 将 SSE 二进制流转换为字符串流
- */
-export function intoTextStream(stream: ReadableStream<Uint8Array>): AsyncIterableReadableStream<string> {
-  return createAsyncIterable((toPolyfillReadable(stream) as typeof stream).pipeThrough(new TextDecoderStream()))
-}
-
-export async function readableStream2JsonObject(stream: ReadableStream) {
-  const s = intoTextStream(stream)
-  let total = ''
-  for await (const chunk of s) {
-    total += chunk
-  }
-  return JSON.parse(total)
-}
-
-export function createPromise<T = unknown>() {
-  let res: (value: T | PromiseLike<T>) => void
-  let rej: (reason?: any) => void
-  const promise = new Promise<T>((resolve, reject) => {
-    res = resolve
-    rej = reject
-  })
-  return { promise, res, rej }
-}
-
-export function isToolCallAssistantMessage(message: ChatModelMessage): message is ToolCallAssistantMessage {
-  // eslint-disable-next-line eqeqeq
-  return message.role === 'assistant' && 'tool_calls' in message && message.tool_calls?.[0] != null
-}
-
-export function functionToolToModelTool(tool: FunctionTool): ModelTool {
-  return {
-    type: 'function',
-    function: {
-      description: tool.description,
-      name: tool.name,
-      parameters: tool.parameters,
-    },
-  }
-}

package/tsconfig.esm.json

@@ -1,16 +0,0 @@
-{
-  "extends": "../../tsconfig.base.json",
-  "compilerOptions": {
-    "module": "es6",
-    "outDir": "dist/esm",
-    "rootDir": "src",
-  },
-  "include": [
-    "src/**/*.ts",
-    "package.json"
-  ],
-  "exclude": [
-    "node_modules",
-    "dist"
-  ]
-}

package/tsconfig.json

@@ -1,16 +0,0 @@
-{
-  "extends": "../../tsconfig.base.json",
-  "compilerOptions": {
-    "module": "node16",
-    "outDir": "dist/cjs",
-    "rootDir": "src",
-  },
-  "include": [
-    "src/**/*",
-    "package.json"
-  ],
-  "exclude": [
-    "node_modules",
-    "dist"
-  ]
-}

package/webpack/web.prod.js

@@ -1,100 +0,0 @@
-const path = require('path')
-const webpack = require('webpack')
-const TerserPlugin = require('terser-webpack-plugin')
-// const BundleAnalyzerPlugin = require('webpack-bundle-analyzer').BundleAnalyzerPlugin
-module.exports = function (options) {
-  const { context, entry, output, mode, watch, externals, definePlugin = {}, optimization = {} } = options
-  const isDevelopment = mode !== 'production'
-  let plugins = [
-    new webpack.DefinePlugin(definePlugin),
-    // new BundleAnalyzerPlugin()
-  ].filter((item) => !!item)
-
-  const BABEL_LOADER = {
-    loader: 'babel-loader',
-    options: {
-      presets: [
-        [
-          '@babel/preset-env',
-          {
-            modules: false,
-            targets: {
-              esmodules: true,
-            },
-          },
-        ],
-      ],
-    },
-  }
-
-  return {
-    context,
-    entry,
-    mode,
-    watch,
-    watchOptions: {
-      ignored: [output.path],
-    },
-    output,
-    externals,
-    cache: {
-      type: 'memory',
-    },
-    devtool: false,
-    resolve: {
-      extensions: ['.ts', '.js', '.json'],
-    },
-    module: {
-      rules: [
-        {
-          test: /\.ts$/,
-          exclude: [/node_modules/],
-          use: [
-            BABEL_LOADER,
-            {
-              loader: require.resolve('ts-loader'),
-              options: {
-                configFile: path.resolve(context, './tsconfig.esm.json'),
-              },
-            },
-          ],
-        },
-        {
-          test: /\.js$/,
-          exclude: [/node_modules/],
-          use: [BABEL_LOADER],
-        },
-        {
-          test: /package\.json$/,
-          loader: 'package-json-cleanup-loader',
-          options: {
-            only: ['version'],
-          },
-        },
-      ],
-      noParse: [/sjcl\.js$/],
-    },
-    plugins,
-    optimization: {
-      emitOnErrors: false,
-      removeEmptyChunks: true,
-      usedExports: true,
-      ...optimization,
-      ...(isDevelopment
-        ? {
-            minimize: false,
-            removeAvailableModules: false,
-            concatenateModules: true,
-          }
-        : {
-            minimizer: [
-              new TerserPlugin({
-                test: /\.js(\?.*)?$/i,
-                cache: false,
-                parallel: true,
-              }),
-            ],
-          }),
-    },
-  }
-}

package/webpack/webpack.miniprogram.js

@@ -1,24 +0,0 @@
-const path = require('path')
-
-const params = {
-  context: path.resolve(__dirname, '../'),
-  mode: 'production',
-  watch: false,
-  entry: path.resolve(__dirname, '../src/index.ts'),
-  output: {
-    path: path.resolve(__dirname, '../dist/miniprogram'),
-    filename: 'index.js',
-    library: `tcbauth`,
-    libraryTarget: 'umd',
-    umdNamedDefine: true,
-    globalObject: 'typeof window !== "undefined"?window:this',
-  },
-  externals: {
-  },
-  definePlugin: {
-    'process.env.NODE_ENV': JSON.stringify('production'), // 注入环境变量，用于业务代码判断
-    'globalThis.IS_MP_BUILD': true,
-  },
-}
-
-module.exports = require('./web.prod.js')(params)