@cloudbase/ai 3.6.2 → 3.6.4-alpha.1

package/src/errors.ts

@@ -1,23 +0,0 @@
-/**
- * 参数校验错误类
- * 用于统一参数校验错误的格式
- */
-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

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

package/src/eventsource_parser/parse.ts

@@ -1,169 +0,0 @@
-/**
- * EventSource/Server-Sent Events parser
- * @see https://html.spec.whatwg.org/multipage/server-sent-events.html
- *
- * Based on code from the {@link https://github.com/EventSource/eventsource | EventSource module},
- * which is licensed under the MIT license. And copyrighted the EventSource GitHub organisation.
- */
-import type { EventSourceParseCallback, EventSourceParser } from './types'
-
-/**
- * Creates a new EventSource parser.
- *
- * @param onParse - Callback to invoke when a new event is parsed, or a new reconnection interval
- *                  has been sent from the server
- *
- * @returns A new EventSource parser, with `parse` and `reset` methods.
- * @public
- */
-export function createParser(onParse: EventSourceParseCallback): EventSourceParser {
-  // Processing state
-  let isFirstChunk: boolean
-  let buffer: string
-  let startingPosition: number
-  let startingFieldLength: number
-
-  // Event state
-  let eventId: string | undefined
-  let eventName: string | undefined
-  let data: string
-
-  reset()
-  return { feed, reset }
-
-  function reset(): void {
-    isFirstChunk = true
-    buffer = ''
-    startingPosition = 0
-    startingFieldLength = -1
-
-    eventId = undefined
-    eventName = undefined
-    data = ''
-  }
-
-  function feed(chunk: string): void {
-    buffer = buffer ? buffer + chunk : chunk
-
-    // Strip any UTF8 byte order mark (BOM) at the start of the stream.
-    // Note that we do not strip any non - UTF8 BOM, as eventsource streams are
-    // always decoded as UTF8 as per the specification.
-    if (isFirstChunk && hasBom(buffer)) {
-      buffer = buffer.slice(BOM.length)
-    }
-
-    isFirstChunk = false
-
-    // Set up chunk-specific processing state
-    const { length } = buffer
-    let position = 0
-    let discardTrailingNewline = false
-
-    // Read the current buffer byte by byte
-    while (position < length) {
-      // EventSource allows for carriage return + line feed, which means we
-      // need to ignore a linefeed character if the previous character was a
-      // carriage return
-      // @todo refactor to reduce nesting, consider checking previous byte?
-      // @todo but consider multiple chunks etc
-      if (discardTrailingNewline) {
-        if (buffer[position] === '\n') {
-          position += 1
-        }
-        discardTrailingNewline = false
-      }
-
-      let lineLength = -1
-      let fieldLength = startingFieldLength
-      let character: string
-
-      for (let index = startingPosition; lineLength < 0 && index < length; index++) {
-        character = buffer[index]
-        if (character === ':' && fieldLength < 0) {
-          fieldLength = index - position
-        } else if (character === '\r') {
-          discardTrailingNewline = true
-          lineLength = index - position
-        } else if (character === '\n') {
-          lineLength = index - position
-        }
-      }
-
-      if (lineLength < 0) {
-        startingPosition = length - position
-        startingFieldLength = fieldLength
-        break
-      } else {
-        startingPosition = 0
-        startingFieldLength = -1
-      }
-
-      parseEventStreamLine(buffer, position, fieldLength, lineLength)
-
-      position += lineLength + 1
-    }
-
-    if (position === length) {
-      // If we consumed the entire buffer to read the event, reset the buffer
-      buffer = ''
-    } else if (position > 0) {
-      // If there are bytes left to process, set the buffer to the unprocessed
-      // portion of the buffer only
-      buffer = buffer.slice(position)
-    }
-  }
-
-  function parseEventStreamLine(lineBuffer: string, index: number, fieldLength: number, lineLength: number) {
-    if (lineLength === 0) {
-      // We reached the last line of this event
-      if (data.length > 0) {
-        onParse({
-          type: 'event',
-          id: eventId,
-          event: eventName || undefined,
-          data: data.slice(0, -1), // remove trailing newline
-        })
-
-        data = ''
-        eventId = undefined
-      }
-      eventName = undefined
-      return
-    }
-
-    const noValue = fieldLength < 0
-    const field = lineBuffer.slice(index, index + (noValue ? lineLength : fieldLength))
-    let step = 0
-
-    if (noValue) {
-      step = lineLength
-    } else if (lineBuffer[index + fieldLength + 1] === ' ') {
-      step = fieldLength + 2
-    } else {
-      step = fieldLength + 1
-    }
-
-    const position = index + step
-    const valueLength = lineLength - step
-    const value = lineBuffer.slice(position, position + valueLength).toString()
-
-    if (field === 'data') {
-      data += value ? `${value}\n` : '\n'
-    } else if (field === 'event') {
-      eventName = value
-    } else if (field === 'id' && !value.includes('\u0000')) {
-      eventId = value
-    } else if (field === 'retry') {
-      const retry = parseInt(value, 10)
-      if (!Number.isNaN(retry)) {
-        onParse({ type: 'reconnect-interval', value: retry })
-      }
-    }
-  }
-}
-
-const BOM = [239, 187, 191]
-
-function hasBom(buffer: string) {
-  return BOM.every((charCode: number, index: number) => buffer.charCodeAt(index) === charCode)
-}

