@planet-matrix/mobius-model 0.5.0 → 0.9.0

package/src/ai/chat-completion-ai/aihubmix-chat-completion.ts

@@ -0,0 +1,78 @@
+import type * as Openai from "#Source/openai/index.ts"
+
+import type { BaseChatCompletionOptions, ChatCompletionOptions, ChatCompletionResult } from "./chat-completion.ts"
+import { BaseChatCompletion } from "./chat-completion.ts"
+
+export interface AihubmixChatCompletionOptions extends BaseChatCompletionOptions {
+  openai: Openai.Openai
+}
+export class AihubmixChatCompletion extends BaseChatCompletion {
+  protected readonly openai: Openai.Openai
+
+  constructor(options: AihubmixChatCompletionOptions) {
+    super(options)
+    this.logger.setDefaultName("AihubmixChatCompletion")
+
+    this.openai = options.openai
+  }
+
+  protected transformOptions(options: ChatCompletionOptions): Openai.CustomChatCompletionOptions {
+    const transformedOptions: Openai.CustomChatCompletionOptions = {
+      messages: options.messages.map((message) => {
+        const { role, content } = message
+        if (role === "system") {
+          return message
+        }
+        if (role === "user") {
+          if (typeof content === "string") {
+            return {
+              role,
+              content,
+            }
+          }
+          if (Array.isArray(content)) {
+            return {
+              role,
+              content: content.map((item) => {
+                if (item.type === "image_url") {
+                  return {
+                    type: item.type,
+                    image_url: item.imageUrl,
+                  }
+                }
+                else {
+                  return item
+                }
+              }),
+            }
+          }
+          throw new Error("Invalid content")
+        }
+        if (role === "assistant") {
+          return message
+        }
+        throw new Error("Invalid role")
+      }),
+      model: options.model,
+      ...(options.frequencyPenalty !== undefined ? { frequency_penalty: options.frequencyPenalty } : {}),
+      ...(options.logitBias !== undefined ? { logit_bias: options.logitBias } : {}),
+      ...(options.logprobs !== undefined ? { logprobs: options.logprobs } : {}),
+      ...(options.maxCompletionTokens !== undefined ? { max_completion_tokens: options.maxCompletionTokens } : {}),
+      ...(options.maxTokens !== undefined ? { max_tokens: options.maxTokens } : {}),
+      ...(options.presencePenalty !== undefined ? { presence_penalty: options.presencePenalty } : {}),
+      ...(options.responseFormat !== undefined ? { response_format: options.responseFormat } : {}),
+      ...(options.temperature !== undefined ? { temperature: options.temperature } : {}),
+      ...(options.topLogprobs !== undefined ? { top_logprobs: options.topLogprobs } : {}),
+      ...(options.topP !== undefined ? { top_p: options.topP } : {}),
+      timeout: options.timeoutFirstChunk ?? undefined,
+      abortSignal: options.abortSignal,
+    }
+    return transformedOptions
+  }
+
+  async chatCompletion(options: ChatCompletionOptions): Promise<ChatCompletionResult> {
+    const transformedOptions = this.transformOptions(options)
+    const result = await this.openai.customChatCompletionStreaming(transformedOptions)
+    return result
+  }
+}

package/src/ai/chat-completion-ai/chat-completion-ai.ts

