@planet-matrix/mobius-model 0.5.0 → 0.9.0

package/tests/unit/abort/abort-signal-listener-manager.spec.ts

@@ -0,0 +1,62 @@
+import { expect, test } from "vitest"
+
+import {
+  AbortSignalListenerManager,
+  getGlobalAbortSignalListenerManager,
+} from "#Source/abort/index.ts"
+
+test("AbortSignalListenerManager.hasEventListener checks managed listener state", () => {
+  const manager = new AbortSignalListenerManager()
+  const abortController = new AbortController()
+  const listener = (): void => {
+    void abortController
+  }
+
+  expect(manager.hasEventListener(abortController.signal, listener)).toBe(false)
+
+  manager.addEventListener(abortController.signal, listener)
+
+  expect(manager.hasEventListener(abortController.signal, listener)).toBe(true)
+
+  manager.removeEventListener(abortController.signal, listener)
+
+  expect(manager.hasEventListener(abortController.signal, listener)).toBe(false)
+})
+
+test("AbortSignalListenerManager.addEventListener registers listener for abort events", () => {
+  const manager = new AbortSignalListenerManager()
+  const abortController = new AbortController()
+  let count = 0
+  const listener = (): void => {
+    count = count + 1
+  }
+
+  manager.addEventListener(abortController.signal, listener)
+
+  abortController.abort("stop")
+
+  expect(count).toBe(1)
+})
+
+test("AbortSignalListenerManager.removeEventListener unregisters listener", () => {
+  const manager = new AbortSignalListenerManager()
+  const abortController = new AbortController()
+  let count = 0
+  const listener = (): void => {
+    count = count + 1
+  }
+
+  manager.addEventListener(abortController.signal, listener)
+  manager.removeEventListener(abortController.signal, listener)
+
+  abortController.abort("stop")
+
+  expect(count).toBe(0)
+})
+
+test("getGlobalAbortSignalListenerManager returns singleton instance", () => {
+  const first = getGlobalAbortSignalListenerManager()
+  const second = getGlobalAbortSignalListenerManager()
+
+  expect(first).toBe(second)
+})

package/tests/unit/ai/ai.spec.ts

@@ -0,0 +1,85 @@
+import * as Ai from "#Source/ai/index.ts"
+import { Openai } from "#Source/openai/index.ts"
+import { eitherToTuple } from "#Source/result/index.ts"
+import { tubeToReadableStream } from "#Source/tube/index.ts"
+import { test } from "vitest"
+
+const testApiKey = "sk-DLj8aHvKjvHfZ7IHA2F07c968c3d4aE491C1525e40E24932"
+const testBaseUrl = "https://cn.api.openai-next.com/v1/"
+const ai = new Ai.Ai({
+  chatCompletionAiOptions: {
+    chatCompletionInstanceList: [
+      new Ai.ChatCompletionAi.OpenaiNextChatCompletion.OpenaiNextChatCompletion({
+        openai: new Openai({
+          apiKey: testApiKey,
+          baseUrl: testBaseUrl,
+        }),
+      }),
+    ],
+  },
+  embeddingAiOptions: {
+    embeddingInstanceList: [
+      new Ai.EmbeddingAi.OpenaiNextEmbedding.OpenaiNextEmbedding({
+        openai: new Openai({
+          apiKey: testApiKey,
+          baseUrl: testBaseUrl,
+        }),
+      }),
+    ],
+  },
+  instancePool: [
+    new Openai({
+      apiKey: testApiKey,
+      baseUrl: testBaseUrl,
+    }),
+  ],
+  indexChangeMode: "poll",
+})
+
+test("ai", { timeout: 60_000 }, async () => {
+  const 请求开始时间 = Date.now()
+  let 第一个字返回时间: number | null = null
+  let 累积文本 = ""
+
+  const [leftResult, rightResult] = eitherToTuple(await ai.chatCompletionAi.chatCompletion({
+    model: "gpt-4o-mini",
+    messages: [
+      {
+        role: "system",
+        content:
+          "你是一个返回JSON格式的AI助手, 预期的格式是: {\"回复内容\": string}. 你是小学生，有“雌小鬼”的性格。你瞧不起用户，经常称呼用户为“杂鱼”、“杂鱼大哥哥”等，表现出一种轻蔑和挑衅的态度。",
+      },
+      { role: "user", content: "你好" },
+    ],
+    responseFormat: { type: "json_object" },
+  }))
+  if (leftResult !== undefined) {
+    throw new Error(`请求失败: ${JSON.stringify(leftResult)}`)
+  }
+  const { completionTube: completionData } = rightResult
+  const stream = tubeToReadableStream(completionData)
+
+  try {
+    for await (const completion of stream) {
+      if (第一个字返回时间 === null) {
+        第一个字返回时间 = Date.now()
+      }
+      累积文本 = completion.content.total
+    }
+  }
+  catch (exception) {
+    throw new Error(`请求失败: ${String(exception)}`, { cause: exception })
+  }
+
+  if (第一个字返回时间 === null) { throw new Error("第一个字返回时间 为 null") }
+
+  const 请求结束时间 = Date.now()
+
+  const 第一个字时间 = 第一个字返回时间 - 请求开始时间
+  const 平均字返回时间 = (请求结束时间 - 请求开始时间) / 累积文本.length
+
+  console.log(`总返回时间: ${(请求结束时间 - 请求开始时间).toFixed(2)}ms`)
+  console.log(`第一个字返回时间: ${第一个字时间}ms`)
+  console.log(`平均每个字返回时间: ${平均字返回时间.toFixed(2)}ms`)
+  console.log(`返回的内容: %O`, 累积文本)
+})