package/src/eventsource_parser/stream.ts

@@ -1,35 +0,0 @@
-import type { EventSourceParser, ParsedEvent } from './types'
-import { createParser } from './parse'
-
-/**
- * A TransformStream that ingests a stream of strings and produces a stream of ParsedEvents.
- *
- * @example
- * ```
- * const eventStream =
- *   response.body
- *     .pipeThrough(new TextDecoderStream())
- *     .pipeThrough(new EventSourceParserStream())
- * ```
- * @public
- */
-export class EventSourceParserStream extends TransformStream<string, ParsedEvent> {
-  constructor() {
-    let parser!: EventSourceParser
-
-    super({
-      start(controller) {
-        parser = createParser((event) => {
-          if (event.type === 'event') {
-            controller.enqueue(event)
-          }
-        })
-      },
-      transform(chunk) {
-        parser.feed(chunk)
-      },
-    })
-  }
-}
-
-export type { ParsedEvent } from './types'

package/src/eventsource_parser/types.ts

@@ -1,90 +0,0 @@
-/**
- * EventSource parser instance.
- *
- * Needs to be reset between reconnections/when switching data source, using the `reset()` method.
- *
- * @public
- */
-export interface EventSourceParser {
-  /**
-   * Feeds the parser another chunk. The method _does not_ return a parsed message.
-   * Instead, if the chunk was a complete message (or completed a previously incomplete message),
-   * it will invoke the `onParse` callback used to create the parsers.
-   *
-   * @param chunk - The chunk to parse. Can be a partial, eg in the case of streaming messages.
-   * @public
-   */
-  feed(chunk: string): void
-
-  /**
-   * Resets the parser state. This is required when you have a new stream of messages -
-   * for instance in the case of a client being disconnected and reconnecting.
-   *
-   * @public
-   */
-  reset(): void
-}
-
-/**
- * A parsed EventSource event
- *
- * @public
- */
-export interface ParsedEvent {
-  /**
-   * Differentiates the type from reconnection intervals and other types of messages
-   * Not to be confused with `event`.
-   */
-  type: 'event'
-
-  /**
-   * The event type sent from the server. Note that this differs from the browser `EventSource`
-   * implementation in that browsers will default this to `message`, whereas this parser will
-   * leave this as `undefined` if not explicitly declared.
-   */
-  event?: string
-
-  /**
-   * ID of the message, if any was provided by the server. Can be used by clients to keep the
-   * last received message ID in sync when reconnecting.
-   */
-  id?: string
-
-  /**
-   * The data received for this message
-   */
-  data: string
-}
-
-/**
- * An event emitted from the parser when the server sends a value in the `retry` field,
- * indicating how many seconds the client should wait before attempting to reconnect.
- *
- * @public
- */
-export interface ReconnectInterval {
-  /**
-   * Differentiates the type from `event` and other types of messages
-   */
-  type: 'reconnect-interval'
-
-  /**
-   * Number of seconds to wait before reconnecting. Note that the parser does not care about
-   * this value at all - it only emits the value for clients to use.
-   */
-  value: number
-}
-
-/**
- * The different types of messages the parsed can emit to the `onParse` callback
- *
- * @public
- */
-export type ParseEvent = ParsedEvent | ReconnectInterval
-
-/**
- * Callback passed as the `onParse` callback to a parser
- *
- * @public
- */
-export type EventSourceParseCallback = (event: ParseEvent) => void