@@ -0,0 +1,270 @@
+import type { LoggerFriendly, LoggerFriendlyOptions } from "#Source/log/index.ts"
+import type { AbortManager } from "#Source/abort/index.ts"
+
+import { Logger } from "#Source/log/index.ts"
+import { Dispatcher } from "#Source/orchestration/index.ts"
+import { fromWithAbortSignal } from "#Source/abort/index.ts"
+import { controllerFromEitherType, eitherToTuple } from "#Source/result/index.ts"
+import { scheduleMacroTask } from "#Source/basic/index.ts"
+import { connectTube, Tube } from "#Source/tube/index.ts"
+import * as Aio from "#Source/aio/index.ts"
+
+import type { BaseChatCompletion, ChatCompletionOptions, ChatCompletionResult, Completion } from "./chat-completion.ts"
+
+export interface ChatCompletionAiOptions extends LoggerFriendlyOptions {
+  chatCompletionInstanceList: BaseChatCompletion[]
+  /**
+   * The timeout for the first chunk of data to be received, in milliseconds.
+   *
+   * @default timeoutPerChunk | 30_000
+   */
+  timeoutFirstChunk?: number | undefined
+  /**
+   * The timeout for each chunk of data to be received, in milliseconds.
+   *
+   * @default 30_000
+   */
+  timeoutPerChunk?: number | undefined
+  /**
+   * The maximum number of tries for the request.
+   *
+   * @default 3
+   */
+  maxTries?: number | undefined
+}
+interface ResolvedChatCompletionAiOptions {
+  chatCompletionInstanceList: BaseChatCompletion[]
+  timeoutFirstChunk: number
+  timeoutPerChunk: number
+  maxTries: number
+}
+export class ChatCompletionAi implements LoggerFriendly {
+  protected readonly options: ResolvedChatCompletionAiOptions
+
+  readonly logger: Logger
+  private dispatcher: Dispatcher<BaseChatCompletion>
+
+  constructor(options: ChatCompletionAiOptions) {
+    this.options = {
+      chatCompletionInstanceList: options.chatCompletionInstanceList,
+      timeoutFirstChunk: options.timeoutFirstChunk ?? options.timeoutPerChunk ?? 30_000,
+      timeoutPerChunk: options.timeoutPerChunk ?? 30_000,
+      maxTries: options.maxTries ?? 3,
+    }
+
+    this.logger = Logger.fromOptions(options).setDefaultName("ChatCompletionAi")
+
+    this.dispatcher = new Dispatcher({
+      itemList: this.options.chatCompletionInstanceList,
+      logger: this.logger,
+    })
+  }
+
+  async chatCompletion(
+    options: ChatCompletionOptions
+  ): Promise<ChatCompletionResult> {
+    const controller = controllerFromEitherType<ChatCompletionResult>()
+
+    const completionTube = new Tube<Completion>({
+      historyCount: Infinity,
+      replayHistory: true
+    })
+
+    scheduleMacroTask({
+      task: async () => {
+        await this.request(options, completionTube)
+      },
+    })
+
+    return await controller.returnRight({
+      completionTube,
+    })
+  }
+
+  private async request(
+    options: ChatCompletionOptions,
+    targetCompletionTube: Tube<Completion>,
+  ): Promise<void> {
+    const { selector, destroy } = this.dispatcher.getSelector({
+      filter: (item) => {
+        return item.isSupportModel(options.model) === true
+      },
+    })
+    targetCompletionTube.subscribeEndEvent({
+      subscriber: () => {
+        destroy()
+      },
+    })
+
+    const latestCompletion: Completion = {
+      content: {
+        deltaList: [],
+        total: "",
+      },
+      token: {
+        deltaList: [],
+        total: 0,
+      },
+    }
+
+    const maxTries = options.maxTries ?? this.options.maxTries
+
+    interface HandleTryErrorOptions {
+      tryIndex: number
+      abortManager: AbortManager
+    }
+    const handleTryError = async (options: HandleTryErrorOptions): Promise<void> => {
+      const { tryIndex, abortManager } = options
+
+      this.logger.log(`Handle try error, current failure count: ${tryIndex + 1}, max tries: ${maxTries}`)
+
+      if (abortManager.isAborted()) {
+        this.logger.log("Chat completion aborted by invoker.")
+        await targetCompletionTube.pushError(new Error("Chat completion aborted by invoker."))
+        abortManager.abort("Chat completion aborted by invoker.")
+        return
+      }
+      else {
+        this.logger.log("Chat completion not aborted by invoker.")
+      }
+      // 清理资源
+      abortManager.abort("Failed request")
+
+      // 重置数据
+      latestCompletion.content = Aio.applyDeltaToTextContent(latestCompletion.content, {
+        type: "reset",
+      })
+      latestCompletion.token = Aio.applyDeltaToNumberContent(latestCompletion.token, {
+        type: "reset",
+      })
+      await targetCompletionTube.pushData(structuredClone(latestCompletion))
+
+      // 如果尝试次数未达到上限，则继续尝试
+      const nextTryIndex = tryIndex + 1
+      if (nextTryIndex < maxTries) {
+        this.logger.log(`Not exceed maximum tries (${maxTries}) for chat completion, try again`)
+        scheduleMacroTask({
+          task: async () => {
+            await startTry(nextTryIndex)
+          },
+          timeout: 500,
+        })
+      }
+      else {
+        this.logger.log(`Exceeded maximum tries (${maxTries}) for chat completion`)
+        await targetCompletionTube.pushError(new Error("Exceeded maximum tries."))
+      }
+    }
+    const startTry = async (tryIndex: number): Promise<void> => {
+      this.logger.log(`Start try, tries ${tryIndex + 1} of ${maxTries}`)
+
+      const abortManager = fromWithAbortSignal(options)
+      const [getItemLeft, getItemRight] = eitherToTuple(await selector.getItem())
+      if (getItemLeft !== undefined) {
+        await handleTryError({ tryIndex, abortManager })
+        return
+      }
+      const { item, markUnavailable } = getItemRight
+      this.logger.log(`${item.logger.getName()} is selected from pool`)
+      const [leftResult, rightResult] = eitherToTuple(await this.requestAndConstrainSpeed(
+        {
+          ...options,
+          abortSignal: abortManager.abortSignal,
+        },
+        item,
+      ))
+      if (leftResult !== undefined) {
+        await handleTryError({ tryIndex, abortManager })
+        return
+      }
+      const { completionTube: sourceCompletionTube } = rightResult
+      sourceCompletionTube.subscribeEndEvent({
+        subscriber: async (): Promise<void> => {
+          if (sourceCompletionTube.isError()) {
+            this.logger.log("Source completion tube ended with error")
+            markUnavailable()
+            await handleTryError({ tryIndex, abortManager })
+          }
+          else {
+            this.logger.log("Source completion tube ended normally")
+            await targetCompletionTube.end()
+          }
+        },
+      })
+      sourceCompletionTube.subscribeData({
+        subscriber: async (data: Completion): Promise<void> => {
+          await targetCompletionTube.pushData(data)
+        },
+      })
+    }
+
+    await startTry(0)
+  }
+
+  /**
+   * 发起请求并对返回结果施加时间约束，当发生以下情况时，将被视为请求失败：
+   * 1. 首个数据块超时；
+   * 2. 相邻数据块超时；
+   */
+  private async requestAndConstrainSpeed(
+    options: ChatCompletionOptions,
+    instance: BaseChatCompletion,
+  ): Promise<ChatCompletionResult> {
+    const controller = controllerFromEitherType<ChatCompletionResult>()
+
+    const [chatCompletionLeft, chatCompletionRight] = eitherToTuple(await instance.chatCompletion(options))
+    if (chatCompletionLeft !== undefined) {
+      return await controller.returnLeft(chatCompletionLeft)
+    }
+    const { completionTube } = chatCompletionRight
+
+    const newCompletionTube = new Tube<Completion>({ historyCount: Infinity, replayHistory: true })
+    // 无异常的情况下，上游数据直接传递给下游即可
+    connectTube(completionTube, newCompletionTube)
+
+    const timeoutFirstChunk = options.timeoutFirstChunk ?? this.options.timeoutFirstChunk
+    const timeoutPerChunk = options.timeoutPerChunk ?? this.options.timeoutPerChunk
+
+    // 定义首个数据块超时的处理逻辑
+    let hasReceivedFirstChunk = false
+    const firstChunkTimeoutTimer: NodeJS.Timeout = setTimeout(() => {
+      if (hasReceivedFirstChunk === false) {
+        this.logger.addOnceTags(["ConstrainSpeed"]).log("First chunk timeout")
+        void newCompletionTube.pushError(new Error("FirstChunkTimeout"))
+      }
+    }, timeoutFirstChunk)
+
+    // 定义相邻数据块超时的处理逻辑
+    let perChunkTimeoutTimer: NodeJS.Timeout | undefined
+    completionTube.subscribeData({
+      subscriber: () => {
+        if (hasReceivedFirstChunk === false) {
+          this.logger.addOnceTags(["ConstrainSpeed"]).log("Received first chunk, clear first chunk timeout timer")
+          hasReceivedFirstChunk = true
+          // Clear the timeout timer for the first chunk
+          clearTimeout(firstChunkTimeoutTimer)
+        }
+        else {
+          // Reset the timeout timer for each chunk
+          clearTimeout(perChunkTimeoutTimer)
+        }
+        // Set a new timeout timer for the next chunk
+        perChunkTimeoutTimer = setTimeout(() => {
+          this.logger.addOnceTags(["ConstrainSpeed"]).log("Per chunk timeout")
+          void newCompletionTube.pushError(new Error("PerChunkTimeout"))
+        }, timeoutPerChunk)
+      },
+    })
+    completionTube.subscribeEndEvent({
+      subscriber: () => {
+        this.logger.addOnceTags(["ConstrainSpeed"]).log("Source completion tube ended")
+        clearTimeout(firstChunkTimeoutTimer)
+        clearTimeout(perChunkTimeoutTimer)
+      },
+    })
+
+    return await controller.returnRight({
+      completionTube: newCompletionTube,
+    })
+  }
+}

