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

package/src/models/DashScope/index.ts

@@ -0,0 +1,97 @@
+/* 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

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

@@ -0,0 +1,80 @@
+/* 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

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

@@ -0,0 +1,94 @@
+/* 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

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

@@ -0,0 +1,60 @@
+/* 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

@@ -0,0 +1,83 @@
+/* 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)
+  }
+}