package/src/index.ts

@@ -1,165 +0,0 @@
-/* eslint-disable eqeqeq */
-import type { IFetchOptions, SDKRequestInterface } from '@cloudbase/adapter-interface'
-import type { ICloudbase, ICloudbaseConfig } from '@cloudbase/types'
-import type { ICloudbaseComponent } from '@cloudbase/types/component'
-import { AI } from './AI'
-import { Bot } from './bot'
-import * as models from './models'
-import * as utils from './utils'
-
-const COMPONENT_NAME = 'ai'
-
-const { MODELS, ...restModels } = models
-
-interface IHandleRequestInstance {
-  req: SDKRequestInterface
-}
-
-type HandleRequestInstanceFunc = (options: IHandleRequestInstance) => SDKRequestInterface
-
-const createRequestInstanceWithAccessTokenHeader = ({
-  getAccessToken,
-  req,
-}: IHandleRequestInstance & { getAccessToken: () => Promise<{ accessToken: string }> }) => {
-  const fetch: typeof req.fetch = async (options: IFetchOptions & { token?: string }) => {
-    if (typeof req.fetch !== 'function') {
-      throw new Error('req.fetch is not a function')
-    }
-
-    const { token, headers = {}, ...restOptions } = options
-    let accessToken: string
-    if (token != null) {
-      accessToken = token
-    } else {
-      accessToken = (await getAccessToken()).accessToken
-    }
-
-    return req.fetch({
-      headers: {
-        Authorization: `Bearer ${accessToken}`,
-        ...headers,
-      },
-      ...restOptions,
-    })
-  }
-
-  return {
-    download: req.download,
-    post: req.post,
-    upload: req.upload,
-    fetch,
-  }
-}
-
-interface AIInitOption {
-  baseUrl?: string
-}
-
-interface ICreateAI {
-  req: SDKRequestInterface
-  baseUrl?: string
-  /** 动态获取 baseUrl 的函数，若提供则优先使用，支持端点变更后请求自动跟随 */
-  getBaseUrl?: () => string
-  env?: string
-  getAccessToken?: () => Promise<{ accessToken: string }>
-  handleReqInstance?: HandleRequestInstanceFunc
-  i18n?: ICloudbaseConfig['i18n']
-}
-
-/**
- * 最简地创建一个接云开发网关服务的 `AI` 实例，请求时会自动带上鉴权请求头。
- * 只需要传入：
- *
- * - `getAccessToken`: 获取 accessToken 的函数
- * - `req`: 请求函数，一般从 adapter 上拿
- * - `env`: 云开发环境 ID
- *
- * 其他参数可按需传入覆盖函数逻辑。
- */
-function createAI({ env, baseUrl, getBaseUrl: getBaseUrlFunc, req, getAccessToken, handleReqInstance, i18n }: ICreateAI) {
-  const getBaseUrl = () => {
-    if (getBaseUrlFunc != null) {
-      return getBaseUrlFunc()
-    }
-    if (baseUrl != null) {
-      return baseUrl
-    }
-    if (env == null) {
-      throw new Error('`env` is required when `baseUrl` is not provided!')
-    }
-    return `https://${env}.api.tcloudbasegateway.com/v1`
-  }
-
-  const getReq = () => {
-    if (handleReqInstance == null) {
-      if (getAccessToken == null) {
-        throw new Error('`getAccessToken` is required when `handleReqInstance` is not provided!')
-      }
-      return createRequestInstanceWithAccessTokenHeader({ req, getAccessToken })
-    }
-    return handleReqInstance({ req })
-  }
-
-  return new AI(getReq(), getBaseUrl(), i18n, getBaseUrlFunc)
-}
-
-// 兼容
-/**
- * @deprecated use `createAI`
- */
-const createAi = createAI
-
-/**
- * 创建 `AI` 实例。
- * 该函数挂载在 js sdk 的 Cloudbase 实例上。
- * 该函数调用了本模块暴露的 `createAI` 函数，但调用时通过传入参数做了逻辑覆盖：
- *
- * - 传入从 Cloudbase 实例上的中心的 `req`
- * - 传入从 Cloudbase 实例上拿到的 `baseUrl`
- * - 传入一个不处理 `req` 的 `handleReqInstance`，由于 `req` 是从 Cloudbase 实例上拿到的，这个中心的 `req` 已经可用了
- * - 不用传入 `env` 了，因为已经传了 `baseUrl`
- * - 不用传入 `getAccessToken` 了，因为传了 `handleReqInstance`
- */
-function ai(
-  this: ICloudbase & { getEndPointWithKey: (key: 'GATEWAY') => { BASE_URL: string; PROTOCOL: string } },
-  options?: AIInitOption,
-) {
-  const req = this.request
-
-  if (req.fetch == null) {
-    throw new Error('cloudbase.request.fetch() unimplemented!')
-  }
-
-  const getUrlFromCloud = () => {
-    const { BASE_URL, PROTOCOL } = this.getEndPointWithKey('GATEWAY')
-    return `${PROTOCOL}${BASE_URL}`
-  }
-
-  // 若用户传了静态 baseUrl 则使用静态值，否则传入动态获取函数支持端点变更后生效
-  if (options?.baseUrl) {
-    return createAI({ req, baseUrl: options.baseUrl, handleReqInstance: ({ req }) => req, i18n: this.config.i18n })
-  }
-
-  return createAI({ req, baseUrl: getUrlFromCloud(), getBaseUrl: getUrlFromCloud, handleReqInstance: ({ req }) => req, i18n: this.config.i18n })
-}
-
-const component: ICloudbaseComponent = {
-  name: COMPONENT_NAME,
-  entity: { ai },
-}
-
-function registerAi(app: ICloudbase) {
-  try {
-    app.registerComponent(component)
-  } catch (e) {
-    console.warn(e)
-  }
-}
-
-export { AI, Bot, createAi, createAI, restModels as models, registerAi, utils }
-export * from './type'
-export * from './errors'
-
-try {
-  (window as any).registerAi = registerAi
-} catch (e) {}