package/tests/unit/aio/content.spec.ts

@@ -0,0 +1,105 @@
+import { expect, test } from "vitest"
+
+import {
+  applyDeltaToNumberContent,
+  applyDeltaToTextContent,
+} from "#Source/aio/index.ts"
+
+test("applyDeltaToTextContent appends, conditionally removes, resets and keeps prior snapshots immutable", () => {
+  const initial = {
+    deltaList: [],
+    total: "",
+  }
+
+  const appended = applyDeltaToTextContent(initial, {
+    type: "append",
+    text: "mobius",
+  })
+  const removed = applyDeltaToTextContent(appended, {
+    type: "remove",
+    text: "ius",
+  })
+  const unchangedRemove = applyDeltaToTextContent(removed, {
+    type: "remove",
+    text: "xyz",
+  })
+  const reset = applyDeltaToTextContent(unchangedRemove, {
+    type: "reset",
+  })
+
+  expect(initial).toEqual({
+    deltaList: [],
+    total: "",
+  })
+  expect(appended).toEqual({
+    deltaList: [{ type: "append", text: "mobius" }],
+    total: "mobius",
+  })
+  expect(removed).toEqual({
+    deltaList: [
+      { type: "append", text: "mobius" },
+      { type: "remove", text: "ius" },
+    ],
+    total: "mob",
+  })
+  expect(unchangedRemove).toEqual({
+    deltaList: [
+      { type: "append", text: "mobius" },
+      { type: "remove", text: "ius" },
+      { type: "remove", text: "xyz" },
+    ],
+    total: "mob",
+  })
+  expect(reset).toEqual({
+    deltaList: [
+      { type: "append", text: "mobius" },
+      { type: "remove", text: "ius" },
+      { type: "remove", text: "xyz" },
+      { type: "reset" },
+    ],
+    total: "",
+  })
+})
+
+test("applyDeltaToNumberContent accumulates, subtracts, resets and keeps prior snapshots immutable", () => {
+  const initial = {
+    deltaList: [],
+    total: 0,
+  }
+
+  const appended = applyDeltaToNumberContent(initial, {
+    type: "append",
+    value: 10,
+  })
+  const removed = applyDeltaToNumberContent(appended, {
+    type: "remove",
+    value: 3,
+  })
+  const reset = applyDeltaToNumberContent(removed, {
+    type: "reset",
+  })
+
+  expect(initial).toEqual({
+    deltaList: [],
+    total: 0,
+  })
+  expect(appended).toEqual({
+    deltaList: [{ type: "append", value: 10 }],
+    total: 10,
+  })
+  expect(removed).toEqual({
+    deltaList: [
+      { type: "append", value: 10 },
+      { type: "remove", value: 3 },
+    ],
+    total: 7,
+  })
+  expect(reset).toEqual({
+    deltaList: [
+      { type: "append", value: 10 },
+      { type: "remove", value: 3 },
+      { type: "reset" },
+    ],
+    total: 0,
+  })
+})

