提示 API

[Exposed=Window, SecureContext]
interface LanguageModel : EventTarget {
  static Promise<LanguageModel> create(optional LanguageModelCreateOptions options = {});
  static Promise<Availability> availability(optional LanguageModelCreateCoreOptions options = {});
  // **EXPERIMENTAL**: 仅在扩展和实验性上下文中可用。
  static Promise<LanguageModelParams?> params();

  // 如果 role = "system"，这些将抛出 "NotSupportedError" DOMException
  Promise<DOMString> prompt(
    LanguageModelPrompt input,
    optional LanguageModelPromptOptions options = {}
  );
  ReadableStream promptStreaming(
    LanguageModelPrompt input,
    optional LanguageModelPromptOptions options = {}
  );
  Promise<undefined> append(
    LanguageModelPrompt input,
    optional LanguageModelAppendOptions options = {}
  );


  Promise<double> measureContextUsage(
    LanguageModelPrompt input,
    optional LanguageModelPromptOptions options = {}
  );
  readonly attribute double contextUsage;
  readonly attribute unrestricted double contextWindow;
  attribute EventHandler oncontextoverflow;

  // **DEPRECATED**: 此方法仅在扩展上下文中可用。
  Promise<double> measureInputUsage(
    LanguageModelPrompt input,
    optional LanguageModelPromptOptions options = {}
  );
  // **DEPRECATED**: 此属性仅在扩展上下文中可用。
  readonly attribute double inputUsage;
  // **DEPRECATED**: 此属性仅在扩展上下文中可用。
  readonly attribute unrestricted double inputQuota;
  // **DEPRECATED**: 此属性仅在扩展上下文中可用。
  attribute EventHandler onquotaoverflow;

  // **EXPERIMENTAL**: 仅在扩展和实验性上下文中可用。
  readonly attribute unsigned long topK;
  // **EXPERIMENTAL**: 仅在扩展和实验性上下文中可用。
  readonly attribute float temperature;

  Promise<LanguageModel> clone(optional LanguageModelCloneOptions options = {});
};
LanguageModel includes DestroyableModel;

// **EXPERIMENTAL**: 仅在扩展和实验性上下文中可用。
[Exposed=Window, SecureContext]
interface LanguageModelParams {
  readonly attribute unsigned long defaultTopK;
  readonly attribute unsigned long maxTopK;
  readonly attribute float defaultTemperature;
  readonly attribute float maxTemperature;
};


callback LanguageModelToolFunction = Promise<DOMString> (any... arguments);

// 语言模型可以调用的工具调用描述。
dictionary LanguageModelTool {
  required DOMString name;
  required DOMString description;
  // 输入参数的 JSON schema。
  required object inputSchema;
  // 由用户代理代表语言模型调用的函数。
  required LanguageModelToolFunction execute;
};

dictionary LanguageModelCreateCoreOptions {
  // 注：这两个具有自定义的越界处理行为，不在 IDL 层。
  // 它们是 unrestricted double，以便允许 +Infinity 而不失败。
  // **EXPERIMENTAL**: 仅在扩展和实验性上下文中可用。
  unrestricted double topK;
  // **EXPERIMENTAL**: 仅在扩展和实验性上下文中可用。
  unrestricted double temperature;

  sequence<LanguageModelExpected> expectedInputs;
  sequence<LanguageModelExpected> expectedOutputs;
  sequence<LanguageModelTool> tools;
};

dictionary LanguageModelCreateOptions : LanguageModelCreateCoreOptions {
  AbortSignal signal;
  CreateMonitorCallback monitor;

  sequence<LanguageModelMessage> initialPrompts;
};

dictionary LanguageModelPromptOptions {
  object responseConstraint;
  boolean omitResponseConstraintInput = false;
  AbortSignal signal;
};

dictionary LanguageModelAppendOptions {
  AbortSignal signal;
};

dictionary LanguageModelCloneOptions {
  AbortSignal signal;
};

dictionary LanguageModelExpected {
  required LanguageModelMessageType type;
  sequence<DOMString> languages;
};

// prompt() 方法及其他类似方法的参数

typedef (
  sequence<LanguageModelMessage>
  // `[{ role: "user", content: [{ type: "text", value: providedValue }] }]` 的简写
  or DOMString
) LanguageModelPrompt;