package/src/models/Ark/index.ts

@@ -1,94 +0,0 @@
-/* eslint-disable eqeqeq */
-/* eslint-disable @typescript-eslint/naming-convention */
-import {
-  createAsyncIterable,
-  TransformStream,
-  toPolyfillReadable,
-  intoStandardStream,
-  isToolCallAssistantMessage,
-} from '../../utils'
-import type { ArkGenerateTextOutput, ArkInputData, ArkStreamTextOutput } from './type'
-import type {
-  ModelReq,
-  BaseChatModelInput,
-  SimpleChatModel,
-  DoGenerateOutput,
-  DoStreamOutput,
-  BaseDoStreamOutputChunk,
-  ReqOptions,
-} from '../../type'
-
-function processInput(input: BaseChatModelInput): ArkInputData {
-  const { messages, model, temperature, tools, top_p } = input
-
-  return {
-    ...input,
-    messages,
-    model,
-    tools,
-    top_p,
-    temperature,
-  }
-}
-
-export class ArkSimpleModel implements SimpleChatModel {
-  public subUrl = 'ark/api/v3/chat/completions'
-  constructor(private req: ModelReq, public baseUrl: string, subUrl?: string) {
-    if (subUrl != null) {
-      this.subUrl = subUrl
-    }
-  }
-
-  private get url() {
-    return `${this.baseUrl}/${this.subUrl}`
-  }
-
-  public async doGenerate(data: BaseChatModelInput, options?: ReqOptions): Promise<DoGenerateOutput> {
-    const res = (await this.req({
-      url: this.url,
-      data: {
-        ...processInput(data),
-        stream: false,
-      },
-      stream: false,
-      timeout: options?.timeout,
-    })) as ArkGenerateTextOutput
-    return { ...res, rawResponse: res }
-  }
-
-  public async doStream(data: BaseChatModelInput, options?: ReqOptions): Promise<DoStreamOutput> {
-    let isToolCall: null | boolean = null
-    const _stream = await this.req({
-      url: this.url,
-      data: {
-        ...processInput(data),
-        stream: true,
-      },
-      stream: true,
-      timeout: options?.timeout,
-    })
-    const stream = toPolyfillReadable(_stream) as typeof _stream
-
-    const arkStream = intoStandardStream<ArkStreamTextOutput>(stream)
-    const streamWithRaw = arkStream.pipeThrough(new TransformStream<ArkStreamTextOutput, BaseDoStreamOutputChunk & { rawResponse?: any }>({
-      transform(chunk, controller) {
-        const newChoices = chunk.choices.map((choice) => {
-          const message = choice.delta
-          if (isToolCall == null) isToolCall = isToolCallAssistantMessage(message)
-          if (isToolCall) {
-            return {
-              ...choice,
-              finish_reason: 'tool_calls' as const,
-              delta: message,
-            }
-          }
-          return choice
-        })
-        const newChunk = { ...chunk, choices: newChoices }
-        controller.enqueue({ ...newChunk, rawResponse: chunk })
-      },
-    }),)
-
-    return createAsyncIterable(streamWithRaw)
-  }
-}