package/src/ai/chat-completion-ai/chat-completion.ts

@@ -0,0 +1,189 @@
+import type * as Aio from "#Source/aio/index.ts"
+import type { WithAbortSignal } from "#Source/abort/index.ts"
+import type { Either } from "#Source/result/index.ts"
+import type { Tube } from "#Source/tube/index.ts"
+import type { StringWithAutoCompleteOptions } from "#Source/type/index.ts"
+import type { LoggerFriendly, LoggerFriendlyOptions } from "#Source/log/index.ts"
+import { Logger } from "#Source/log/index.ts"
+
+export interface ChatCompletionContentPartText {
+  /**
+   * The text content.
+   */
+  text: string
+  /**
+   * The type of the content part.
+   */
+  type: "text"
+}
+export interface ChatCompletionContentPartRefusal {
+  /**
+   * The refusal message generated by the model.
+   */
+  refusal: string
+  /**
+   * The type of the content part.
+   */
+  type: "refusal"
+}
+export interface ChatCompletionContentPartImage {
+  imageUrl: {
+    /**
+     * Either a URL of the image or the base64 encoded image data.
+     */
+    url: string
+    /**
+     * Specifies the detail level of the image. Learn more in the
+     * [Vision guide](https://platform.openai.com/docs/guides/vision/low-or-high-fidelity-image-understanding).
+     */
+    detail?: "auto" | "low" | "high"
+  }
+  /**
+   * The type of the content part.
+   */
+  type: "image_url"
+}
+export interface ChatCompletionSystemMessage {
+  /**
+   * The contents of the system message.
+   */
+  content: string | ChatCompletionContentPartText[]
+  /**
+   * The role of the messages author, in this case `system`.
+   */
+  role: "system"
+}
+export interface ChatCompletionUserMessage {
+  /**
+   * The contents of the user message.
+   */
+  content: string | Array<ChatCompletionContentPartText | ChatCompletionContentPartImage>
+  /**
+   * The role of the messages author, in this case `user`.
+   */
+  role: "user"
+}
+export interface ChatCompletionAssistantMessage {
+  /**
+   * The contents of the assistant message. Required unless `tool_calls` or
+   * `function_call` is specified.
+   */
+  content: string | Array<ChatCompletionContentPartText | ChatCompletionContentPartRefusal>
+  /**
+   * The role of the messages author, in this case `assistant`.
+   */
+  role: "assistant"
+}
+export type ChatCompletionMessage =
+  | ChatCompletionSystemMessage
+  | ChatCompletionUserMessage
+  | ChatCompletionAssistantMessage
+const CHAT_COMPLETION_MODEL_LIST = [
+  "o1-preview",
+  "o1-preview-2024-09-12",
+  "o1-mini",
+  "o1-mini-2024-09-12",
+  "gpt-4o",
+  "gpt-4o-2024-08-06",
+  "gpt-4o-2024-05-13",
+  "gpt-4o-realtime-preview-2024-10-01",
+  "chatgpt-4o-latest",
+  "gpt-4o-mini",
+  "gpt-4o-mini-2024-07-18",
+  "gpt-4-turbo",
+  "gpt-4-turbo-2024-04-09",
+  "gpt-4-0125-preview",
+  "gpt-4-turbo-preview",
+  "gpt-4-1106-preview",
+  "gpt-4-vision-preview",
+  "gpt-4",
+  "gpt-4-0314",
+  "gpt-4-0613",
+  "gpt-4-32k",
+  "gpt-4-32k-0314",
+  "gpt-4-32k-0613",
+  "gpt-3.5-turbo",
+  "gpt-3.5-turbo-16k",
+  "gpt-3.5-turbo-0301",
+  "gpt-3.5-turbo-0613",
+  "gpt-3.5-turbo-1106",
+  "gpt-3.5-turbo-0125",
+  "gpt-3.5-turbo-16k-0613",
+  "yi-lightning",
+  "hunyuan-standard",
+  "grok-3",
+  "gemini-2.0-flash-lite-preview-02-05",
+  "deepseek-r1",
+  "deepseek-v3",
+] as const
+export type ChatCompletionModel = typeof CHAT_COMPLETION_MODEL_LIST[number]
+export interface ResponseFormatText {
+  /**
+   * The type of response format being defined: `text`
+   */
+  type: "text"
+}
+export interface ResponseFormatJSONObject {
+  /**
+   * The type of response format being defined: `json_object`
+   */
+  type: "json_object"
+}
+export type ResponseFormat = ResponseFormatText | ResponseFormatJSONObject
+export interface ChatCompletionOptions extends WithAbortSignal {
+  messages: ChatCompletionMessage[]
+  model: ChatCompletionModel
+  frequencyPenalty?: number | null
+  logitBias?: Record<string, number> | null
+  logprobs?: boolean | null
+  maxCompletionTokens?: number | null
+  maxTokens?: number | null
+  presencePenalty?: number | null
+  responseFormat?: ResponseFormat
+  temperature?: number | null
+  topLogprobs?: number | null
+  topP?: number | null
+  /**
+   * The timeout for the first chunk of data to be received, in milliseconds.
+   */
+  timeoutFirstChunk?: number | undefined
+  /**
+   * The timeout for each chunk of data to be received, in milliseconds.
+   */
+  timeoutPerChunk?: number | undefined
+  /**
+   * The maximum number of tries for the request.
+   */
+  maxTries?: number | undefined
+}
+
+export interface ChatCompletionLeft {
+  code: StringWithAutoCompleteOptions<never>
+}
+export interface Completion {
+  content: Aio.TextContent
+  token: Aio.NumberContent
+}
+export interface ChatCompletionRight {
+  completionTube: Tube<Completion>
+}
+export type ChatCompletionResult = Either<ChatCompletionLeft, ChatCompletionRight>
+
+export interface BaseChatCompletionOptions extends LoggerFriendlyOptions {
+}
+export abstract class BaseChatCompletion implements LoggerFriendly {
+  readonly logger: Logger
+  private readonly supportedModelList: ChatCompletionModel[]
+
+  constructor(options: BaseChatCompletionOptions) {
+    this.logger = Logger.fromOptions(options).setDefaultName("BaseChatCompletion")
+
+    this.supportedModelList = [...CHAT_COMPLETION_MODEL_LIST]
+  }
+
+  isSupportModel(model: ChatCompletionModel): boolean {
+    return this.supportedModelList.includes(model)
+  }
+
+  abstract chatCompletion(options: ChatCompletionOptions): Promise<ChatCompletionResult>
+}