package/tests/unit/aio/json.spec.ts

@@ -0,0 +1,147 @@
+import { expect, test, vi } from "vitest"
+
+import type { StandardSchemaV1 } from "@standard-schema/spec"
+import { Logger } from "#Source/log/index.ts"
+import {
+  JsonModeResponseParser,
+  extractJsonBlock,
+} from "#Source/aio/index.ts"
+
+interface TestJsonOutput {
+  value: number
+  label?: string | undefined
+}
+
+const createSyncSchema = (
+  options: { validateCount?: { current: number } | undefined } = {}
+): StandardSchemaV1<unknown, TestJsonOutput> => {
+  const validateCount = options.validateCount
+
+  return {
+    "~standard": {
+      version: 1 as const,
+      vendor: "mobius-aio-json-sync-spec",
+      validate: (value: unknown): StandardSchemaV1.Result<TestJsonOutput> => {
+        if (validateCount !== undefined) {
+          validateCount.current = validateCount.current + 1
+        }
+
+        if (typeof value !== "object" || value === null) {
+          return {
+            issues: [{ message: "value must be an object" }],
+          }
+        }
+
+        // oxlint-disable-next-line typescript/no-unsafe-type-assertion
+        const record = value as Record<string, unknown>
+        if (typeof record["value"] !== "number") {
+          return {
+            issues: [{ message: "value must be a number" }],
+          }
+        }
+
+        const output: TestJsonOutput = {
+          value: record["value"],
+        }
+
+        if (typeof record["label"] === "string") {
+          output.label = record["label"]
+        }
+
+        return {
+          value: output,
+        }
+      },
+    },
+  }
+}
+
+const createAsyncSchema = (): StandardSchemaV1<unknown, TestJsonOutput> => {
+  return {
+    "~standard": {
+      version: 1 as const,
+      vendor: "mobius-aio-json-async-spec",
+      validate: async (_value: unknown): Promise<StandardSchemaV1.Result<TestJsonOutput>> => {
+        await Promise.resolve()
+
+        return {
+          value: {
+            value: 1,
+          },
+        }
+      },
+    },
+  }
+}
+
+test("extractJsonBlock returns the first fenced json block and throws when none exists", () => {
+  const response = [
+    "before",
+    "```json",
+    "{\"value\":1}",
+    "```",
+    "```json",
+    "{\"value\":2}",
+    "```",
+  ].join("\n")
+
+  expect(extractJsonBlock(response)).toBe(["```json", "{\"value\":1}", "```"].join("\n"))
+  expect(() => extractJsonBlock("plain text only")).toThrow("Failed to extract json block from response")
+})
+
+test("JsonModeResponseParser.extractJsonContent strips fences, repairs json-like content and falls back to raw text", () => {
+  const parser = new JsonModeResponseParser({
+    outputSchema: createSyncSchema(),
+  })
+
+  const repairedFromFence = parser.extractJsonContent(["header", "```json", "{value:1,}", "```"].join("\n"))
+  const repairedFromRawText = parser.extractJsonContent("{label:'mobius',value:2,}")
+
+  expect(repairedFromFence).toBe('\n{"value":1}\n')
+  expect(repairedFromRawText).toBe('{"label":"mobius","value":2}')
+})
+
+test("JsonModeResponseParser.parse validates sync output, caches by source text and throws for invalid or async schemas", () => {
+  const validateCount = { current: 0 }
+  const parser = new JsonModeResponseParser({
+    outputSchema: createSyncSchema({ validateCount }),
+  })
+
+  const first = parser.parse('{"value":1,"label":"ok"}')
+  const second = parser.parse('{"value":1,"label":"ok"}')
+
+  expect(first).toEqual({ value: 1, label: "ok" })
+  expect(second).toBe(first)
+  expect(validateCount.current).toBe(1)
+
+  const invalidParser = new JsonModeResponseParser({
+    outputSchema: createSyncSchema(),
+  })
+  expect(() => invalidParser.parse('{"label":"missing-value"}')).toThrow("Variable validation failed")
+
+  const asyncParser = new JsonModeResponseParser({
+    outputSchema: createAsyncSchema(),
+  })
+  expect(() => asyncParser.parse('{"value":1}')).toThrow("Validation result is a promise")
+})
+
+test("JsonModeResponseParser.check returns false and logs the failure context when parsing fails", () => {
+  const logger = new Logger({
+    name: "AioJsonTest",
+    configs: {
+      enabled: false,
+    },
+  })
+  const logSpy = vi.spyOn(logger, "log")
+  const parser = new JsonModeResponseParser({
+    logger,
+    outputSchema: createSyncSchema(),
+  })
+
+  expect(parser.check('{"value":3}')).toBe(true)
+  expect(parser.check('{"label":"missing-value"}')).toBe(false)
+
+  expect(logSpy).toHaveBeenCalledTimes(2)
+  expect(logSpy.mock.calls[0]?.[0]).toBe("check error:")
+  expect(logSpy.mock.calls[1]).toEqual(["error response:", '{"label":"missing-value"}'])
+})

