@planet-matrix/mobius-model 0.6.0 → 0.9.0

package/src/json/README.md

@@ -0,0 +1,92 @@
+# JSON
+
+## Description
+
+JSON 模块提供围绕 JSON（JavaScript Object Notation）这一数据表示格式的相关基础能力，用于承载与 JSON 本身直接相关、且值得长期稳定维护的公共语义。
+
+当前模块公开能力还很少，暂时只有 `repair` 这一项文本修复入口；但这不意味着模块边界仅限于修复本身，而是说明 JSON 相关能力仍在逐步沉淀中。
+
+## For Understanding
+
+理解 JSON 模块时，应把它看作一个围绕 JSON 本身建立的问题域模块，而不是一个泛化的数据清洗工具箱，也不是任意对象处理逻辑的收纳处。判断某项能力是否应进入这里，关键不在于它“碰巧输入或输出了 JSON”，而在于它是否直接服务于 JSON 这一表示格式本身的稳定语义。
+
+这类能力通常可能包括 JSON 文本修复、序列化与反序列化辅助、稳定格式化、合法性判断、边界明确的表示转换，或其它直接围绕 JSON 文本与 JSON 语义展开的基础能力。当前仓库里之所以只有 `repair`，只是因为模块还处在较早阶段，而不是因为其它 JSON 相关能力天然不属于这里。
+
+当前边界可以概括为：
+
+- 它可以承载与 JSON 本身直接相关的公共能力，而不局限于当前已经存在的 `repair`。
+- 它关注的是 JSON 作为表示格式时的稳定语义，而不是解析后对象在业务上的含义。
+- 它可以处理文本层问题，也可以在未来扩展到仍然属于 JSON 语义边界内的其它能力。
+- 它不应因为名称宽泛就退化成杂项对象工具箱或通用数据清洗工具箱。
+
+因此，这个模块不应承载对象结构校验、字段语义补全、领域模型迁移、容错合并或业务级默认值推导。那些问题可能发生在 JSON 之前或之后，也可能依赖 JSON 作为载体，但并不因此自动属于 JSON 模块。
+
+## For Using
+
+当你需要复用一类与 JSON 本身直接相关的基础能力，而不是在业务代码里零散处理 JSON 文本、解析入口或表示细节时，可以使用这个模块。当前最直接的使用场景，是在解析之前先修复接近 JSON、但带有轻微格式噪声的文本，例如人工编辑配置、LLM 输出、宽松的第三方接口返回、日志片段复制结果，或历史遗留系统吐出的近似 JSON 文本。
+
+当前公共能力可以从使用意图上理解为一类入口：
+
+- 文本修复入口：把接近 JSON 的字符串整理成可继续交给标准解析器处理的 JSON 文本。
+
+随着模块扩展，未来也可以继续容纳其它直接服务于 JSON 语义的公共入口。但即便如此，使用时仍应区分“JSON 本身的问题”和“业务对象的问题”：如果你的问题已经变成对象级校验、字段默认值注入、结构迁移或业务容错，那么应在其它模块或上层流程中继续分层，而不要把这些职责压回 JSON 模块。
+
+## For Contributing
+
+贡献 JSON 模块时，应优先判断新增能力是否直接表达 JSON 本身的稳定语义，而不是借着 JSON 的名字引入对象级处理、业务级清洗或协议级解释逻辑。这个模块可以继续增长，但增长方向应围绕 JSON 自身的问题域展开，而不是因为名字宽泛就无限吸纳一切与对象或文本有关的工具。
+
+在扩展时，应优先遵守以下边界：
+
+- 公共能力应直接围绕 JSON 本身展开，例如表示修复、合法性处理、稳定序列化或其它明确属于 JSON 语义的能力。
+- 不要把 schema 校验、字段补全、结构迁移、业务默认值或容错合并直接写成 JSON 模块的公共职责。
+- 若新增能力只是“使用了 JSON”但核心问题并不属于 JSON 本身，则应放在更合适的模块，而不是为了归类方便塞进这里。
+- 对于像 `repair` 这类带有容错性质的能力，应保持失败语义清楚；当输入不能被稳定处理时，抛错通常比返回含糊结果更符合模块边界。
+
+### JSDoc 注释格式要求
+
+- 每个公开导出的目标（类型、函数、变量、类等）都应包含 JSDoc 注释，让人在不跳转实现的情况下就能理解用途。
+- JSDoc 注释第一行应为清晰且简洁的描述，该描述优先使用中文（英文也可以）。
+- 如果描述后还有其他内容，应在描述后加一个空行。
+- 如果有示例，应使用 `@example` 标签，后接三重反引号代码块（不带语言标识）。
+- 如果有示例，应包含多个场景，展示不同用法，尤其要覆盖常见组合方式或边界输入。
+- 如果有示例，应使用注释格式说明每个场景：`// Expect: <result>`。
+- 如果有示例，应将结果赋值给 `example1`、`example2` 之类的变量，以保持示例易读。
+- 如果有示例，`// Expect: <result>` 应该位于 `example1`、`example2` 之前，以保持示例的逻辑清晰。
+- 如果有示例，应优先使用确定性示例；避免断言精确的随机输出。
+- 如果函数返回结构化字符串，应展示其预期格式特征。
+- 如果有参考资料，应将 `@see` 放在 `@example` 代码块之后，并用一个空行分隔。
+
+### 实现规范要求
+
+- 不同程序元素之间使用一个空行分隔，保持结构清楚。这里的程序元素，通常指函数、类型、常量，以及直接服务于它们的辅助元素。
+- 某程序元素独占的辅助元素与该程序元素本身视为一个整体，不要在它们之间添加空行。
+- 程序元素的辅助元素应该放置在该程序元素的上方，以保持阅读时的逻辑顺序。
+- 若辅助元素被多个程序元素共享，则应将其视为独立的程序元素，放在这些程序元素中第一个相关目标的上方，并与后续程序元素之间保留一个空行。
+- 辅助元素也应该像其它程序元素一样，保持清晰的命名和适当的注释，以便在需要阅读实现细节时能够快速理解它们的作用和使用方式。
+- 辅助元素的命名必须以前缀 `internal` 开头（或 `Internal`，大小写不敏感）。
+- 辅助元素永远不要公开导出。
+- 被模块内多个不同文件中的程序元素共享的辅助元素，应该放在一个单独的文件中，例如 `./src/json/internal.ts`；若当前模块仍然很小，则不必为了形式拆出没有稳定价值的共享文件。
+- 模块内可以包含子模块。只有当某个子目录表达一个稳定、可单独理解、且可能被父模块重导出的子问题域时，才应将其视为子模块。
+- 子模块包含多个文件时，应该为其单独创建子文件夹，并为其创建单独的 Barrel 文件；父模块的 Barrel 文件再重导出子模块的 Barrel 文件。
+- 子模块不需要有自己的 `README.md`。
+- 子模块可以有自己的 `internal.ts` 文件，多个子模块共享的辅助元素应该放在父模块的 `internal.ts` 文件中，单个子模块共享的辅助元素应该放在该子模块的 `internal.ts` 文件中。
+- 对模块依赖关系的要求（通常是不循环依赖或不反向依赖）与对 DRY 的要求可能产生冲突。此时，若复用的代码数量不大，可以适当牺牲 DRY，复制粘贴并保留必要的注释说明；若复用的代码数量较大，则可以将其抽象到新的文件或子模块中，如 `common.ts`，并在需要的地方导入使用。
+- 实现时应优先保持输入、输出与失败条件的语义清楚；若某项能力具有容错或修复性质，不应为了支持更多特例不断堆叠难以解释的隐式规则。
+
+### 导出策略要求
+
+- 保持内部辅助项和内部符号为私有，不要让外部接入依赖临时性的内部结构。
+- 每个模块都应有一个用于重导出所有公共 API 的 Barrel 文件。
+- Barrel 文件应命名为 `index.ts`，放在模块目录根部，并且所有公共 API 都应从该文件导出。
+- 新增公共能力时，应优先检查它是否表达稳定、清楚且值得长期维护的 JSON 模块语义，而不是某段实现细节的便捷暴露；仅在确认需要长期对外承诺时再加入 Barrel 导出。
+
+### 测试要求
+
+- 若程序元素是函数，则只为该函数编写一个测试，如果该函数需要测试多个用例，应放在同一个测试中。
+- 若程序元素是类，则至少要为该类的每一个方法编写一个测试，如果该方法需要测试多个用例，应放在同一个测试中。
+- 若程序元素是类，除了为该类的每一个方法编写至少一个测试之外，还可以为该类编写任意多个测试，以覆盖该类的不同使用场景或边界情况。
+- 若编写测试时需要用到辅助元素（Mock 或 Spy 等），可以在测试文件中直接定义这些辅助元素。若辅助元素较为简单，则可以直接放在每一个测试内部，优先保证每个测试的独立性，而不是追求极致 DRY；若辅助元素较为复杂或需要在多个测试中复用，则可以放在测试文件顶部，供该测试文件中的所有测试使用。
+- 测试顺序应与源文件中被测试目标的原始顺序保持一致。
+- 若该模块不需要测试，必须在说明文件中明确说明该模块不需要测试，并说明理由。一般来说，只有在该模块没有可执行的公共函数、只承载类型层表达，或其语义已被上层模块的测试完整覆盖且重复测试几乎不再带来额外价值时，才适合这样处理。
+- 模块的单元测试文件目录是 `./tests/unit/json`，若模块包含子模块，则子模块的单元测试文件目录为 `./tests/unit/json/<sub-module-name>`。
+- 测试应覆盖各公共能力各自的稳定语义。对于当前已有的 `repair`，重点覆盖可稳定修复的常见格式问题，以及超出修复边界时是否以明确失败结束，而不是返回含糊结果。

