@cloudbase/ai 2.8.21-beta.0 → 2.8.22-beta.0

package/src/models/HunYuanBeta/index.ts

@@ -1,15 +1,22 @@
-import { type ParsedEvent } from '../../eventsource_parser'
 import {
   createAsyncIterable,
   TransformStream,
-  TextDecoderStream,
-  createEventSourceParserTransformStream,
   toPolyfillReadable,
+  intoStandardStream,
+  isToolCallAssistantMessage,
 } from '../../utils'
-import type { HunYuanInputData, HunYaunGenerateTextOutput, HunYaunStreamTextOutput } from './type'
-import type { ChatModel, StreamTextResult, ModelReq, BaseChatModelInput } from '../../type'
+import type {
+  ModelReq,
+  BaseChatModelInput,
+  SimpleChatModel,
+  DoStreamOutput,
+  BaseDoStreamOutputChunk,
+  DoGenerateOutput,
+} from '../../type'
+import { processInput } from '../HunYuan/util'
+import { HunYuanGenerateTextOutput, HunYuanStreamTextOutput } from '../HunYuan/type'
 
-export class HunYuanBetaModel implements ChatModel {
+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) {
@@ -21,92 +28,51 @@ export class HunYuanBetaModel implements ChatModel {
     return `${this.baseUrl}/${this.subUrl}`
   }
 
-  async generateText(data: BaseChatModelInput) {
-    const processedData = this.processInput(data)
+  public async doGenerate(data: BaseChatModelInput): Promise<DoGenerateOutput> {
     const res = (await this.req({
       url: this.url,
-      headers: {
-        'X-Tc-Action': 'ChatCompletions',
-      },
       data: {
-        ...processedData,
-        Stream: false,
+        ...processInput(data),
+        stream: false,
       },
       stream: false,
-    })) as HunYaunGenerateTextOutput
-    return {
-      text: (res?.choices?.[0]?.message?.content as string) ?? '',
-      rawResponse: res,
-    }
+    })) as HunYuanGenerateTextOutput
+    return { ...res, rawResponse: res }
   }
 