dictionary LanguageModelMessage {
  required LanguageModelMessageRole role;

  // DOMString 分支是 `[{ type: "text", value: providedValue }]` 的简写
  required (DOMString or sequence<LanguageModelMessageContent>) content;

  boolean prefix = false;
};

dictionary LanguageModelMessageContent {
  required LanguageModelMessageType type;
  required LanguageModelMessageValue value;
};

enum LanguageModelMessageRole { "system", "user", "assistant" };

enum LanguageModelMessageType { "text", "image", "audio", "tool-call", "tool-response" };

typedef (
  ImageBitmapSource
  or AudioBuffer
  or BufferSource
  or DOMString
) LanguageModelMessageValue;

静态 create(options) 方法步骤为：

1. 返回在给定 options、"language-model"、 验证并规范化语言模型选项、计算语言模型选项可用性、下载语言模型、初始化语言模型、创建语言模型对象 和 false 时，创建 AI 模型对象的结果。

要在给定 LanguageModelCreateCoreOptions options 时，验证并规范化语言模型选项，执行以下步骤。它们会就地改变 options，以规范化并去重语言标签；如果任何语言标签无效，则抛出异常。

1. 如果 options["expectedInputs"] 存在，则对 options["expectedInputs"] 的每个 expected 执行以下操作：

   1. 如果 expected["languages"] 存在，则在给定 expected 和 "languages" 时，验证并规范化语言标签。

2. 如果 options["expectedOutputs"] 存在，则对 options["expectedOutputs"] 的每个 expected 执行以下操作：

   1. 如果 expected["languages"] 存在，则在给定 expected 和 "languages" 时，验证并规范化语言标签。

3. 如果 options["initialPrompts"] 存在，则：

   1. 令 expectedInputs 为 options["expectedInputs"]， 如果它存在；否则为一个空列表。

   2. 令 expectedInputTypes 为在给定 expectedInputs 时，获取预期内容类型的结果。

   3. 在给定 options["initialPrompts"]、 expectedInputTypes 和 false 时，执行验证并规范化提示。

要在给定 LanguageModelCreateCoreOptions options 时，下载语言模型：

1. 断言：这些步骤正在并行运行。

2. 根据 options，为用户代理提示语言模型所需的一切启动下载过程。这可能包括基础 AI 模型、用于特定语言或选项值的微调，或其他资源。

3. 如果由于任何原因无法启动下载过程，则返回 false。

4. 返回 true。

要在给定 LanguageModelCreateOptions options 时，初始化语言模型：

1. 断言：这些步骤正在并行运行。

2. 令 availability 为在给定 options 时，计算语言模型选项可用性的结果。

   1. 如果 availability 为 null 或 unavailable， 则返回一个 DOMException 错误信息，其 name 为 "NotSupportedError"， 并且其 details 包含适当的详细信息。

3. 对支撑用户代理提示能力的 AI 模型执行任何必要的初始化操作。

   这可能包括将适当的模型以及支持 options 所需的任何微调加载到内存中。

   1. 如果 options["initialPrompts"] 存在，则：

      1. 令 expectedInputs 为 options["expectedInputs"]， 如果它存在；否则为一个空列表。

      2. 令 expectedInputTypes 为在给定 expectedInputs 时，获取预期内容类型的结果。

      3. 令 initialMessages 为在给定 options["initialPrompts"]、 expectedInputTypes 和 false 时，验证并规范化提示的结果。

      4. 将 initialMessages 加载到模型的上下文窗口中。

   2. 如果 options["tools"] 存在，则将 options["tools"] 加载到模型的上下文窗口中。

4. 如果初始化失败是因为加载 options 的过程用尽了模型的上下文窗口，则：

   1. 令 requested 为编码 options 所需的上下文窗口量。将 options 编码为输入的方式是实现定义的。

   2. 令 maximum 为用户代理支持的最大上下文窗口大小。

   3. 断言：requested 大于 maximum。（这就是我们到达此错误分支的方式。）

   4. 返回一个 配额超出错误信息，其 requested 为 requested，且 quota 为 maximum。

5. 如果初始化因任何其他原因失败，则返回一个 DOMException 错误信息，其 name 为 "OperationError"， 并且其 details 包含适当的详细信息。

