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

package/src/type.ts

@@ -0,0 +1,362 @@
+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:
+  | 'HY-Image-3.0-Plus-4090-Tob-v1.0'
+  | 'HY-Image-v3.0-I2I-ToB-v1.0.1'
+  | 'hunyuan-image-v3.0-v1.0.4'
+  | 'hunyuan-image-v3.0-v1.0.1'
+  | 'hunyuan-image-v3.0-v1.0.5'
+  /** 生成图片使用的文本，不超过 8192 字符 */
+  prompt: string
+  /**
+   * 图片尺寸，格式 "${宽}x${高}"，默认 "1024x1024"
+   * HY-Image-3.0-Plus-4090-Tob-v1.0 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 }
+  /**
+   * 垫图url列表，与image二选一，优先选image，大小不超过10MB，支持 jpg jpeg png 格式，最多3张图，image_urls和images必有一个非空
+   */
+  image_urls?: string[]
+  /**
+   * 垫图base64列表，与image_url二选一，优先选image，大小不超过10MB，支持 jpg jpeg png 格式，最多3张图
+   */
+  images?: string[]
+}
+
+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

@@ -0,0 +1,198 @@
+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'
+
+/**
+ * 检测当前环境是否原生支持完整的 Web Streams API（Node.js >= 18 或现代浏览器）
+ * 如果原生支持，则无需使用 polyfill，避免 web-streams-adapter 在高版本 Node.js 中的兼容问题
+ */
+const hasNativeStreams = typeof globalThis.ReadableStream === 'function'
+  && typeof globalThis.TransformStream === 'function'
+  && typeof globalThis.ReadableStream.prototype.pipeThrough === 'function'
+
+export const ReadableStream = (hasNativeStreams ? globalThis.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 = (hasNativeStreams ? globalThis.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)
+    },
+  })
+}
+
+/**
+ * 将任意 ReadableStream 转换为当前环境使用的 ReadableStream 实现
+ * - 在原生支持 Web Streams 的环境（Node.js >= 18、现代浏览器）中，直接返回原始 stream（无需转换）
+ * - 在不支持原生 Web Streams 的环境（旧浏览器、小程序）中，使用 web-streams-adapter 进行转换
+ */
+export const toPolyfillReadable: (readable: any) => any = hasNativeStreams
+  ? readable => readable
+  : 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

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

package/tsconfig.json

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

package/webpack/web.prod.js

@@ -0,0 +1,100 @@
+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

@@ -0,0 +1,24 @@
+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)