@planet-matrix/mobius-model 0.6.0 → 0.10.1

package/CHANGELOG.md

@@ -1,5 +1,55 @@
 # @planet-matrix/mobius-model
 
+## 0.10.1
+
+### Patch Changes
+
+- d7c33d7: Add `dist` to `.npmignore`.
+
+## 0.10.0
+
+### Minor Changes
+
+- 6f99535: Add service model.
+- 9520154: Add tagged error capabilities to exception model.
+
+## 0.9.0
+
+### Minor Changes
+
+- f5cd790: Add weixin model.
+- fae630f: Add ai model.
+- 6e132e6: Add openai model.
+
+## 0.8.0
+
+### Minor Changes
+
+- 3c736c0: Add http model.
+- 5036bdb: Add drizzle model.
+- fefbfef: 优化 basic steam，新增 basic schedule。
+- 5a9fb9d: Add cron model.
+- f101d98: Add http model.
+- de21d1f: Add email model.
+- 84e76bc: Enhance logger functionality with default names for various components.
+- 8146954: Implement Scheduler and Task classes with logging functionality and tests.
+- faa0f2d: Add huawei model, include moderation and obs functionalities.
+- 8421836: Add tube model.
+
+## 0.7.0
+
+### Minor Changes
+
+- cbe190c: Add request model.
+- 730cb8b: Add socket model.
+- 7511df7: Add result model.
+- a97b489: Add form model.
+- 44cbf55: Add aio model.
+- 8ec2d59: Add route model.
+- 73cb3ea: Implement dispatcher and down-count selector for orchestration model.
+- 5452bbe: Add json model.
+- c1afa6e: Add credential model.
+
 ## 0.6.0
 
 ### Minor Changes

package/oxlint.config.ts

@@ -1,6 +1,5 @@
-import { defineConfig } from "oxlint"
 import { Lint } from "@planet-matrix/mobius-mono"
 
-const config: Lint.OxlintConfig = defineConfig(Lint.defineOxlintConfig({}))
+const config: Lint.OxlintConfig = Lint.defineOxlintConfig({})
 
 export default config

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@planet-matrix/mobius-model",
-  "version": "0.6.0",
+  "version": "0.10.1",
   "description": "Mobius model.",
   "keywords": [
     "mobius",
@@ -32,19 +32,19 @@
     }
   },
   "imports": {
-    "#Project/*": {
-      "import": {
-        "@planet-matrix/mobius-mono": "./*",
-        "bun": "./*",
-        "default": "./*"
-      }
-    },
     "#Source/*": {
       "import": {
         "@planet-matrix/mobius-mono": "./src/*",
         "bun": "./src/*",
         "default": "./src/*"
       }
+    },
+    "#Project/*": {
+      "import": {
+        "@planet-matrix/mobius-mono": "./*",
+        "bun": "./*",
+        "default": "./*"
+      }
     }
   },
   "repository": {
@@ -59,21 +59,33 @@
     "prepublishOnly": "bun run build"
   },
   "dependencies": {
+    "typescript": "^6.0.2",
     "ua-parser-js": "^2.0.9",
     "html-to-image": "^1.11.13",
+    "undici": "^7.24.6",
+    "ws": "^8.20.0",
+    "@types/ws": "^8.18.1",
     "@standard-schema/spec": "^v1.1.0",
     "arktype": "^2.2.0",
-    "@dotenvx/dotenvx": "^1.54.1"
+    "zod": "^4.3.6",
+    "@dotenvx/dotenvx": "^1.59.1",
+    "jsonrepair": "^3.13.3",
+    "jose": "^6.2.2",
+    "croner": "^10.0.1",
+    "drizzle-orm": "^0.45.2",
+    "resend": "^6.9.4",
+    "esdk-obs-nodejs": "^3.26.2",
+    "openai": "^6.33.0"
   },
   "devDependencies": {
-    "@planet-matrix/mobius-mono": "0.8.0",
-    "@types/bun": "^1.3.10",
-    "oxlint": "^1.55.0",
-    "oxlint-tsgolint": "^0.16.0",
-    "typescript": "^5.9.3",
-    "@typescript/native-preview": "^7.0.0-dev.20260311.1",
-    "vite": "^8.0.0",
-    "vitest": "^4.1.0"
+    "@planet-matrix/mobius-mono": "0.10.1",
+    "@types/bun": "^1.3.11",
+    "@typescript/native-preview": "^7.0.0-dev.20260329.1",
+    "oxlint": "^1.57.0",
+    "oxlint-tsgolint": "^0.18.1",
+    "vitest": "^4.1.2",
+    "vite": "^8.0.3",
+    "drizzle-kit": "^0.31.10"
   },
   "peerDependencies": {},
   "peerDependenciesMeta": {},

package/scripts/build.ts

@@ -1,53 +1,3 @@
-import { $, build } from "bun"
+import { Build } from "@planet-matrix/mobius-mono"
 
