@cloudbase/ai 3.6.2 → 3.6.4-alpha.1

package/src/models/DashScope/index.ts

@@ -1,97 +0,0 @@
-/* eslint-disable eqeqeq */
-/* eslint-disable @typescript-eslint/naming-convention */
-import {
-  createAsyncIterable,
-  TransformStream,
-  intoStandardStream,
-  isToolCallAssistantMessage,
-  toPolyfillReadable,
-} from '../../utils'
-import type { DSInput, DSGenerateOutput, DSStreamOutput } from './type'
-import type {
-  ModelReq,
-  BaseChatModelInput,
-  DoGenerateOutput,
-  DoStreamOutput,
-  BaseDoStreamOutputChunk,
-  SimpleChatModel,
-  ReqOptions,
-} from '../../type'
-
-function processInput(input: BaseChatModelInput): DSInput {
-  const { messages, model, temperature, tools, top_p } = input
-
-  return {
-    ...input,
-    messages,
-    model,
-    tools,
-    top_p,
-    temperature,
-  }
-}
-
-export class DSSimpleModel implements SimpleChatModel {
-  public subUrl = 'dashscope/compatible-mode/v1/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 DSGenerateOutput
-    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<DSStreamOutput>(stream)
-    const streamWithRaw = arkStream.pipeThrough(new TransformStream<DSStreamOutput, BaseDoStreamOutputChunk & { rawResponse?: any }>({
-      transform(chunk, controller) {
-        const newChoices = chunk.choices.map((choice) => {
-          const message = Object.assign(choice.delta, { role: 'assistant' }) as typeof choice.delta & {
-            role: 'assistant'
-          }
-          if (isToolCall == null) isToolCall = isToolCallAssistantMessage(message)
-          if (isToolCall) {
-            return {
-              ...choice,
-              finish_reason: 'tool_calls' as const,
-              delta: message,
-            }
-          }
-          return { ...choice, delta: message }
-        })
-        const newChunk = { ...chunk, choices: newChoices }
-        controller.enqueue({ ...newChunk, rawResponse: chunk })
-      },
-    }),)
-
-    return createAsyncIterable(streamWithRaw)
-  }
-}

package/src/models/DashScope/type.ts

@@ -1,76 +0,0 @@
-export type DSInput = {
-  model: string
-  messages: Array<Message>
-  temperature?: number
-  top_p?: number
-  tools?: Array<{
-    type: string
-    function: { name: string; description: string; parameters: object }
-  }>
-}
-
-type Message = SystemMessage | UserMessage | AssistantMessage | ToolMessage
-
-type SystemMessage = {
-  content: string
-  role: 'system'
-}
-
-type UserMessage = {
-  content: string
-  role: 'user'
-}
-
-type ToolMessage = {
-  content: string
-  role: 'tool'
-}
-
-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 }
-}
-
-export type DSGenerateOutput = {
-  choices: Array<{
-    finish_reason: string
-    message: {
-      content: string
-      role: 'assistant'
-      tool_calls?: Array<ToolCall>
-    }
-  }>
-  usage: {
-    prompt_tokens: number
-    completion_tokens: number
-    total_tokens: number
-  }
-}
-
-export type DSStreamOutput = {
-  choices: Array<{
-    delta: {
-      content: string
-      tool_calls?: Array<ToolCall>
-      role?: 'assistant'
-    }
-    finish_reason: string
-  }>
-  usage?: {
-    prompt_tokens: number
-    completion_tokens: number
-    total_tokens: number
-  }
-}

package/src/models/DeepSeek/index.ts