6. 返回 null。

要在给定一个 realm realm 和一个 LanguageModelCreateOptions options 时，创建语言模型对象：

1. 断言：这些步骤正在 realm 的周围 agent 的事件循环上运行。

2. 令 contextWindowSize 为用户代理可用于此模型的上下文窗口量。（该值是实现定义的，并且如果除了例如用户内存限制或 JavaScript 字符串限制之外没有特定限制，则可以为 +∞。）

3. 令 initialMessages 为空的 LanguageModelMessage 列表。

4. 令 initialMessagesUsage 为 0。

5. 如果 options["initialPrompts"] 存在，则：

   1. 令 expectedInputs 为 options["expectedInputs"]， 如果它存在；否则为一个空列表。

   2. 令 expectedInputTypes 为在给定 expectedInputs 时，获取预期内容类型的结果。

   3. 将 initialMessages 设置为在给定 options["initialPrompts"]、 expectedInputTypes 和 false 时，验证并规范化提示的结果。

   4. 将 initialMessagesUsage 设置为在给定 initialMessages 和 options["signal"] 时，测量语言模型上下文使用量的结果。

6. 返回一个新的 LanguageModel 对象，该对象在 realm 中创建，并具有

   初始消息

   initialMessages

   top K

   options["topK"]， 如果它存在；否则为一个实现定义的值

   temperature

   options["temperature"]， 如果它存在；否则为一个实现定义的值

   预期输入

   options["expectedInputs"]， 如果它存在；否则为一个空列表

   预期输出

   options["expectedOutputs"]， 如果它存在；否则为一个空列表

   工具

   options["tools"]， 如果它存在；否则为一个空列表

   上下文窗口大小

   contextWindowSize

   当前上下文使用量

   initialMessagesUsage

静态 availability(options) 方法步骤为：

1. 返回在给定 options、"language-model"、 验证并规范化语言模型选项，以及 计算语言模型选项可用性时，计算 AI 模型可用性的结果。

要在给定 一个 LanguageModelCreateCoreOptions options 时，计算语言模型选项可用性，执行以下步骤。它们返回一个 Availability 值或 null，并且它们会就地改变 options，以将语言标签更新为其最佳匹配。

1. 断言：此算法正在并行运行。

2. 令 availability 为语言模型非选项可用性。

3. 如果 availability 为 null，则返回 null。

4. 令 availabilities 为一个包含 availability 的列表。

5. 令 inputPartition 为在给定以该语言提示语言模型这一目的时，获取语言可用性分区的结果。

6. 令 outputPartition 为在给定以该语言生成语言模型输出这一目的时，获取语言可用性分区的结果。

7. 如果 options["expectedInputs"] 存在，则对 options["expectedInputs"] 的每个 expected 执行以下操作：

   1. 如果 expected["languages"] 存在，则：

      1. 令 inputLanguageAvailability 为在给定 expected["languages"] 和 inputPartition 时，计算语言可用性的结果。

      2. 将 inputLanguageAvailability 追加到 availabilities。

   2. 令 inputTypeAvailability 为在给定 expected["type"] 和 true 时的语言模型内容类型可用性。

   3. 将 inputTypeAvailability 追加到 availabilities。

8. 如果 options["expectedOutputs"] 存在，则对 options["expectedOutputs"] 的每个 expected 执行以下操作：

   1. 如果 expected["languages"] 存在，则：

      1. 令 outputLanguageAvailability 为在给定 expected["languages"] 和 outputPartition 时，计算语言可用性的结果。

      2. 将 outputLanguageAvailability 追加到 availabilities。

   2. 令 outputTypeAvailability 为在给定 expected["type"] 和 false 时的语言模型内容类型可用性。

   3. 将 outputTypeAvailability 追加到 availabilities。

9. 返回在给定 availabilities 时的最小可用性。

语言模型非选项可用性由以下步骤给出。它们返回一个 Availability 值或 null。

1. 断言：此算法正在并行运行。

2. 如果在尝试确定用户代理是否能够支持提示语言模型时出现某些错误，而用户代理认为该错误是暂时性的（因此重新查询可能会停止产生此类错误），则返回 null。

