@cloudbase/ai 3.6.2 → 3.6.4-alpha.1

package/src/models/HunYuanExp/index.ts

@@ -1,80 +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,
-} from '../../type'
-import { processInput } from '../HunYuan/util'
-import { HunYuanGenerateTextOutput, HunYuanStreamTextOutput } from '../HunYuan/type'
-
-export class HunYuanExpSimpleModel implements SimpleChatModel {
-  public subUrl = 'hunyuan-exp/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): Promise<DoGenerateOutput> {
-    const res = (await this.req({
-      url: this.url,
-      data: {
-        ...processInput(data),
-        stream: false,
-      },
-      stream: false,
-    })) as HunYuanGenerateTextOutput
-    return { ...res, rawResponse: res }
-  }
-
-  public async doStream(data: BaseChatModelInput): Promise<DoStreamOutput> {
-    let isToolCall: null | boolean = null
-
-    const _stream = await this.req({
-      url: this.url,
-      data: {
-        ...processInput(data),
-        stream: true,
-      },
-      stream: true,
-    })
-    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)
-  }
-}

package/src/models/HunYuanOpen/index.ts

@@ -1,83 +0,0 @@
-/* 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 HunYuanOpenSimpleModel implements SimpleChatModel {
-  public subUrl = 'hunyuan-open/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
-
-    // eslint-disable-next-line @typescript-eslint/naming-convention
-    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)
-  }
-}

package/src/models/Moonshot/index.ts

@@ -1,95 +0,0 @@
-/* eslint-disable eqeqeq */
-import {
-  createAsyncIterable,
-  TransformStream,
-  toPolyfillReadable,
-  intoStandardStream,
-  isToolCallAssistantMessage,
-} from '../../utils'
-import type { MoonshotGenerateTextOutput, MoonshotStreamTextOutput, MoonshotInputData } from './type'
-import type {
-  ModelReq,
-  BaseDoStreamOutputChunk,
-  DoGenerateOutput,
-  DoStreamOutput,
-  SimpleChatModel,
-  BaseChatModelInput,
-  ReqOptions,
-} from '../../type'
-
-function processInput(input: BaseChatModelInput): MoonshotInputData {
-  // eslint-disable-next-line @typescript-eslint/naming-convention
-  const { messages, model, temperature, tools, top_p } = input
-
-  return {
-    ...input,
-    messages,
-    model,
-    tools,
-    top_p,
-    temperature,
-  }
-}
-
-export class MoonshotSimpleModel implements SimpleChatModel {
-  public subUrl = 'moonshot/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 MoonshotGenerateTextOutput
-    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: {
-        ...processInput(data),
-        stream: true,
-      },
-      stream: true,
-      timeout: options?.timeout,
-    })
-    const stream = toPolyfillReadable(_stream) as typeof _stream
-
-    const arkStream = intoStandardStream<MoonshotStreamTextOutput>(stream)
-    const streamWithRaw = arkStream.pipeThrough(new TransformStream<MoonshotStreamTextOutput, 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/Moonshot/type.ts

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

package/src/models/Yi/index.ts

@@ -1,100 +0,0 @@
-/* eslint-disable @typescript-eslint/naming-convention */
-/* eslint-disable eqeqeq */
-import {
-  createAsyncIterable,
-  TransformStream,
-  toPolyfillReadable,
-  intoStandardStream,
-  isToolCallAssistantMessage,
-} from '../../utils'
-import type { YiInput, YiGenerateOutput, YiStreamOutput } from './type'
-import type {
-  ModelReq,
-  BaseChatModelInput,
-  DoGenerateOutput,
-  DoStreamOutput,
-  BaseDoStreamOutputChunk,
-  SimpleChatModel,
-  ReqOptions,
-} from '../../type'
-
-function processInput(input: BaseChatModelInput): YiInput {
-  const { messages, model, temperature, tools, top_p } = input
-
-  return {
-    ...input,
-    messages,
-    model,
-    tools,
-    top_p,
-    temperature,
-  }
-}
-
-export class YiSimpleModel implements SimpleChatModel {
-  public subUrl = '01-ai/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 YiGenerateOutput
-    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<YiStreamOutput>(stream)
-    const streamWithRaw = arkStream.pipeThrough(new TransformStream<YiStreamOutput, BaseDoStreamOutputChunk & { rawResponse?: any }>({
-      transform(chunk, controller) {
-        // 非常奇葩
-        if (!(chunk?.choices?.[0]?.delta?.content || chunk?.choices?.[0]?.delta?.tool_calls)) return
-
-        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/Yi/type.ts

@@ -1,77 +0,0 @@
-type SystemMessage = {
-  role: 'system'
-  content: string
-}
-
-type UserMessage = {
-  role: 'user'
-  content: string
-}
-
-type AssistantMessage =
-  | {
-    role: 'assistant'
-    content: string
-  }
-  | {
-    role: 'assistant'
-    tool_calls: Array<ToolCall>
-    content?: string
-  }
-
-type ToolMessage = {
-  role: 'tool'
-  content: string
-  tool_call_id: string
-}
-
-type YiMessage = SystemMessage | UserMessage | AssistantMessage | ToolMessage
-
-export type YiInput = {
-  model: string
-  messages: Array<YiMessage>
-  temperature?: number
-  top_p?: number
-  tools?: Array<{
-    type: string
-    function: { name: string; description: string; parameters: object }
-  }>
-}
-
-type ToolCall = {
-  id: string
-  type: string
-  function: { name: string; arguments: string }
-}
-
-export type YiGenerateOutput = {
-  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 YiStreamOutput = {
-  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/ZhiPu/index.ts

@@ -1,104 +0,0 @@
-/* eslint-disable eqeqeq */
-/* eslint-disable @typescript-eslint/naming-convention */
-import {
-  createAsyncIterable,
-  TransformStream,
-  toPolyfillReadable,
-  intoStandardStream,
-  isToolCallAssistantMessage,
-} from '../../utils'
-import type { ZhiPuGenerateTextOutput, ZhiPuInputData, ZhiPuStreamTextOutput } from './type'
-import type {
-  ModelReq,
-  BaseChatModelInput,
-  SimpleChatModel,
-  DoStreamOutput,
-  BaseDoStreamOutputChunk,
-  DoGenerateOutput,
-  ReqOptions,
-} from '../../type'
-
-function processInput(input: BaseChatModelInput): ZhiPuInputData {
-  const { messages, model, temperature, tool_choice, tools, top_p } = input
-
-  const processToolChoice = () => {
-    if (tool_choice && tool_choice !== 'auto') {
-      console.warn('`tool_choice` is not \'auto\'')
-    }
-    return tool_choice as any
-  }
-
-  return {
-    ...input,
-    messages,
-    model,
-    temperature,
-    tool_choice: processToolChoice(),
-    tools,
-    top_p,
-  }
-}
-
-export class ZhiPuSimpleModel implements SimpleChatModel {
-  public subUrl = 'zhipu/api/paas/v4/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 data = processInput(_data)
-    const res = (await this.req({
-      url: this.url,
-      data: {
-        ...data,
-        stream: false,
-      },
-      stream: false,
-      timeout: options?.timeout,
-    })) as ZhiPuGenerateTextOutput
-    return { ...res, rawResponse: res }
-  }
-
-  public async doStream(_data: BaseChatModelInput, options?: ReqOptions): Promise<DoStreamOutput> {
-    const data = processInput(_data)
-    let isToolCall: null | boolean = null
-    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 zhipuStream = intoStandardStream<ZhiPuStreamTextOutput>(stream)
-    const streamWithRaw = zhipuStream.pipeThrough(new TransformStream<ZhiPuStreamTextOutput, 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/ZhiPu/type.ts

@@ -1,71 +0,0 @@
-import { ChatModelMessage } from '../../type'
-
-type SystemMessage = {
-  role: 'system'
-  content: string
-}
-
-type UserMessage = {
-  role: 'user'
-  content: string
-}
-
-type AssistantMessage = {
-  role: 'assistant'
-  content?: string
-  tool_calls?: Array<{
-    id: string
-    type: string
-    function?: { name: string; arguments: string }
-  }>
-}
-
-type ToolMessage = {
-  role: 'tool'
-  content: string
-  tool_call_id: string
-}
-
-type ZhiPuMessage = SystemMessage | UserMessage | AssistantMessage | ToolMessage
-
-export type ZhiPuInputData = {
-  model: string
-  messages: Array<ZhiPuMessage>
-  request_id?: string
-  do_sample?: boolean
-  temperature?: number
-  top_p?: number
-  max_tokens?: number
-  stop?: Array<string>
-  tools?: Array<{
-    type: string
-    function: { name: string; description: string; parameters: object }
-  }>
-  tool_choice?: 'auto'
-  user_id?: string
-}
-
-export type ZhiPuGenerateTextOutput = {
-  choices?: Array<{
-    finish_reason?: 'stop' | 'tool_calls' | 'length' | 'sensitive' | 'network_error'
-    message?: ChatModelMessage
-  }>
-  usage?: {
-    completion_tokens: number
-    prompt_tokens: number
-    total_tokens: number
-  }
-}
-
-export type ZhiPuStreamTextOutput = {
-  choices?: Array<{
-    index: number
-    finish_reason?: 'stop' | 'tool_calls' | 'length' | 'sensitive' | 'network_error'
-    delta?: ChatModelMessage
-  }>
-  usage?: {
-    completion_tokens: number
-    prompt_tokens: number
-    total_tokens: number
-  }
-}