@@ -1,80 +0,0 @@
-/* eslint-disable eqeqeq */
-import {
-  createAsyncIterable,
-  TransformStream,
-  toPolyfillReadable,
-  intoStandardStream,
-  isToolCallAssistantMessage,
-} from '../../utils'
-import type {
-  ModelReq,
-  BaseChatModelInput,
-  SimpleChatModel,
-  DoStreamOutput,
-  BaseDoStreamOutputChunk,
-  DoGenerateOutput,
-  ReqOptions,
-} from '../../type'
-
-export class DeepSeekSimpleModel implements SimpleChatModel {
-  public subUrl = 'deepseek/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: {
-        ...data,
-        stream: false,
-      },
-      stream: false,
-      timeout: options?.timeout,
-    })) as DoGenerateOutput
-    return { ...res, rawResponse: res }
-  }
-
-  public async doStream(data: BaseChatModelInput, options?: ReqOptions): Promise<DoStreamOutput> {
-    let isToolCall: null | boolean = null
-    // eslint-disable-next-line @typescript-eslint/naming-convention
-    const _stream = await this.req({
-      url: this.url,
-      data: {
-        ...data,
-        stream: true,
-      },
-      stream: true,
-      timeout: options?.timeout,
-    })
-    const stream = toPolyfillReadable(_stream) as typeof _stream
-
-    const standardStream = intoStandardStream<BaseDoStreamOutputChunk>(stream)
-    const streamWithRaw = standardStream.pipeThrough(new TransformStream<BaseDoStreamOutputChunk, 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/Default/index.ts

@@ -1,70 +0,0 @@
-import {
-  createAsyncIterable,
-  TransformStream,
-  toPolyfillReadable,
-  intoStandardStream,
-  isToolCallAssistantMessage,
-} from '../../utils'
-import type {
-  ModelReq,
-  BaseChatModelInput,
-  SimpleChatModel,
-  DoStreamOutput,
-  BaseDoStreamOutputChunk,
-  DoGenerateOutput,
-} from '../../type'
-
-export class DefaultSimpleModel implements SimpleChatModel {
-  constructor(private req: ModelReq, public baseUrl: string, public subUrl: string = '') {}
-
-  private get url() {
-    return `${this.baseUrl}/${this.subUrl}`
-  }
-
-  public async doGenerate(data: BaseChatModelInput): Promise<DoGenerateOutput> {
-    const res = await this.req({
-      url: this.url,
-      data: { ...data, stream: false },
-      stream: false,
-    })
-    return { ...res, rawResponse: res }
-  }
-
-  public async doStream(data: BaseChatModelInput): Promise<DoStreamOutput> {
-    let isToolCall: null | boolean = null
-
-    // eslint-disable-next-line @typescript-eslint/naming-convention
-    const _stream = await this.req({
-      url: this.url,
-      data: {
-        ...data,
-        stream: true,
-      },
-      stream: true,
-    })
-    const stream = toPolyfillReadable(_stream) as typeof _stream
-
-    const standardStream = intoStandardStream<BaseDoStreamOutputChunk>(stream)
-    const streamWithRaw = standardStream.pipeThrough(new TransformStream<BaseDoStreamOutputChunk, BaseDoStreamOutputChunk & { rawResponse?: any }>({
-      transform(chunk, controller) {
-        const newChoices = chunk.choices.map((choice) => {
-          const message = choice.delta
-          // eslint-disable-next-line eqeqeq
-          if (isToolCall == null) isToolCall = isToolCallAssistantMessage(message)
-          if (isToolCall) {
-            return {
-              ...choice,
-              finish_reason: 'tool_calls',
-              delta: message,
-            }
-          }
-          return choice
-        })
-        const newChunk = { ...chunk, choices: newChoices }
-        controller.enqueue({ ...newChunk, rawResponse: chunk })
-      },
-    }),)
-
-    return createAsyncIterable(streamWithRaw)
-  }
-}

package/src/models/HunYuan/index.ts

@@ -1,94 +0,0 @@
-/* eslint-disable eqeqeq */
-import {
-  createAsyncIterable,
-  TransformStream,
-  toPolyfillReadable,
-  intoStandardStream,
-  isToolCallAssistantMessage,
-} from '../../utils'
-import type {
-  ModelReq,
-  BaseChatModelInput,
-  BaseDoStreamOutputChunk,
-  DoStreamOutput,
-  SimpleChatModel,
-  DoGenerateOutput,
-  ReqOptions,
-} from '../../type'
-import { processInput, titleCaseToSnakeCase } from './util'
-import { HunYuanGenerateTextOutput, HunYuanStreamTextOutput } from './type'
-
-export class HunYuanSimpleModel implements SimpleChatModel {
-  public subUrl = 'hunyuan'
-  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,
-      headers: {
-        'X-Tc-Action': 'ChatCompletions',
-      },
-      data: {
-        ...processInput(data),
-        stream: false,
-      },
-      stream: false,
-      timeout: options?.timeout,
-    })) as { Response: any }
-    const output = titleCaseToSnakeCase(res.Response) as HunYuanGenerateTextOutput
-    return {
-      ...output,
-      rawResponse: res,
-    }
-  }
-
-  public async doStream(data: BaseChatModelInput, options?: ReqOptions): Promise<DoStreamOutput> {
-    let isToolCall: null | boolean = null
-
-    // eslint-disable-next-line @typescript-eslint/naming-convention
-    const _stream = await this.req({
-      url: this.url,
-      headers: {
-        'X-Tc-Action': 'ChatCompletions',
-      },
-      data: {
-        ...data,
-        stream: true,
-      },
-      stream: true,
-      timeout: options?.timeout,
-    })
-    const stream = toPolyfillReadable(_stream) as typeof _stream
-
-    const hunyuanStream = intoStandardStream(stream)
-    const streamWithRaw = hunyuanStream.pipeThrough(new TransformStream<unknown, BaseDoStreamOutputChunk & { rawResponse?: any }>({
-      transform(_chunk, controller) {
-        const chunk = titleCaseToSnakeCase(_chunk) as HunYuanStreamTextOutput
-        const newChoices = chunk.choices.map((choice) => {
-          const message = choice.delta
-          if (isToolCall == null) isToolCall = isToolCallAssistantMessage(message)
-          if (isToolCall) {
-            return {
-              ...choice,
-              finish_reason: 'tool_calls',
-              delta: message,
-            }
-          }
-          return choice
-        })
-        const newChunk = { ...chunk, choices: newChoices }
-        controller.enqueue({ ...newChunk, rawResponse: _chunk })
-      },
-    }),)
-
-    return createAsyncIterable(streamWithRaw)
-  }
-}