3. 如果用户代理当前支持提示语言模型，则返回 "available"。

4. 如果用户代理认为它将能够支持提示语言模型，但只能在完成已经进行中的下载之后，则返回 "downloading"。

5. 如果用户代理认为它将能够支持提示语言模型，但只能在执行当前未进行的下载之后，则返回 "downloadable"。

6. 否则，返回 "unavailable"。

在给定一个 LanguageModelMessageType type 和一个 boolean isInput 时，语言模型内容类型可用性由以下步骤给出。它们返回一个 Availability 值。

1. 断言：此算法正在并行运行。

2. 如果用户代理当前支持 type 在 isInput 为 true 时作为输入，或在 isInput 为 false 时作为输出，则返回 "available"。

3. 如果用户代理认为它将能够支持 type 作为这种形式，但只能在完成已经进行中的下载之后，则返回 "downloading"。

4. 如果用户代理认为它将能够支持 type 作为这种形式，但只能在执行当前未进行的下载之后，则返回 "downloadable"。

5. 否则，返回 "unavailable"。

prompt(input, options) 方法步骤为：

1. 令 responseConstraint 为 options["responseConstraint"]， 如果它存在；否则为 null。

2. 令 omitResponseConstraintInput 为 options["omitResponseConstraintInput"]。

3. 令 operation 为一个算法步骤，它接受参数 chunkProduced、 done、error 和 stopProducing，并执行以下 步骤：

   1. 令 prefillSuccess 为在给定 this、 input、omitResponseConstraintInput、responseConstraint、 error 和 stopProducing 时，预填充的结果。

   2. 如果 prefillSuccess 为 true，则在给定 this、 responseConstraint、chunkProduced、done、 error 和 stopProducing 时生成。

4. 返回在给定 this、options 和 operation 时，获取聚合的 AI 模型结果的结果。

promptStreaming(input, options) 方法步骤为：

1. 令 responseConstraint 为 options["responseConstraint"]， 如果它存在；否则为 null。

2. 令 omitResponseConstraintInput 为 options["omitResponseConstraintInput"]。

3. 令 operation 为一个算法步骤，它接受参数 chunkProduced、 done、error 和 stopProducing，并执行以下 步骤：

   1. 令 prefillSuccess 为在给定 this、 input、omitResponseConstraintInput、responseConstraint、 error 和 stopProducing 时，预填充的结果。

   2. 如果 prefillSuccess 为 true，则在给定 this、 responseConstraint、chunkProduced、done、 error 和 stopProducing 时生成。

4. 返回在给定 this、options 和 operation 时，获取流式 AI 模型结果的结果。

append(input, options) 方法 步骤为：

1. 令 operation 为一个算法步骤，它接受参数 chunkProduced、 done、error 和 stopProducing，并执行以下 步骤：

   chunkProduced 从不会被调用，因为预填充算法不会 生成块。

   1. 令 prefillSuccess 为在给定 this、 input、false、null、error 和 stopProducing 时，预填充的结果。

   2. 如果 prefillSuccess 为 true 且 done 不为 null，则执行 done。

2. 返回在给定 this、options 和 operation 时，获取聚合的 AI 模型结果的结果。

measureContextUsage(input, options) 方法步骤为：

1. 如果 options["omitResponseConstraintInput"] 为 true，且 options["responseConstraint"] 不存在，则抛出一个 "TypeError" DOMException。

2. 令 expectedInputTypes 为在给定 this 的预期输入时，获取 预期内容类型的结果。

3. 令 messages 为在给定 input、expectedInputTypes 和 false 时，验证并规范化提示的结果。

4. 如果 options["responseConstraint"] 存在且不为 null，并且 options["omitResponseConstraintInput"] 为 false，则实现可以向 messages 插入一个实现定义的 LanguageModelMessage 来引导模型的行为。

5. 令 measureUsage 为一个算法步骤，它接受参数 stopMeasuring， 并返回在给定 messages 和 stopMeasuring 时，测量语言模型上下文 使用量的结果。

6. 返回在给定 this、options 和 measureUsage 时，测量 AI 模型输入使用量的结果。

measureInputUsage(input, options) 方法步骤为：

1. 返回在给定 input 和 options 时，运行 measureContextUsage() 方法步骤的结果。