-// ensure the outdir is existing and cleaned up before building
-console.log("Cleaning and preparing ./dist directory...")
-await $`rm -rf dist`
-
-// console.log("Building TypeScript declarations...")
-// await $`bun run tsgo --noEmit false`
-
-console.log("Building the library with Bun...")
-const builtOutput = await build({
-  banner: "// Enjoy using Example Library!",
-  bytecode: false,
-  conditions: [],
-  define: {},
-  drop: [],
-  emitDCEAnnotations: false,
-  entrypoints: ["./src/index.ts"],
-  env: "PUBLIC_*",
-  external: [],
-  footer: "// Made with ♥ by the Planet Matrix team!",
-  format: "esm",
-  ignoreDCEAnnotations: false,
-  loader: {},
-  minify: {
-    identifiers: true,
-    keepNames: false,
-    syntax: true,
-    whitespace: true,
-  },
-  naming: {
-    entry: '[dir]/[name].[ext]',
-    chunk: '[name]-[hash].[ext]',
-    asset: '[name]-[hash].[ext]',
-  },
-  outdir: "./dist",
-  packages: "bundle",
-  plugins: [],
-  // publicPath: undefined,
-  // root: undefined,
-  sourcemap: "linked",
-  splitting: true,
-  target: "bun",
-  throw: false,
-  tsconfig: "./tsconfig.json",
-})
-
-if (builtOutput.success === false) {
-  console.error('Build failed:', builtOutput.logs);
-  throw new Error('Build process failed.');
-} else {
-  console.log("Build completed successfully.");
-}
+await Build.Library.build({})

package/src/ai/README.md

@@ -0,0 +1 @@
+# Ai

package/src/ai/ai.ts

@@ -0,0 +1,107 @@
+import type * as Openai from "#Source/openai/index.ts"
+import type { LoggerFriendly, LoggerFriendlyOptions } from "#Source/log/index.ts"
+import { Logger } from "#Source/log/index.ts"
+import { randomIntBetween } from "#Source/basic/index.ts"
+
+import * as ChatCompletionAi from "./chat-completion-ai/index.ts"
+import * as EmbeddingAi from "./embedding-ai/index.ts"
+
+export type ChatCompletionOptions = Openai.OriginalChatCompletionOptions
+export type EmbeddingOptions = Openai.CustomEmbeddingOptions
+
+export interface WithAi {
+  ai: Ai
+}
+export interface AiOptions extends LoggerFriendlyOptions {
+  chatCompletionAiOptions?: ChatCompletionAi.ChatCompletionAi.ChatCompletionAiOptions | undefined
+  embeddingAiOptions?: EmbeddingAi.EmbeddingAi.EmbeddingAiOptions | undefined
+  /**
+   * @deprecated
+   */
+  instancePool: Openai.Openai[]
+  /**
+   * @deprecated
+   */
+  indexChangeMode?: "random" | "poll"
+}
+export class Ai implements LoggerFriendly {
+  readonly logger: Logger
+
+  readonly chatCompletionAi: ChatCompletionAi.ChatCompletionAi.ChatCompletionAi
+  readonly embeddingAi: EmbeddingAi.EmbeddingAi.EmbeddingAi
+
+  protected instancePool: Openai.Openai[]
+  protected indexChangeMode: "random" | "poll"
+  protected index = 0
+
+  constructor(options: AiOptions) {
+    this.logger = Logger.fromOptions(options).setDefaultName("Ai")
+
+    this.chatCompletionAi = new ChatCompletionAi.ChatCompletionAi.ChatCompletionAi(options.chatCompletionAiOptions ?? {
+      chatCompletionInstanceList: [],
+    })
+    this.embeddingAi = new EmbeddingAi.EmbeddingAi.EmbeddingAi(options.embeddingAiOptions ?? {
+      embeddingInstanceList: [],
+    })
+
+    this.instancePool = options.instancePool
+    this.indexChangeMode = options.indexChangeMode ?? "random"
+  }
+
+  protected changeIndex(): void {
+    this.logger.info(`chang instance index, mode: ${this.indexChangeMode}`)
+
+    switch (this.indexChangeMode) {
+      case "random": {
+        this.index = randomIntBetween(0, this.instancePool.length - 1)
+        break
+      }
+      case "poll": {
+        this.index = this.index + 1
+        if (this.index >= this.instancePool.length - 1) {
+          this.index = 0
+        }
+        break
+      }
+      default: {
+        throw new Error(`unknown indexChangeMode: ${String(this.indexChangeMode)}`)
+      }
+    }
+
+    this.logger.info(`change instance index success: ${this.index}`)
+  }
+
+  protected async getInstance(): Promise<Openai.Openai> {
+    this.logger.info(`get instance index: ${this.index}`)
+
+    const instance = this.instancePool[this.index]
+    if (instance === undefined) {
+      throw new Error("can not find instance")
+    }
+
+    this.logger.info(`get instance success, index: ${this.index}`)
+    this.logger.info(`get instance success, baseUrl: ${instance.getBaseUrl()}`)
+    return await Promise.resolve(instance)
+  }
+
+  protected async changeIndexAndGetInstance(): Promise<Openai.Openai> {
+    this.changeIndex()
+    return await this.getInstance()
+  }
+
+  /**
+   * @deprecated
+   */
+  async originalChatCompletionNoStreaming(options: ChatCompletionOptions): Promise<Openai.OriginalChatCompletionResult> {
+    const instance = await this.changeIndexAndGetInstance()
+    return await instance.originalChatCompletionNonStreaming(options)
+  }
+
+  /**
+   * @deprecated
+   */
+  async originalChatCompletionStreaming(options: ChatCompletionOptions): Promise<Openai.Stream<Openai.OriginalChatCompletionChunkResult>> {
+    const instance = await this.changeIndexAndGetInstance()
+    return await instance.originalChatCompletionStreaming(options)
+  }
+}

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,
+    })
+  }
+}