package/src/ai/chat-completion-ai/index.ts

@@ -0,0 +1,7 @@
+export * as ChatCompletionAi from "./chat-completion-ai.ts"
+
+export * as ChatCompletion from "./chat-completion.ts"
+export * as OpenaiNextChatCompletion from "./openai-next-chat-completion.ts"
+export * as OhmygptChatCompletion from "./ohmygpt-chat-completion.ts"
+export * as LingyiwanwuChatCompletion from "./lingyiwanwu-chat-completion.ts"
+export * as AihubmixChatCompletion from "./aihubmix-chat-completion.ts"

package/src/ai/chat-completion-ai/lingyiwanwu-chat-completion.ts

@@ -0,0 +1,78 @@
+import type * as Openai from "#Source/openai/index.ts"
+
+import type { BaseChatCompletionOptions, ChatCompletionOptions, ChatCompletionResult } from "./chat-completion.ts"
+import { BaseChatCompletion } from "./chat-completion.ts"
+
+export interface LingyiwanwuChatCompletionOptions extends BaseChatCompletionOptions {
+  openai: Openai.Openai
+}
+export class LingyiwanwuChatCompletion extends BaseChatCompletion {
+  protected readonly openai: Openai.Openai
+
+  constructor(options: LingyiwanwuChatCompletionOptions) {
+    super(options)
+    this.logger.setDefaultName("LingyiwanwuChatCompletion")
+
+    this.openai = options.openai
+  }
+
+  protected transformOptions(options: ChatCompletionOptions): Openai.CustomChatCompletionOptions {
+    const transformedOptions: Openai.CustomChatCompletionOptions = {
+      messages: options.messages.map((message) => {
+        const { role, content } = message
+        if (role === "system") {
+          return message
+        }
+        if (role === "user") {
+          if (typeof content === "string") {
+            return {
+              role,
+              content,
+            }
+          }
+          if (Array.isArray(content)) {
+            return {
+              role,
+              content: content.map((item) => {
+                if (item.type === "image_url") {
+                  return {
+                    type: item.type,
+                    image_url: item.imageUrl,
+                  }
+                }
+                else {
+                  return item
+                }
+              }),
+            }
+          }
+          throw new Error("Invalid content")
+        }
+        if (role === "assistant") {
+          return message
+        }
+        throw new Error("Invalid role")
+      }),
+      model: options.model,
+      ...(options.frequencyPenalty !== undefined ? { frequency_penalty: options.frequencyPenalty } : {}),
+      ...(options.logitBias !== undefined ? { logit_bias: options.logitBias } : {}),
+      ...(options.logprobs !== undefined ? { logprobs: options.logprobs } : {}),
+      ...(options.maxCompletionTokens !== undefined ? { max_completion_tokens: options.maxCompletionTokens } : {}),
+      ...(options.maxTokens !== undefined ? { max_tokens: options.maxTokens } : {}),
+      ...(options.presencePenalty !== undefined ? { presence_penalty: options.presencePenalty } : {}),
+      ...(options.responseFormat !== undefined ? { response_format: options.responseFormat } : {}),
+      ...(options.temperature !== undefined ? { temperature: options.temperature } : {}),
+      ...(options.topLogprobs !== undefined ? { top_logprobs: options.topLogprobs } : {}),
+      ...(options.topP !== undefined ? { top_p: options.topP } : {}),
+      timeout: options.timeoutFirstChunk ?? undefined,
+      abortSignal: options.abortSignal,
+    }
+    return transformedOptions
+  }
+
+  async chatCompletion(options: ChatCompletionOptions): Promise<ChatCompletionResult> {
+    const transformedOptions = this.transformOptions(options)
+    const result = await this.openai.customChatCompletionStreaming(transformedOptions)
+    return result
+  }
+}