package/src/json/index.ts

@@ -0,0 +1 @@
+export * from "./repair.ts"

package/src/json/repair.ts

@@ -0,0 +1,18 @@
+import { jsonrepair } from "jsonrepair"
+
+/**
+ * 修复常见格式问题后的 JSON 文本字符串。
+ *
+ * 该函数面向“文本表示修复”这一问题：当输入接近 JSON、但包含单引号、未加引号的键名、尾随逗号等常见格式问题时，可以先把它整理成合法 JSON 文本，再交给后续解析流程。
+ *
+ * @example
+ * ```
+ * // Expect: "{\"foo\":1}"
+ * const example1 = repairJson("{foo:1,}")
+ * // Expect: "{\"name\":\"mobius\"}"
+ * const example2 = repairJson("{'name':'mobius',}")
+ * ```
+ */
+export const repairJson = (text: string): string => {
+  return jsonrepair(text)
+}

package/src/log/logger.ts

@@ -135,7 +135,8 @@ export class Logger implements Disposable {
     return logger
   }
 
-  protected name: string
+  protected defaultName: string
+  protected name?: string | undefined
   protected parent?: Logger | undefined
   protected childs: Logger[]
   protected parentConfigs?: LoggerConfigs | undefined
@@ -149,7 +150,8 @@ export class Logger implements Disposable {
   private cachedLogMethodMap: Map<string, (...messages: unknown[]) => this>
 
   constructor(options: LoggerOptions) {
-    this.name = options.name ?? "Unnamed"
+    this.defaultName = "Unnamed"
+    this.name = options.name
     this.parent = options.parent
     this.childs = []
     const parentConfigs = options.parent?.getConfigs()
@@ -170,17 +172,26 @@ export class Logger implements Disposable {
     this.cachedLogMethodMap = new Map()
   }
 
+  /**
+   * Set the default name if the current name is empty,
+   * and return the logger for chaining.
+   */
+  setDefaultName(name: string): this {
+    this.defaultName = name
+    return this
+  }
+
   /**
    * Get the logger display name.
    */
   getName(): string {
-    return this.name
+    return this.name ?? this.defaultName
   }
 
   /**
    * Set the logger display name.
    */
-  setName(name: string): this {
+  setName(name: string | undefined): this {
     this.name = name
     return this
   }

package/src/openai/README.md

@@ -0,0 +1 @@
+# Openai

package/src/openai/index.ts

@@ -0,0 +1 @@
+export * from "./openai.ts"

package/src/openai/openai.ts

@@ -0,0 +1,510 @@
+import type { ClientOptions } from "openai"
+import { OpenAI } from "openai"
+import type { Stream } from "openai/streaming"
+import { Agent, setGlobalDispatcher } from "undici"
+
+import type { LoggerFriendly, LoggerFriendlyOptions } from "#Source/log/index.ts"
+import type { WithAbortSignal } from "#Source/abort/index.ts"
+import type { Either } from "#Source/result/index.ts"
+
+import { Logger } from "#Source/log/index.ts"
+import * as Aio from "#Source/aio/index.ts"
+import { controllerFromEitherType } from "#Source/result/index.ts"
+import { Tube } from "#Source/tube/index.ts"
+import { scheduleMacroTask, streamConsumeInMacroTask, streamTransformInMacroTask } from "#Source/basic/index.ts"
+
+export { OpenAI } from "openai"
+export { Stream } from "openai/streaming"
+
+export interface WithOpenai {
+  openai: Openai
+}
+
+export interface OriginalChatCompletionOptions
+  extends Omit<OpenAI.Chat.ChatCompletionCreateParams, never>, WithAbortSignal {
+}
+export type OriginalChatCompletionResult = OpenAI.Chat.ChatCompletion
+export type OriginalChatCompletionChunkResult = OpenAI.Chat.Completions.ChatCompletionChunk
+
+export interface CustomChatCompletionOptions extends OriginalChatCompletionOptions {
+  /**
+   * In milliseconds.
+   */
+  timeout?: number | undefined
+}
+export interface CustomChatCompletionNonStreamingLeft {
+  code: "NO_CHOICE" | "TOO_LONG" | "FILTERED" | "REFUSED" | "EMPTY" | "UNKNOWN"
+}
+export interface CustomChatCompletionNonStreamingRight {
+  content: string
+  token: number
+}
+export type CustomChatCompletionNonStreamingResult
+  = Either<CustomChatCompletionNonStreamingLeft, CustomChatCompletionNonStreamingRight>
+
+export interface CustomChatCompletionStreamingLeft {
+  code: never
+}
+export interface Completion {
+  content: Aio.TextContent
+  token: Aio.NumberContent
+}
+export interface CustomChatCompletionStreamingRight {
+  completionTube: Tube<Completion>
+}
+export type CustomChatCompletionStreamingResult =
+  Either<CustomChatCompletionStreamingLeft, CustomChatCompletionStreamingRight>
+
+export interface OriginalEmbeddingOptions
+  extends OpenAI.Embeddings.EmbeddingCreateParams, WithAbortSignal {
+}
+export type OriginalEmbeddingResult = OpenAI.Embeddings.CreateEmbeddingResponse
+
+export interface CustomEmbeddingOptions extends WithAbortSignal {
+  input: string
+  model?: OpenAI.Embeddings.EmbeddingCreateParams["model"] | undefined
+  dimensions?: OpenAI.Embeddings.EmbeddingCreateParams["dimensions"] | undefined
+}
+export interface CustomEmbeddingResultLeft {
+  code: "NO_EMBEDDING" | "MODEL_MISMATCH" | "UNKNOWN"
+}
+export interface CustomEmbeddingResultRight {
+  embedding: number[]
+  usage: {
+    promptTokens: number
+    totalTokens: number
+  }
+}
+export type CustomEmbeddingResult =
+  Either<CustomEmbeddingResultLeft, CustomEmbeddingResultRight>
+
+export type CustomSpeechOptions = Omit<OpenAI.Audio.SpeechCreateParams, "input" | "model" | "voice" | "response_format"> & {
+  input: string
+}
+
+export interface OpenaiOptions extends LoggerFriendlyOptions {
+  apiKey: Exclude<ClientOptions["apiKey"], undefined | null>
+  baseUrl: Exclude<ClientOptions["baseURL"], undefined | null>
+  /**
+   * In milliseconds.
+   *
+   * @default 5 * 60 * 1000
+   */
+  timeout?: ClientOptions["timeout"] | undefined
+}
+interface ResolvedOpenaiOptions {
+  apiKey: Exclude<ClientOptions["apiKey"], undefined | null>
+  baseUrl: Exclude<ClientOptions["baseURL"], undefined | null>
+  timeout: Exclude<ClientOptions["timeout"], undefined | null>
+}
+export class Openai implements LoggerFriendly {
+  protected options: ResolvedOpenaiOptions
+
+  readonly logger: Logger
+  protected openai: OpenAI
+
+  constructor(options: OpenaiOptions) {
+    this.options = {
+      apiKey: options.apiKey,
+      baseUrl: options.baseUrl,
+      timeout: options.timeout ?? 5 * 60 * 1_000,
+    }
+
+    this.logger = Logger.fromOptions(options).setDefaultName("Openai")
+    this.openai = new OpenAI({
+      baseURL: this.options.baseUrl,
+      // NOTE: 若服务方证书出现问题可暂时开启这个选项，问题解决后应该第一时间关闭。
+      // fetch: this.customFetchThatIgnoreTheCAs,
+      timeout: this.options.timeout,
+      apiKey: this.options.apiKey,
+    })
+  }
+
+  protected async customFetchThatIgnoreTheCAs(
+    url: string, init?: RequestInit
+  ): Promise<Response> {
+    setGlobalDispatcher(new Agent({ connect: { rejectUnauthorized: false } }))
+
+    const response = await fetch(url, init)
+    if (response.ok === false) {
+      throw new Error(`Request failed with status ${response.status}`)
+    }
+
+    return response
+  }
+
+  getBaseUrl(): string {
+    return this.openai.baseURL
+  }
+
+  /**
+   * 原始 chatCompletion 方法的包装，但将其固定为非流式且不自动重试。
+   */
+  async originalChatCompletionNonStreaming(
+    options: OriginalChatCompletionOptions,
+  ): Promise<OriginalChatCompletionResult> {
+    try {
+      const { abortSignal, ...restOptions } = options
+      const response = await this.openai.chat.completions.create({
+        ...restOptions,
+        stream: false,
+      }, {
+        maxRetries: 0,
+        signal: abortSignal,
+      })
+      return response
+    }
+    catch (exception) {
+      this.logger.error("Error creating chat completion: ", exception)
+      throw exception
+    }
+  }
+
+  /**
+   * 原始 chatCompletion 方法的包装，但将其固定为流式且不自动重试。
+   */
+  async originalChatCompletionStreaming(
+    options: OriginalChatCompletionOptions,
+  ): Promise<Stream<OriginalChatCompletionChunkResult>> {
+    try {
+      const { abortSignal, ...restOptions } = options
+      const response = await this.openai.chat.completions.create({
+        ...restOptions,
+        stream: true,
+      }, {
+        maxRetries: 0,
+        signal: abortSignal,
+      })
+      return response
+    }
+    catch (exception) {
+      this.logger.error("Error creating chat completion: ", exception)
+      throw exception
+    }
+  }
+
+  /**
+   * 此方法不会自动重试，调用方需要通过错误信息自行处理。
+   *
+   * {@link https://platform.openai.com/docs/api-reference/chat | Chat - OpenAI API}
+   */
+  async customChatCompletionNonStreaming(
+    options: CustomChatCompletionOptions,
+  ): Promise<CustomChatCompletionNonStreamingResult> {
+    const controller = controllerFromEitherType<CustomChatCompletionNonStreamingResult>()
+    try {
+      const { abortSignal, ...restOptions } = options
+      const response = await this.openai.chat.completions.create({
+        ...restOptions,
+        stream: false,
+      }, {
+        maxRetries: 0,
+        signal: abortSignal,
+      })
+      const choice = response.choices[0]
+      if (choice === undefined) {
+        this.logger.error("Chat completion is empty.")
+        return await controller.returnLeft({ code: "NO_CHOICE" })
+      }
+
+      const finishReason = choice.finish_reason
+      if (finishReason === "length") {
+        this.logger.error("Chat completion is too long.")
+        return await controller.returnLeft({ code: "TOO_LONG" })
+      }
+      if (finishReason === "content_filter") {
+        this.logger.error("Chat completion is filtered.")
+        return await controller.returnLeft({ code: "FILTERED" })
+      }
+
+      const refusal = choice.message.refusal
+      if (refusal !== null && refusal !== undefined) {
+        this.logger.error(`Chat completion is refused: ${refusal}`)
+        return await controller.returnLeft({ code: "REFUSED" })
+      }
+      const content = choice.message.content
+      if (content === null) {
+        this.logger.error("Chat completion is empty.")
+        return await controller.returnLeft({ code: "EMPTY" })
+      }
+
+      return await controller.returnRight({
+        content,
+        // TODO: count the tokens
+        token: 0,
+      })
+    }
+    catch (exception) {
+      this.logger.error("Error creating chat completion: ", exception)
+      return await controller.returnLeft({ code: "UNKNOWN" })
+    }
+  }
+
+  async customChatCompletionStreaming(
+    options: CustomChatCompletionOptions,
+  ): Promise<CustomChatCompletionStreamingResult> {
+    const controller = controllerFromEitherType<CustomChatCompletionStreamingResult>()
+
+    const {
+      timeout = this.options.timeout,
+      abortSignal,
+    } = options
+    const openaiClient = this.openai
+    const logger = this.logger
+
+    const completionTube = new Tube<Completion>({
+      historyCount: Infinity,
+      replayHistory: true
+    })
+
+    const start = async (): Promise<void> => {
+      const { abortSignal: _, ...restOptions } = options
+      try {
+        // Pass the AbortSignal to the OpenAI request to support aborting
+        logger.log("Starting chat completion streaming.")
+        const response = await openaiClient.chat.completions.create(
+          {
+            ...restOptions,
+            stream: true,
+          },
+          {
+            timeout,
+            maxRetries: 0,
+            signal: abortSignal, // Include the abort signal in the request options
+          },
+        )
+        logger.log("Chat completion streaming started.")
+
+        // NOTE: 以下将 response 转换成 ReadableStream
+        const readableStream = streamTransformInMacroTask<Uint8Array, OriginalChatCompletionChunkResult>({
+          reader: response.toReadableStream().getReader(),
+          onChunk: (chunk, controller) => {
+            if (abortSignal !== undefined && abortSignal.aborted) {
+              logger.log("Original chat completion api's stream aborted by invoker.")
+              const error = new Error("Original chat completion api's stream aborted by invoker.")
+              controller.error(error)
+              return
+            }
+            if (chunk.done) {
+              logger.log("Original chat completion api's stream ended.")
+              controller.close()
+              return
+            }
+            const textDecoder = new TextDecoder()
+            const decoded = textDecoder.decode(chunk.value)
+            // oxlint-disable-next-line typescript/no-unsafe-type-assertion
+            const parsed = JSON.parse(decoded) as OriginalChatCompletionChunkResult
+            // logger.log("Original chat completion api's stream chunk:", JSON.stringify(parsed))
+            controller.enqueue(parsed)
+            return
+          },
+          onError: (error) => {
+            logger.error("Error reading original chat completion api's stream:", error)
+          },
+        })
+
+        const latestCompletion: Completion = {
+          content: {
+            deltaList: [],
+            total: "",
+          },
+          token: {
+            deltaList: [],
+            total: 0,
+          },
+        }
+
+        streamConsumeInMacroTask({
+          readableStream,
+          onValue: async (chunk) => {
+            // If the signal is aborted, break and stop the stream
+            if (abortSignal !== undefined && abortSignal.aborted) {
+              throw new Error("Stream aborted by abort signal")
+            }
+            const choice = chunk.choices[0]
+            if (choice === undefined) {
+              // NOTE: sometimes there will be no choice in the chunk, just skip the chunk
+              // Example chunk:
+              // {
+              //   "id": "chatcmpl-hTMAcJUVRpO5Etj64tdowhgpQalcP",
+              //   "object": "chat.completion.chunk",
+              //   "created": 1734481734,
+              //   "model": "gpt-4o-mini",
+              //   "choices": [],
+              //   "usage": {
+              //     "prompt_tokens": 2345,
+              //     "completion_tokens": 90,
+              //     "total_tokens": 2435,
+              //     "prompt_tokens_details": {
+              //       "cached_tokens": 0,
+              //       "audio_tokens": 0
+              //     },
+              //     "completion_tokens_details": {
+              //       "audio_tokens": 0
+              //     }
+              //   }
+              // }
+              return
+            }
+
+            const finishReason = choice.finish_reason
+            if (finishReason === "stop") {
+              // the model hit a natural stop point or a provided stop sequence, do nothing
+            }
+            if (finishReason === "length") {
+              // the maximum number of tokens specified in the request was reached
+              logger.error("Chat completion is too long.")
+            }
+            if (finishReason === "content_filter") {
+              logger.error("Chat completion is filtered.")
+              throw new Error("Chat completion is filtered.")
+            }
+
+            const refusal = choice.delta.refusal
+            if (refusal !== null && refusal !== undefined) {
+              logger.error(`Chat completion is refused: ${refusal}`)
+              throw new Error(`Chat completion is refused: ${refusal}`)
+            }
+
+            const deltaContent = choice.delta.content
+            if (deltaContent !== null && deltaContent !== undefined) {
+              latestCompletion.content = Aio.applyDeltaToTextContent(latestCompletion.content, {
+                type: "append",
+                text: deltaContent,
+              })
+              latestCompletion.token = Aio.applyDeltaToNumberContent(latestCompletion.token, {
+                type: "append",
+                value: 0,
+              })
+              await completionTube.pushData(structuredClone(latestCompletion))
+            }
+          },
+          onDone: async () => {
+            await completionTube.end()
+          },
+          onError: async (error) => {
+            await completionTube.pushError(error)
+          },
+        })
+      }
+      catch (exception) {
+        if (abortSignal !== undefined && abortSignal.aborted) {
+          logger.log("Original chat completion api's stream aborted by invoker.")
+          const error = new Error("Original chat completion api's stream aborted by invoker.")
+          await completionTube.pushError(error)
+        }
+        else {
+          logger.error("Error starting chat completion streaming: ", exception)
+          const error = new Error(`Error starting chat completion streaming, ${String(exception)}`)
+          await completionTube.pushError(error)
+        }
+      }
+    }
+    scheduleMacroTask({
+      task: async () => {
+        await start()
+      },
+    })
+
+    return await controller.returnRight({
+      completionTube,
+    })
+  }
+
+  /**
+   * 原始 embedding 方法的包装，将其最大重试次数固定为 0。
+   */
+  async originalEmbedding(
+    options: OriginalEmbeddingOptions
+  ): Promise<OriginalEmbeddingResult> {
+    const { abortSignal, ...restOptions } = options
+    try {
+      const response = await this.openai.embeddings.create({
+        ...restOptions,
+      }, {
+        maxRetries: 0,
+        signal: abortSignal,
+      })
+      return response
+    }
+    catch (exception) {
+      this.logger.error("Error creating embedding: ", exception)
+      throw exception
+    }
+  }
+
+  /**
+   * {@link https://platform.openai.com/docs/api-reference/embeddings | Embeddings - OpenAI API}
+   */
+  async customEmbedding(
+    options: CustomEmbeddingOptions
+  ): Promise<CustomEmbeddingResult> {
+    const controller = controllerFromEitherType<CustomEmbeddingResult>()
+    const logger = this.logger
+    try {
+      const {
+        abortSignal,
+        input,
+        model = "text-embedding-3-large",
+        // IMPORTANT: the number of dimensions should be 1536 currently, ask @kongxiangyan for more information.
+        dimensions = 1_536,
+      } = options
+      logger.log(`Creating embedding with model: ${model}, dimensions: ${dimensions}, input: ${input}`)
+      const response = await this.openai.embeddings.create({
+        input,
+        model,
+        dimensions,
+      }, {
+        maxRetries: 0,
+        signal: abortSignal,
+      })
+      logger.log("Get embedding response.")
+      // logger.log("Embedding response: ", JSON.stringify(response, null, 2))
+      if (response.data.length === 0) {
+        logger.error("Embedding is empty.")
+        return await controller.returnLeft({ code: "NO_EMBEDDING" })
+      }
+      if (response.model !== model) {
+        logger.error(`Model mismatch: ${response.model} !== ${model}`)
+        return await controller.returnLeft({ code: "MODEL_MISMATCH" })
+      }
+
+      const embedding = response.data[0]!.embedding
+      const promptTokens = response.usage.prompt_tokens
+      const totalTokens = response.usage.total_tokens
+      return await controller.returnRight({
+        embedding,
+        usage: {
+          promptTokens,
+          totalTokens,
+        },
+      })
+    }
+    catch (exception) {
+      logger.error("Error creating embedding: ", exception)
+      return await controller.returnLeft({ code: "UNKNOWN" })
+    }
+  }
+
+  /**
+   * {@link https://platform.openai.com/docs/api-reference/audio/createSpeech | Audio - OpenAI API}
+   */
+  async customSpeech(options: CustomSpeechOptions, stream?: boolean): Promise<Buffer> {
+    try {
+      const response = await this.openai.audio.speech.create({
+        ...options,
+        model: "tts-1",
+        voice: "alloy",
+        response_format: "opus",
+      }, {
+        stream: stream ?? false,
+      })
+      const buffer = Buffer.from(await response.arrayBuffer())
+      return buffer
+    }
+    catch (exception) {
+      this.logger.error("Error creating speech: ", exception)
+      throw exception
+    }
+  }
+}