clone(options) 方法步骤为：

1. 返回在给定 this 和 options 时，克隆语言模型的结果。

要在给定以下内容时预填充：

• 一个 LanguageModel model，

• 一个 LanguageModelPrompt input，

• 一个 boolean omitResponseConstraintInput，

• 一个 object-or-null responseConstraint，

• 一个 algorithm-or-null error，其接受错误信息且不返回任何内容，以及

• 一个 algorithm-or-null stopPrefilling，其不接受参数并返回一个 boolean，

执行以下步骤：

1. 断言：此算法正在并行运行。

2. 令 messages 为在给定 input、expectedInputTypes，以及当 model 的当前上下文使用量大于 0 时为 true、否则为 false 时，验证并规范化提示的结果。

   如果这抛出异常 e，则：

   1. 如果 error 不为 null，则在给定一个 DOMException 错误信息时执行 error，该错误信息的 name 是 e 的 name，且其 details 包含适当的详细信息。

   2. 返回 false。

3. 如果 responseConstraint 不为 null 且 omitResponseConstraintInput 为 false， 则实现可以向 messages 插入一个实现定义的 LanguageModelMessage 来引导模型的行为。

4. 令 requested 为在给定 messages 和 stopPrefilling 时，测量语言模型上下文使用量的结果。

5. 如果 requested 为 null，则返回 false。

6. 如果 requested 是错误信息，则：

   1. 如果 error 不为 null，则在给定 requested 时执行 error。

   2. 返回 false。

7. 断言：requested 是一个数字。

8. 如果 model 的当前上下文使用量 + requested 大于 model 的上下文窗口大小，则：

   1. 如果 error 不为 null，则：

      1. 令 errorInfo 为一个配额超出错误 信息，其 requested 为 model 的当前上下文使用量 + requested，且 quota 为 model 的上下文窗口大小。

      2. 在给定 errorInfo 时执行 error。

   2. 返回 false。

9. 令 expectedInputTypes 为在给定 model 的预期 输入时，获取 预期内容类型的结果。

10. 以实现定义的方式，更新底层模型的内部状态以包含 messages。

    该过程应使用 model 的初始 消息、model 的top K、model 的temperature、 model 的预期输入、model 的预期输出，以及 model 的tools 来引导状态如何更新。

    该过程必须符合 § 4 隐私考虑事项 和 § 5 安全考虑事项 中给出的指导。

    如果在此过程中 stopPrefilling 返回 true，则返回 false。

    如果预填充期间发生错误：

    1. 令该错误按照 § 3.3.4 错误 中的指导表示为错误信息 errorInfo。

    2. 如果 error 不为 null，则在给定 errorInfo 时执行 error。

    3. 返回 false。

11. 将 model 的当前上下文使用量设置为 model 的当前上下文使用量 + requested。

12. 返回 true。

要在给定以下内容时生成：

• 一个 LanguageModel model，

• 一个 object-or-null responseConstraint，

• 一个 algorithm-or-null chunkProduced，其接受一个字符串且不返回 任何内容，

• 一个 algorithm-or-null done，其不接受参数且不返回任何内容，

• 一个 algorithm-or-null error，其接受错误信息且不返回任何内容，以及

• 一个 algorithm-or-null stopProducing，其不接受参数并返回一个 boolean，

执行以下步骤：

1. 断言：此算法正在并行运行。

2. 以实现定义的方式，在遵循以下准则的前提下，开始基于语言模型 当前内部状态生成响应的过程。

   该过程应使用 model 的初始 消息、model 的top K、model 的temperature、 model 的预期输入、model 的预期输出、model 的tools，以及 responseConstraint 来引导 模型的行为。

   提示过程必须符合 § 4 隐私 考虑事项 和 § 5 安全考虑事项 中给出的指导。

   如果 model 的tools 非空，则模型可以通过调用其 execute 函数来使用所提供的 工具。