-  async streamText(data: BaseChatModelInput) {
-    const processedData = this.processInput(data)
-    const stream = await this.req({
+  public async doStream(data: BaseChatModelInput): Promise<DoStreamOutput> {
+    let isToolCall: null | boolean = null
+
+    const _stream = await this.req({
       url: this.url,
-      headers: {
-        'X-Tc-Action': 'ChatCompletions',
-      },
       data: {
-        ...processedData,
-        Stream: true,
+        ...data,
+        stream: true,
       },
       stream: true,
     })
-    return new HunyuanModelStreamResult(stream)
-  }
-
-  private processInput({ messages, model, temperature, top_p, ...rest }: BaseChatModelInput): HunYuanInputData {
-    return {
-      Messages: messages.map(({ content, role }) => ({ Content: content, Role: role })),
-      Model: model as any,
-      Temperature: temperature,
-      TopP: top_p,
-      ...rest,
-    }
-  }
-}
-
-class HunyuanModelStreamResult implements StreamTextResult {
-  private _eventSourceStream: ReadableStream<ParsedEvent>
-
-  constructor(_stream: ReadableStream<Uint8Array>) {
     const stream = toPolyfillReadable(_stream) as typeof _stream
-    this._eventSourceStream = stream
-      .pipeThrough(new TextDecoderStream())
-      .pipeThrough(createEventSourceParserTransformStream())
-  }
 
-  private get teeedStream() {
-    const [s1, s2] = this._eventSourceStream.tee()
-    this._eventSourceStream = s2
-    return s1
-  }
-
-  get eventSourceStream() {
-    return createAsyncIterable(this.teeedStream)
-  }
-
-  get dataStream() {
-    return createAsyncIterable(this.eventSourceStream.pipeThrough(new TransformStream<ParsedEvent, HunYaunStreamTextOutput>({
+    const hunyuanBetaStream = intoStandardStream<HunYuanStreamTextOutput>(stream)
+    const streamWithRaw = hunyuanBetaStream.pipeThrough(new TransformStream<HunYuanStreamTextOutput, BaseDoStreamOutputChunk & { rawResponse?: any }>({
       transform(chunk, controller) {
-        try {
-          const data = JSON.parse(chunk.data) as HunYaunStreamTextOutput
-          controller.enqueue(data)
-        } catch (e) {
-          if (chunk.data !== '[DONE]') {
-            console.warn('Error when transforming event source data to json', e)
+        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 })
       },
-    }),),)
-  }
+    }),)
 
-  get textStream() {
-    return createAsyncIterable(this.dataStream.pipeThrough(new TransformStream<HunYaunStreamTextOutput, string>({
-      transform(chunk, controller) {
-        controller.enqueue(chunk?.choices?.[0]?.delta?.content ?? '')
-      },
-    }),),)
+    return createAsyncIterable(streamWithRaw)
   }
 }

package/src/models/Moonshot/index.ts

@@ -1,15 +1,37 @@
-import { type ParsedEvent } from '../../eventsource_parser'
 import {
   createAsyncIterable,
   TransformStream,
-  TextDecoderStream,
-  createEventSourceParserTransformStream,
   toPolyfillReadable,
+  intoStandardStream,
+  isToolCallAssistantMessage,
 } from '../../utils'
-import type { MoonshotInputData, MoonshotGenerateTextOutput, MoonshotStreamTextOutput } from './type'
-import type { ChatModel, StreamTextResult, ModelReq } from '../../type'
+import type { MoonshotGenerateTextOutput, MoonshotStreamTextOutput, MoonshotInputData } from './type'
+import type {
+  ModelReq,
+  BaseDoStreamOutputChunk,
+  DoGenerateOutput,
+  DoStreamOutput,
+  SimpleChatModel,
+  BaseChatModelInput,
+} from '../../type'
 
-export class MoonshotModel implements ChatModel {
+function processInput(input: BaseChatModelInput): MoonshotInputData {
+  const { messages, model, temperature, tools, top_p } = input
+
+  return {
+    ...input,
+    messages,
+    model,
+    tools: tools?.map(tool => ({
+      ...tool,
+      function: { ...tool.function, parameters: JSON.parse(tool.function.parameters) },
+    })),
+    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) {
@@ -21,74 +43,50 @@ export class MoonshotModel implements ChatModel {
     return `${this.baseUrl}/${this.subUrl}`
   }
 
-  async generateText(data: MoonshotInputData) {
+  public async doGenerate(data: BaseChatModelInput): Promise<DoGenerateOutput> {
     const res = (await this.req({
       url: this.url,
       data: {
-        ...data,
+        ...processInput(data),
         stream: false,
       },
       stream: false,
     })) as MoonshotGenerateTextOutput
-    return {
-      text: (res?.choices?.[0]?.message?.content as string) ?? '',
-      rawResponse: res,
-    }
+    return { ...res, rawResponse: res }
   }
 
-  async streamText(data: MoonshotInputData) {
-    const stream = await this.req({
+  public async doStream(data: BaseChatModelInput): Promise<DoStreamOutput> {
+    let isToolCall: null | boolean = null
+    const _stream = await this.req({
       url: this.url,
       data: {
-        ...data,
+        ...processInput(data),
         stream: true,
       },
       stream: true,
     })
-    return new MoonshotModelStreamResult(stream)
-  }
-}
-
-class MoonshotModelStreamResult implements StreamTextResult {
-  private _eventSourceStream: ReadableStream<ParsedEvent>
-
-  constructor(_stream: ReadableStream<Uint8Array>) {
     const stream = toPolyfillReadable(_stream) as typeof _stream
-    this._eventSourceStream = stream
-      .pipeThrough(new TextDecoderStream())
-      .pipeThrough(createEventSourceParserTransformStream())
-  }
-
-  private get teeedStream() {
-    const [s1, s2] = this._eventSourceStream.tee()
-    this._eventSourceStream = s2
-    return s1
-  }
-
-  get eventSourceStream() {
-    return createAsyncIterable(this.teeedStream)
-  }
 
-  get dataStream() {
-    return createAsyncIterable(this.eventSourceStream.pipeThrough(new TransformStream<ParsedEvent, MoonshotStreamTextOutput>({
+    const arkStream = intoStandardStream<MoonshotStreamTextOutput>(stream)
+    const streamWithRaw = arkStream.pipeThrough(new TransformStream<MoonshotStreamTextOutput, BaseDoStreamOutputChunk & { rawResponse?: any }>({
       transform(chunk, controller) {
-        try {
-          const data = JSON.parse(chunk.data) as MoonshotStreamTextOutput
-          controller.enqueue(data)
-        } catch (e) {
-          if (chunk.data !== '[DONE]') {
-            console.warn('Error when transforming event source data to json', e)
+        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 })
       },
-    }),),)
-  }
+    }),)
 
-  get textStream() {
-    return createAsyncIterable(this.dataStream.pipeThrough(new TransformStream<MoonshotStreamTextOutput, string>({
-      transform(chunk, controller) {
-        controller.enqueue(chunk?.choices?.[0]?.delta?.content ?? '')
-      },
-    }),),)
+    return createAsyncIterable(streamWithRaw)
   }
 }

package/src/models/Moonshot/type.ts

@@ -1,12 +1,42 @@
-type MoonshotMessage = { role: 'user' | 'system' | 'assistant'; content: string }
+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: 'moonshot-v1-8k' | 'moonshot-v1-32k' | 'moonshot-v1-128k'
+  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
@@ -15,14 +45,38 @@ export type MoonshotInputData = {
 
 // todo: more precise
 export type MoonshotGenerateTextOutput = {
-  choices?: Array<{
-    message?: { content?: string }
+  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 }
+  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,16 +1,39 @@
-import { type ParsedEvent } from '../../eventsource_parser'
 import {
   createAsyncIterable,
   TransformStream,
-  TextDecoderStream,
-  createEventSourceParserTransformStream,
   toPolyfillReadable,
+  intoStandardStream,
+  isToolCallAssistantMessage,
 } from '../../utils'
-import type { YiGenerateTextOutput, YiStreamTextOutput } from './type'
-import type { ChatModel, StreamTextResult, ModelReq, BaseChatModelInput } from '../../type'
+import type { YiInput, YiGenerateOutput, YiStreamOutput } from './type'
+import type {
+  ModelReq,
+  BaseChatModelInput,
+  DoGenerateOutput,
+  DoStreamOutput,
+  BaseDoStreamOutputChunk,
+  SimpleChatModel,
+} from '../../type'
 
-export class YiModel implements ChatModel {
+function processInput(input: BaseChatModelInput): YiInput {
+  const { messages, model, temperature, tools, top_p } = input
+
+  return {
+    ...input,
+    messages,
+    model,
+    tools: tools?.map(tool => ({
+      ...tool,
+      function: { ...tool.function, parameters: JSON.parse(tool.function.parameters) },
+    })),
+    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
@@ -21,74 +44,55 @@ export class YiModel implements ChatModel {
     return `${this.baseUrl}/${this.subUrl}`
   }
 
-  async generateText(data: BaseChatModelInput) {
+  public async doGenerate(data: BaseChatModelInput): Promise<DoGenerateOutput> {
     const res = (await this.req({
       url: this.url,
       data: {
-        ...data,
+        ...processInput(data),
         stream: false,
       },
       stream: false,
-    })) as YiGenerateTextOutput
-    return {
-      text: (res?.choices?.[0]?.message?.content as string) ?? '',
-      rawResponse: res,
-    }
+    })) as YiGenerateOutput
+    return { ...res, rawResponse: res }
   }
 
-  async streamText(data: BaseChatModelInput) {
-    const stream = await this.req({
+  public async doStream(data: BaseChatModelInput): Promise<DoStreamOutput> {
+    let isToolCall: null | boolean = null
+    const _stream = await this.req({
       url: this.url,
       data: {
-        ...data,
+        ...processInput(data),
         stream: true,
       },
       stream: true,
     })
-    return new YiModelStreamResult(stream)
-  }
-}
-
-class YiModelStreamResult implements StreamTextResult {
-  private _eventSourceStream: ReadableStream<ParsedEvent>
-
-  constructor(_stream: ReadableStream<Uint8Array>) {
     const stream = toPolyfillReadable(_stream) as typeof _stream
-    this._eventSourceStream = stream
-      .pipeThrough(new TextDecoderStream())
-      .pipeThrough(createEventSourceParserTransformStream())
-  }
-
-  private get teeedStream() {
-    const [s1, s2] = this._eventSourceStream.tee()
-    this._eventSourceStream = s2
-    return s1
-  }
-
-  get eventSourceStream() {
-    return createAsyncIterable(this.teeedStream)
-  }
 
-  get dataStream() {
-    return createAsyncIterable(this.eventSourceStream.pipeThrough(new TransformStream<ParsedEvent, YiStreamTextOutput>({
+    const arkStream = intoStandardStream<YiStreamOutput>(stream)
+    const streamWithRaw = arkStream.pipeThrough(new TransformStream<YiStreamOutput, BaseDoStreamOutputChunk & { rawResponse?: any }>({
       transform(chunk, controller) {
-        try {
-          const data = JSON.parse(chunk.data) as YiStreamTextOutput
-          controller.enqueue(data)
-        } catch (e) {
-          if (chunk.data !== '[DONE]') {
-            console.warn('Error when transforming event source data to json', e)
+        // 非常奇葩
+        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 })
       },
-    }),),)
-  }
+    }),)
 
-  get textStream() {
-    return createAsyncIterable(this.dataStream.pipeThrough(new TransformStream<YiStreamTextOutput, string>({
-      transform(chunk, controller) {
-        controller.enqueue(chunk?.choices?.[0]?.delta?.content ?? '')
-      },
-    }),),)
+    return createAsyncIterable(streamWithRaw)
   }
 }

package/src/models/Yi/type.ts

@@ -8,10 +8,16 @@ type UserMessage = {
   content: string
 }
 
-type AssistantMessage = {
-  role: 'assistant'
-  content: string
-}
+type AssistantMessage =
+  | {
+    role: 'assistant'
+    content: string
+  }
+  | {
+    role: 'assistant'
+    tool_calls: Array<ToolCall>
+    content?: string
+  }
 
 type ToolMessage = {
   role: 'tool'
@@ -21,29 +27,51 @@ type ToolMessage = {
 
 type YiMessage = SystemMessage | UserMessage | AssistantMessage | ToolMessage
 
-export type YiInputData = {
+export type YiInput = {
   model: string
   messages: Array<YiMessage>
+  temperature?: number
+  top_p?: number
   tools?: Array<{
-    type: 'function'
-    function: { name: string; description?: string; parameters: object }
+    type: string
+    function: { name: string; description: string; parameters: object }
   }>
-  tool_choice?: string | object
-  max_tokens?: number | null
-  top_p?: number
-  temperature?: number
 }
 
-// todo: more precise
-export type YiGenerateTextOutput = {
-  choices?: Array<{
-    message?: { content?: string }
+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
+  }
 }
 
-// todo: more precise
-export type YiStreamTextOutput = {
-  choices?: Array<{
-    delta?: { content?: string }
+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
+  }
 }