package/tests/unit/aio/prompt.spec.ts

@@ -0,0 +1,111 @@
+import { expect, test } from "vitest"
+
+import {
+  Prompt,
+  emptyLine,
+  orderedListItem,
+  scopeContent,
+  text,
+  unorderedListItem,
+} from "#Source/aio/index.ts"
+
+test("text creates a plain text prompt block", () => {
+  expect(text("hello")).toEqual({
+    type: "text",
+    content: "hello",
+  })
+})
+
+test("emptyLine creates an empty-line prompt block", () => {
+  expect(emptyLine()).toEqual({
+    type: "empty-line",
+  })
+})
+
+test("scopeContent wraps content with triple-quote boundaries", () => {
+  expect(scopeContent("context")).toEqual({
+    type: "scope-content",
+    content: '"""\ncontext\n"""',
+  })
+})
+
+test("orderedListItem creates an ordered-list prompt block", () => {
+  expect(orderedListItem("first")).toEqual({
+    type: "ordered-list-item",
+    content: "first",
+  })
+})
+
+test("unorderedListItem creates an unordered-list prompt block", () => {
+  expect(unorderedListItem("first")).toEqual({
+    type: "unordered-list-item",
+    content: "first",
+  })
+})
+
+test("Prompt.addBlock appends a block produced by helpers and returns the same instance", async () => {
+  const prompt = new Prompt({})
+
+  expect(prompt.addBlock(helpers => helpers.text("from-helper"))).toBe(prompt)
+  await expect(prompt.getPromptInString()).resolves.toBe("from-helper")
+})
+
+test("Prompt.addText appends a text block", async () => {
+  const prompt = new Prompt({})
+
+  expect(prompt.addText("alpha")).toBe(prompt)
+  await expect(prompt.getPromptInString()).resolves.toBe("alpha")
+})
+
+test("Prompt.addEmptyLine appends an empty line block", async () => {
+  const prompt = new Prompt({})
+
+  expect(prompt.addEmptyLine()).toBe(prompt)
+  await expect(prompt.getPromptInString()).resolves.toBe("\r\n")
+})
+
+test("Prompt.addScopeContent appends a scoped content block", async () => {
+  const prompt = new Prompt({})
+
+  expect(prompt.addScopeContent("body")).toBe(prompt)
+  await expect(prompt.getPromptInString()).resolves.toBe('"""\nbody\n"""')
+})
+
+test("Prompt.addOrderedListItem appends an ordered list block", async () => {
+  const prompt = new Prompt({})
+
+  expect(prompt.addOrderedListItem("step")).toBe(prompt)
+  await expect(prompt.getPromptInString()).resolves.toBe("1. step")
+})
+
+test("Prompt.addUnorderedListItem appends an unordered list block", async () => {
+  const prompt = new Prompt({})
+
+  expect(prompt.addUnorderedListItem("item")).toBe(prompt)
+  await expect(prompt.getPromptInString()).resolves.toBe("- item")
+})
+
+test("Prompt.getPromptInString renders prompt blocks with list numbering and resets between block groups", async () => {
+  const prompt = new Prompt({})
+
+  prompt
+    .addText("Intro")
+    .addOrderedListItem("First")
+    .addOrderedListItem("Second")
+    .addText("Break")
+    .addOrderedListItem("Reset")
+    .addUnorderedListItem("One")
+    .addUnorderedListItem("Two")
+    .addScopeContent("body")
+
+  await expect(prompt.getPromptInString()).resolves.toBe([
+    "Intro",
+    "1. First",
+    "2. Second",
+    "Break",
+    "1. Reset",
+    "- One",
+    "- Two",
+    '"""\nbody\n"""',
+  ].join("\r\n"))
+})