3. 当 true 时循环：

   1. 等待下一个响应数据块被生成，等待过程完成，或等待调用 stopProducing 的结果变为 true。

   2. 如果成功生成了这样的块：

      1. 令其表示为一个字符串 chunk。

      2. 如果 chunkProduced 不为 null，则在给定 chunk 时执行 chunkProduced。

   3. 否则，如果过程已经完成：

      1. 如果 done 不为 null，则执行 done。

      2. 中断。

   4. 否则，如果 stopProducing 返回 true，则中断。

   5. 否则，如果提示期间发生错误：

      1. 令该错误按照 § 3.3.4 错误 中的指导表示为错误信息 errorInfo。

      2. 如果 error 不为 null，则在给定 errorInfo 时执行 error。

      3. 中断。

要在给定以下内容时测量语言模型上下文使用量：

• 一个由 LanguageModelMessage messages 组成的列表，

• 一个算法 stopMeasuring，其不接受参数并返回一个 boolean，

执行以下步骤：

1. 断言：此算法正在并行运行。

2. 令 inputToModel 为为了在给定 messages 时进行预填充而会发送到底层模型的实现定义的输入。

   这通常会由所有输入的编码组成，可能还带有提示工程或其他实现定义的包装。

   如果在此过程中 stopMeasuring 开始返回 true，则返回 null。

   如果在此过程中发生错误，则按照 § 3.3.4 错误 中的指导返回适当的 DOMException 错误信息。

3. 返回在将 inputToModel 提供给底层模型时表示它所需的上下文使用量。确切的计算过程是实现定义的，但受以下约束限制。

   返回的上下文使用量必须是非负且有限的。它应大致与 inputToModel 中的数据量成比例。

   这可能是在语言模型分词方案中表示输入所需的 token 数，也可能 与数据的字节大小相关。

   如果在此过程中 stopMeasuring 开始返回 true，则改为返回 null。

   如果在此过程中发生错误，则改为按照 § 3.3.4 错误 中的指导返回适当的DOMException 错误信息。

要在给定一个由 LanguageModelExpected expectedContents 组成的列表时，获取 预期内容类型：

1. 令 expectedTypes 为一个空的 LanguageModelMessageType 列表。

2. 对 expectedContents 的每个 expected 执行以下操作：

   1. 如果 expectedTypes 不包含 expected["type"]， 则将 expected["type"] 追加到 expectedTypes。

3. 如果 expectedTypes 不包含 "text"， 则将 "text" 追加到 expectedTypes。

4. 返回 expectedTypes。

要在给定一个 LanguageModelPrompt input、一个由 LanguageModelMessageType expectedTypes 组成的列表，以及一个 boolean hasAppendedInput 时，验证并规范化提示，执行以下步骤。返回 值将是一个非空的、处于“完整形式”的 LanguageModelMessage 列表。

1. 断言：expectedTypes 包含 "text"。

2. 如果 input 是一个字符串，则返回 « «[ "role" → "user", "content" → « «[ "type" → "text", "value" → input ]» », "prefix" → false ]» »。

3. 断言：input 是一个由 LanguageModelMessage 组成的列表。

4. 如果 input 是一个空列表，则返回 « «[ "role" → "user", "content" → « «[ "type" → "text", "value" → "" ]» », "prefix" → false ]» »。

5. 令 messages 为一个空的 LanguageModelMessage 列表。