package/src/ai/chat-completion-ai/ohmygpt-chat-completion.ts

@@ -0,0 +1,78 @@
+import type * as Openai from "#Source/openai/index.ts"
+
+import type { BaseChatCompletionOptions, ChatCompletionOptions, ChatCompletionResult } from "./chat-completion.ts"
+import { BaseChatCompletion } from "./chat-completion.ts"
+
+export interface OhmygptChatCompletionOptions extends BaseChatCompletionOptions {
+  openai: Openai.Openai
+}
+export class OhmygptChatCompletion extends BaseChatCompletion {
+  protected readonly openai: Openai.Openai
+
+  constructor(options: OhmygptChatCompletionOptions) {
+    super(options)
+    this.logger.setDefaultName("OhmygptChatCompletion")
+
+    this.openai = options.openai
+  }
+
+  protected transformOptions(options: ChatCompletionOptions): Openai.CustomChatCompletionOptions {
+    const transformedOptions: Openai.CustomChatCompletionOptions = {
+      messages: options.messages.map((message) => {
+        const { role, content } = message
+        if (role === "system") {
+          return message
+        }
+        if (role === "user") {
+          if (typeof content === "string") {
+            return {
+              role,
+              content,
+            }
+          }
+          if (Array.isArray(content)) {
+            return {
+              role,
+              content: content.map((item) => {
+                if (item.type === "image_url") {
+                  return {
+                    type: item.type,
+                    image_url: item.imageUrl,
+                  }
+                }
+                else {
+                  return item
+                }
+              }),
+            }
+          }
+          throw new Error("Invalid content")
+        }
+        if (role === "assistant") {
+          return message
+        }
+        throw new Error("Invalid role")
+      }),
+      model: options.model,
+      ...(options.frequencyPenalty !== undefined ? { frequency_penalty: options.frequencyPenalty } : {}),
+      ...(options.logitBias !== undefined ? { logit_bias: options.logitBias } : {}),
+      ...(options.logprobs !== undefined ? { logprobs: options.logprobs } : {}),
+      ...(options.maxCompletionTokens !== undefined ? { max_completion_tokens: options.maxCompletionTokens } : {}),
+      ...(options.maxTokens !== undefined ? { max_tokens: options.maxTokens } : {}),
+      ...(options.presencePenalty !== undefined ? { presence_penalty: options.presencePenalty } : {}),
+      ...(options.responseFormat !== undefined ? { response_format: options.responseFormat } : {}),
+      ...(options.temperature !== undefined ? { temperature: options.temperature } : {}),
+      ...(options.topLogprobs !== undefined ? { top_logprobs: options.topLogprobs } : {}),
+      ...(options.topP !== undefined ? { top_p: options.topP } : {}),
+      timeout: options.timeoutFirstChunk ?? undefined,
+      abortSignal: options.abortSignal,
+    }
+    return transformedOptions
+  }
+
+  async chatCompletion(options: ChatCompletionOptions): Promise<ChatCompletionResult> {
+    const transformedOptions = this.transformOptions(options)
+    const result = await this.openai.customChatCompletionStreaming(transformedOptions)
+    return result
+  }
+}