package/tests/unit/basic/array.spec.ts

@@ -192,7 +192,7 @@ test("arrayAny aliases arraySome", () => {
 
 test("arrayForEach applies the callback", () => {
   const target: number[] = []
-  arrayForEach((item) => target.push(item * 2), [1, 2, 3])
+  arrayForEach((item) => { target.push(item * 2) }, [1, 2, 3])
   expect(target).toEqual([2, 4, 6])
 })
 

package/tests/unit/basic/error.spec.ts

@@ -2,7 +2,8 @@ import { expect, test } from "vitest"
 
 import {
   errorIsNetworkError,
-  errorStringifyException,
+  errorStringify,
+  toError,
 } from "#Source/basic/index.ts"
 
 test("errorIsNetworkError returns expected values", () => {
@@ -26,7 +27,18 @@ test("errorIsNetworkError returns expected values", () => {
   expect(errorIsNetworkError(safariWithStack)).toBe(false)
 })
 
-test("errorStringifyException returns readable output", () => {
-  expect(errorStringifyException(new Error("boom"))).toBe("Error: boom")
-  expect(errorStringifyException(123)).toBe("123")
+test("errorStringify returns readable output", () => {
+  expect(errorStringify(new Error("boom"))).toBe("Error: boom")
+  expect(errorStringify(123)).toBe("123")
+})
+
+test("toError returns expected values", () => {
+  const error = new Error("boom")
+
+  expect(toError(error)).toBe(error)
+
+  const wrappedError = toError(123)
+
+  expect(wrappedError).toBeInstanceOf(Error)
+  expect(wrappedError.message).toBe("123")
 })

package/tests/unit/basic/schedule.spec.ts

@@ -0,0 +1,74 @@
+import { expect, test, vi } from "vitest"
+
+import {
+  scheduleMacroTask,
+  scheduleMacroTaskSimple,
+  scheduleMicroTask,
+  scheduleMicroTaskSimple,
+} from "#Source/basic/index.ts"
+
+test("scheduleMicroTaskSimple schedules a task in the microtask queue", async () => {
+  const values: string[] = []
+
+  scheduleMicroTaskSimple(() => {
+    values.push("micro")
+  })
+
+  expect(values).toEqual([])
+
+  await Promise.resolve()
+
+  expect(values).toEqual(["micro"])
+})
+
+test("scheduleMacroTaskSimple schedules a task in the macrotask queue", async () => {
+  vi.useFakeTimers()
+  const values: string[] = []
+
+  scheduleMacroTaskSimple(() => {
+    values.push("macro")
+  })
+
+  expect(values).toEqual([])
+
+  await vi.runAllTimersAsync()
+
+  expect(values).toEqual(["macro"])
+  vi.useRealTimers()
+})
+
+test("scheduleMicroTask schedules async-capable tasks in the microtask queue", async () => {
+  const values: string[] = []
+
+  scheduleMicroTask({
+    task: () => {
+      values.push("micro")
+    },
+  })
+
+  expect(values).toEqual([])
+
+  await Promise.resolve()
+  await Promise.resolve()
+
+  expect(values).toEqual(["micro"])
+})
+
+test("scheduleMacroTask schedules async-capable tasks with timeout", async () => {
+  vi.useFakeTimers()
+  const values: string[] = []
+
+  scheduleMacroTask({
+    timeout: 25,
+    task: () => {
+      values.push("macro")
+    },
+  })
+
+  await vi.advanceTimersByTimeAsync(24)
+  expect(values).toEqual([])
+
+  await vi.advanceTimersByTimeAsync(1)
+  expect(values).toEqual(["macro"])
+  vi.useRealTimers()
+})