6. 对 input 的每个 message 执行以下操作：

   1. 如果 message["content"] 是一个字符串，则将 message 设置为 «[ "role" → message["role"], "content" → « «[ "type" → "text", "value" → message["content"] ]» », "prefix" → message["prefix"] ]»。

   2. 如果 message["prefix"] 为 true，则：

      1. 如果 message["role"] 不是 "assistant"， 则抛出一个 "SyntaxError" DOMException。

      2. 如果 message 不是 messages 中的最后一项，则抛出一个 "SyntaxError" DOMException。

   3. 如果 message["role"] 是 "system"， 则：

      1. 如果 hasAppendedInput 为 true，则抛出一个 "TypeError" DOMException。

   4. 如果 message["content"] 是一个空列表，则：

      1. 令 emptyContent 为一个新的 LanguageModelMessageContent， 其初始化为 «[ "type" → "text", "value" → "" ]»。

      2. 将 emptyContent 追加到 message["content"]。

   5. 对 message["content"] 的每个 content 执行以下操作：

      1. 如果 message["role"] 是 "assistant" 且 content["type"] 不是 "text"， 则抛出一个 "NotSupportedError" DOMException。

      2. 如果 content["type"] 是 "text" 且 content["value"] 不是一个字符串，则抛出一个 "TypeError" DOMException。

      3. 如果 content["type"] 是 "image"， 则：

         1. 如果 expectedTypes 不包含 "image"， 则抛出一个 "NotSupportedError" DOMException。

         2. 如果 content["value"] 既不是 ImageBitmapSource 也不是 BufferSource， 则抛出一个 "TypeError" DOMException。

      4. 如果 content["type"] 是 "audio"， 则：

         1. 如果 expectedTypes 不包含 "audio"， 则抛出一个 "NotSupportedError" DOMException。

         2. 如果 content["value"] 不是 AudioBuffer、 BufferSource 或 Blob， 则抛出一个 "TypeError" DOMException。

   6. 令 contentWithContiguousTextCollapsed 为空的 LanguageModelMessageContent 列表。

   7. 令 lastTextContent 为 null。

   8. 对 message["content"] 的每个 content 执行以下操作：

      1. 如果 content["type"] 是 "text"：

         1. 如果 lastTextContent 为 null：

            1. 将 content 追加到 contentWithContiguousTextCollapsed。

            2. 将 lastTextContent 设置为 content。

         2. 否则，将 lastTextContent["value"] 设置为 lastTextContent["value"] 与 content["value"] 的连接。

            不会添加空格或其他字符。因此，« «[ "type" → "text", "foo" ]», «[ "type" → "text", "bar" ]» » 被规范化为 « «[ "type" → "text", "foobar" ]»。

      2. 否则：

         1. 将 content 追加到 contentWithContiguousTextCollapsed。

         2. 将 lastTextContent 设置为 null。

      3. 将 message["content"] 设置为 contentWithContiguousTextCollapsed。

   9. 将 message 追加到 messages。

   10. 将 hasAppendedInput 设置为 true。

7. 如果 messages 为空， 则抛出一个 "SyntaxError" DOMException。

8. 返回 messages。

要在给定一个 LanguageModel model 和一个 LanguageModelCloneOptions options 时，克隆语言 模型：

1. 令 global 为 model 的相关全局对象。

2. 断言：global 是一个 Window 对象。

3. 如果 global 的关联 Document 不是完全活动的，则返回一个被拒绝的 promise，其拒绝原因为一个 "InvalidStateError" DOMException。

4. 令 signals 为 « model 的销毁中止 控制器的 signal »。

5. 如果 options["signal"] 存在，则 将其追加到 signals。

6. 令 compositeSignal 为在给定 signals 并使用 AbortSignal 和 model 的相关 realm 时，创建依赖中止信号的结果。

7. 如果 compositeSignal 已中止，则返回一个被拒绝的 promise，其拒绝原因为 compositeSignal 的中止原因。

8. 令 signal 为 options["signal"]， 如果它存在；否则为 null。

9. 如果 signal 不为 null 且已中止，则返回一个以 signal 的中止原因拒绝的 promise。

10. 令 promise 为在 model 的相关 realm中创建的新 promise。

11. 令 abortedDuringOperation 为 false。

    此变量将从事件循环写入，但从并行读取。

12. 向 compositeSignal 添加以下中止步骤：

    1. 将 abortedDuringOperation 设置为 true。

    2. 以 compositeSignal 的 中止原因拒绝 promise。

13. 并行：

    1. 在 AI 任务源上排入一个全局任务，以执行以下步骤：

       1. 如果 abortedDuringOperation 为 true，则返回。

       2. 令 clonedModel 为一个新的 LanguageModel 对象，其具有：

          • 初始消息 设置为 model 的初始消息。

          • top K 设置为 model 的top K。

          • temperature 设置为 model 的temperature。

          • 预期输入设置 为 model 的预期输入。

          • 预期输出 设置为 model 的预期输出。

          • tools 设置为 model 的tools。

          • 上下文窗口 大小设置为 model 的上下文窗口 大小。

          • 当前上下文 使用量设置为 model 的当前上下文 使用量。

       3. 以实现定义的方式， 将任何其他状态从 model 复制到 clonedModel。

       4. 如果复制操作失败：

          1. 以一个 "OperationError" DOMException 拒绝 promise。

          2. 返回。

       5. 以 clonedModel 解决 promise。

14. 返回 promise。