package/src/models/HunYuan/type.ts

@@ -1,85 +0,0 @@
-type HunYuanUserMessage = {
-  role: 'user'
-  content: string
-}
-
-type HunYuanSystemMessage = { role: 'system'; content: string }
-
-type HunYuanToolMessage = { role: 'tool'; content: string; tool_call_id: string }
-
-type HunYuanAssistantMessage =
-  | { role: 'assistant'; content: string }
-  | {
-    role: 'assistant'
-    tool_calls: Array<HunYuanToolCall>
-    content?: string
-  }
-
-type HunYuanToolCall = {
-  id: string
-  type: 'function'
-  function: HunYuanToolCallFunction
-}
-
-type HunYuanToolCallFunction = {
-  name: string
-  arguments: string
-}
-
-export type HunYuanMessage = HunYuanUserMessage | HunYuanSystemMessage | HunYuanToolMessage | HunYuanAssistantMessage
-
-type HunYuanTool = {
-  // TODO: 混元文档说当前只支持 function
-  type: 'function'
-  function: HunYuanToolFunction
-}
-
-type HunYuanToolFunction = {
-  name: string
-  parameters: object
-  description?: string
-}
-
-export type HunYuanInputData = {
-  model:
-  | (string & {})
-  | 'hunyuan-lite'
-  | 'hunyuan-standard'
-  | 'hunyuan-standard-256K'
-  | 'hunyuan-pro'
-  | 'hunyuan-code'
-  | 'hunyuan-role'
-  | 'hunyuan-functioncall'
-  | 'hunyuan-vision'
-  messages: Array<HunYuanMessage>
-  stream_moderation?: boolean
-  top_p?: number
-  temperature?: number
-  enable_enhancement?: boolean
-  tools?: Array<HunYuanTool>
-  tool_choice?: 'none' | 'auto' | 'custom'
-  custom_tool?: HunYuanTool
-  search_info?: boolean
-}
-
-type Usage = { prompt_tokens: number; completion_tokens: number; total_tokens: number }
-
-export type HunYuanGenerateTextOutput = {
-  choices?: Array<GenerateChoice>
-  usage?: Usage
-}
-
-type GenerateChoice = {
-  finish_reason?: string
-  message: HunYuanMessage
-}
-
-type StreamChoice = {
-  finish_reason?: string
-  delta: HunYuanAssistantMessage
-}
-
-export type HunYuanStreamTextOutput = {
-  choices?: Array<StreamChoice>
-  usage?: Usage
-}