package/src/models/Ark/type.ts

@@ -1,82 +0,0 @@
-type UserMessage = {
-  role: 'user'
-  content: string
-}
-
-type SystemMessage = {
-  role: 'system'
-  content: string
-}
-
-type ToolMessage = {
-  role: 'tool'
-  content: string
-  tool_call_id: string
-}
-
-type AssistantMessage =
-  | {
-    role: 'assistant'
-    content: string
-  }
-  | {
-    role: 'assistant'
-    tool_calls: Array<ToolCall>
-    content?: string
-  }
-
-type ToolCall = {
-  id: string
-  type: string
-  function: {
-    name: string
-    arguments: string
-  }
-}
-
-type ArkMessage = UserMessage | SystemMessage | AssistantMessage | ToolMessage
-
-export type ArkInputData = {
-  model: string
-  messages: Array<ArkMessage>
-  max_tokens?: number
-  stop?: string | Array<string>
-  frequency_penalty?: number
-  temperature?: number
-  top_p?: number
-  tools?: Array<Tool>
-}
-
-type Tool = {
-  type: string
-  function: {
-    name: string
-    description?: string
-    parameters?: object
-  }
-}
-
-export type ArkGenerateTextOutput = {
-  choices?: Array<{
-    finish_reason: string
-    message?: AssistantMessage
-  }>
-  usage?: {
-    prompt_tokens: number
-    completion_tokens: number
-    total_tokens: number
-  }
-}
-
-// todo: more precise
-export type ArkStreamTextOutput = {
-  choices?: Array<{
-    finish_reason: string
-    delta: AssistantMessage
-  }>
-  usage?: {
-    prompt_tokens: number
-    completion_tokens: number
-    total_tokens: number
-  }
-}