package/src/models/HunYuan/util.ts

@@ -1,60 +0,0 @@
-/* eslint-disable eqeqeq */
-/* eslint-disable @typescript-eslint/naming-convention */
-import { HunYuanInputData } from './type'
-import { BaseChatModelInput } from '../../type'
-
-/**
- * 这里的 process 只是对不符合的 input 做 warning。
- * 实际上还是会如实传递。
- * 防止未来模型参数更新，SDK 没跟上而导致用户输入无法生效。
- */
-export function processInput(input: BaseChatModelInput): HunYuanInputData {
-  const { messages, model, temperature, tool_choice, tools, top_p } = input
-
-  const handleTools = () => {
-    if (!tools) return undefined
-    tools.forEach((tool) => {
-      if (tool.type !== 'function') console.warn('`type` in tool is not \'function\'', tool)
-    })
-    return tools as HunYuanInputData['tools']
-  }
-
-  const handleMessages = () => {
-    messages.forEach((message) => {
-      if ('tool_calls' in message) {
-        message.tool_calls
-          .filter(tool_call => tool_call.type !== 'function')
-          .forEach(tool_call => console.warn('`type` in tool_call is not \'function\'', tool_call, message))
-      }
-    })
-    return messages as HunYuanInputData['messages']
-  }
-
-  return {
-    ...input,
-    messages: handleMessages(),
-    model,
-    tools: handleTools(),
-    top_p,
-    tool_choice,
-    temperature,
-  }
-}
-
-export function titleCaseToSnakeCase(obj: unknown) {
-  if (typeof obj !== 'object' || obj == null) return obj // 如果不是对象或者是null，则直接返回
-
-  if (Array.isArray(obj)) return obj.map(item => titleCaseToSnakeCase(item)) // 如果是数组，递归处理每个元素
-
-  return Object.entries(obj).reduce((acc, [key, value]) => {
-    const snakeCaseKey = toSnakeCase(key)
-
-    acc[snakeCaseKey] = typeof value === 'object' ? titleCaseToSnakeCase(value) : value
-    return acc
-  }, {})
-
-  function toSnakeCase(s: string) {
-    const ret = s.replace(/[A-Z]/g, match => `_${match.toLowerCase()}`)
-    return ret.charAt(0) === '_' ? ret.slice(1) : ret
-  }
-}

package/src/models/HunYuanBeta/index.ts

@@ -1,83 +0,0 @@
-/* eslint-disable @typescript-eslint/naming-convention */
-/* eslint-disable eqeqeq */
-import {
-  createAsyncIterable,
-  TransformStream,
-  toPolyfillReadable,
-  intoStandardStream,
-  isToolCallAssistantMessage,
-} from '../../utils'
-import type {
-  ModelReq,
-  BaseChatModelInput,
-  SimpleChatModel,
-  DoStreamOutput,
-  BaseDoStreamOutputChunk,
-  DoGenerateOutput,
-  ReqOptions,
-} from '../../type'
-import { processInput } from '../HunYuan/util'
-import { HunYuanGenerateTextOutput, HunYuanStreamTextOutput } from '../HunYuan/type'
-
-export class HunYuanBetaSimpleModel implements SimpleChatModel {
-  public subUrl = 'hunyuan-beta/openapi/v1/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 HunYuanGenerateTextOutput
-    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 hunyuanBetaStream = intoStandardStream<HunYuanStreamTextOutput>(stream)
-    const streamWithRaw = hunyuanBetaStream.pipeThrough(new TransformStream<HunYuanStreamTextOutput, 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',
-              delta: message,
-            }
-          }
-          return choice
-        })
-        const newChunk = { ...chunk, choices: newChoices }
-        controller.enqueue({ ...newChunk, rawResponse: chunk })
-      },
-    }),)
-
-    return createAsyncIterable(streamWithRaw)
-  }
-}